claude-flow 2.5.0-alpha.141 → 2.7.0-alpha

package/docs/development/DEPLOYMENT.md

@@ -0,0 +1,2348 @@
+# 🚀 Claude-Flow Production Deployment Guide
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [System Requirements](#system-requirements)
+- [Environment Variables](#environment-variables)
+- [Docker Deployment](#docker-deployment)
+- [Kubernetes Deployment](#kubernetes-deployment)
+- [CI/CD Pipeline](#cicd-pipeline)
+- [Monitoring & Observability](#monitoring--observability)
+- [Security Configuration](#security-configuration)
+- [Load Balancing](#load-balancing)
+- [Production Setup](#production-setup)
+- [Cloud Deployment](#cloud-deployment)
+- [Troubleshooting](#troubleshooting)
+
+---
+
+## Quick Start
+
+### Production Installation
+
+```bash
+# Install from npm registry
+npm install -g claude-flow@alpha
+
+# Verify installation
+npx claude-flow@alpha --version
+
+# Initialize configuration
+npx claude-flow@alpha init --force
+
+# Test installation
+npx claude-flow@alpha swarm "test deployment" --agents 3
+```
+
+### Prerequisites Check
+
+```bash
+# Check Node.js version (requires ≥20.0.0)
+node --version
+
+# Check npm version (requires ≥9.0.0)
+npm --version
+
+# Check system resources
+free -h  # Memory check
+df -h    # Disk space check
+
+# Install required tools
+apt-get update && apt-get install -y curl wget jq
+```
+
+---
+
+## System Requirements
+
+### Production Requirements
+
+| Component | Minimum | Recommended | Enterprise |
+|-----------|---------|-------------|------------|
+| Node.js | v20.0.0 | v20 LTS | v20 LTS |
+| RAM | 4 GB | 8 GB | 16 GB |
+| CPU | 2 cores | 4 cores | 8+ cores |
+| Disk Space | 2 GB | 10 GB | 50 GB |
+| Network | 100 Mbps | 1 Gbps | 10 Gbps |
+| Uptime SLA | 99% | 99.9% | 99.99% |
+
+### Operating System Support
+
+- **Linux**: Ubuntu 20.04+, CentOS 8+, RHEL 8+, Amazon Linux 2
+- **Docker**: Alpine 3.18+, Ubuntu 22.04+
+- **Kubernetes**: 1.24+
+- **Cloud**: AWS, GCP, Azure, DigitalOcean
+
+### Network Requirements
+
+```bash
+# Required ports
+3000/tcp   # Main API server
+8080/tcp   # MCP server
+5432/tcp   # PostgreSQL (if used)
+6379/tcp   # Redis (if used)
+9090/tcp   # Prometheus metrics
+3001/tcp   # Grafana dashboard
+
+# Outbound connections
+https://api.anthropic.com    # Claude API
+https://api.openai.com       # OpenAI API (optional)
+https://registry.npmjs.org   # Package registry
+https://github.com           # Repository access
+```
+
+---
+
+## Environment Variables
+
+### Production Environment Configuration
+
+```bash
+# Create production environment file
+cat > .env.production << 'EOF'
+# === Core Configuration ===
+NODE_ENV=production
+PORT=3000
+HOST=0.0.0.0
+
+# === API Keys ===
+CLAUDE_API_KEY=sk-ant-api03-...
+OPENAI_API_KEY=sk-...
+GITHUB_TOKEN=ghp_...
+
+# === Claude Flow Configuration ===
+CLAUDE_FLOW_DEBUG=false
+CLAUDE_FLOW_LOG_LEVEL=info
+CLAUDE_FLOW_DATA_DIR=/app/data
+CLAUDE_FLOW_MEMORY_DIR=/app/memory
+CLAUDE_FLOW_CONFIG_DIR=/app/config
+
+# === Performance Settings ===
+CLAUDE_FLOW_MAX_AGENTS=100
+CLAUDE_FLOW_MAX_CONCURRENT_TASKS=50
+CLAUDE_FLOW_MEMORY_LIMIT=2048
+CLAUDE_FLOW_CACHE_SIZE=512
+CLAUDE_FLOW_WORKER_THREADS=8
+
+# === Database Configuration ===
+DATABASE_URL=postgresql://claude_flow:secure_password@postgres:5432/claude_flow
+REDIS_URL=redis://redis:6379/0
+CACHE_TTL=3600
+CONNECTION_POOL_SIZE=20
+
+# === Security ===
+JWT_SECRET=your-secure-jwt-secret-256-bits
+ENCRYPTION_KEY=your-encryption-key-256-bits
+ALLOWED_ORIGINS=https://yourdomain.com
+RATE_LIMIT_WINDOW=900000
+RATE_LIMIT_MAX=100
+
+# === Features ===
+CLAUDE_FLOW_ENABLE_HOOKS=true
+CLAUDE_FLOW_ENABLE_MCP=true
+CLAUDE_FLOW_ENABLE_SWARM=true
+CLAUDE_FLOW_ENABLE_METRICS=true
+CLAUDE_FLOW_ENABLE_TRACING=true
+
+# === Monitoring ===
+PROMETHEUS_PORT=9090
+GRAFANA_ADMIN_PASSWORD=secure-password
+LOG_RETENTION_DAYS=30
+METRICS_RETENTION_DAYS=90
+
+# === Cloud Provider (AWS Example) ===
+AWS_REGION=us-west-2
+AWS_ACCESS_KEY_ID=AKIA...
+AWS_SECRET_ACCESS_KEY=...
+S3_BUCKET=claude-flow-backups
+
+# === Notifications ===
+SLACK_WEBHOOK_URL=https://hooks.slack.com/...
+EMAIL_SMTP_HOST=smtp.sendgrid.net
+EMAIL_SMTP_PORT=587
+EMAIL_SMTP_USER=apikey
+EMAIL_SMTP_PASS=SG...
+EOF
+```
+
+### Configuration Validation
+
+```bash
+# Validate environment configuration
+npx claude-flow@alpha config validate --env production
+
+# Test API connectivity
+npx claude-flow@alpha diagnostics --api-check
+
+# Verify database connection
+npx claude-flow@alpha diagnostics --db-check
+```
+
+---
+
+## Docker Deployment
+
+### Production Docker Image
+
+```dockerfile
+# Production Dockerfile
+FROM node:20-alpine AS base
+
+# Install system dependencies
+RUN apk add --no-cache \
+    python3 \
+    make \
+    g++ \
+    sqlite \
+    postgresql-client \
+    redis \
+    curl \
+    jq
+
+# Create app directory
+WORKDIR /app
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S claude-flow -u 1001 -G nodejs
+
+# === Build Stage ===
+FROM base AS builder
+
+# Copy package files
+COPY package*.json ./
+COPY tsconfig*.json ./
+
+# Install dependencies
+RUN npm ci --only=production --no-audit --no-fund
+
+# Copy source code
+COPY src/ ./src/
+COPY *.js *.ts *.json ./
+
+# Build application
+RUN npm run build
+
+# === Production Stage ===
+FROM base AS production
+
+# Set environment
+ENV NODE_ENV=production \
+    CLAUDE_FLOW_DATA_DIR=/app/data \
+    CLAUDE_FLOW_MEMORY_DIR=/app/memory \
+    CLAUDE_FLOW_CONFIG_DIR=/app/config \
+    CLAUDE_FLOW_LOG_LEVEL=info
+
+# Copy built application
+COPY --from=builder --chown=claude-flow:nodejs /app/dist ./dist
+COPY --from=builder --chown=claude-flow:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=claude-flow:nodejs /app/package*.json ./
+
+# Create data directories
+RUN mkdir -p /app/data /app/memory /app/config /app/logs && \
+    chown -R claude-flow:nodejs /app
+
+# Copy entrypoint script
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# Expose ports
+EXPOSE 3000 8080 9090
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:3000/health || exit 1
+
+# Switch to non-root user
+USER claude-flow:nodejs
+
+# Start application
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["node", "dist/index.js"]
+```
+
+### Docker Entrypoint Script
+
+```bash
+#!/bin/sh
+# docker-entrypoint.sh
+
+set -e
+
+# Initialize configuration if not exists
+if [ ! -f "/app/config/config.json" ]; then
+    echo "Initializing Claude Flow configuration..."
+    npx claude-flow@alpha init --force --config-dir /app/config
+fi
+
+# Wait for database if DATABASE_URL is set
+if [ -n "$DATABASE_URL" ]; then
+    echo "Waiting for database to be ready..."
+    until pg_isready -d "$DATABASE_URL" > /dev/null 2>&1; do
+        echo "Database not ready, waiting..."
+        sleep 2
+    done
+    echo "Database is ready!"
+fi
+
+# Wait for Redis if REDIS_URL is set
+if [ -n "$REDIS_URL" ]; then
+    echo "Waiting for Redis to be ready..."
+    until redis-cli -u "$REDIS_URL" ping > /dev/null 2>&1; do
+        echo "Redis not ready, waiting..."
+        sleep 2
+    done
+    echo "Redis is ready!"
+fi
+
+# Run database migrations
+if [ "$NODE_ENV" = "production" ]; then
+    echo "Running database migrations..."
+    npx claude-flow@alpha db migrate
+fi
+
+# Start the application
+echo "Starting Claude Flow..."
+exec "$@"
+```
+
+### Production Docker Compose
+
+```yaml
+# docker-compose.production.yml
+version: '3.8'
+
+services:
+  # === Core Services ===
+  claude-flow:
+    image: claude-flow:2.0.0-production
+    container_name: claude-flow-app
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+      - "8080:8080"
+    environment:
+      NODE_ENV: production
+      CLAUDE_API_KEY: ${CLAUDE_API_KEY}
+      DATABASE_URL: postgresql://claude_flow:${DB_PASSWORD}@postgres:5432/claude_flow
+      REDIS_URL: redis://redis:6379/0
+      CLAUDE_FLOW_MAX_AGENTS: 100
+      CLAUDE_FLOW_MEMORY_LIMIT: 2048
+    volumes:
+      - claude-flow-data:/app/data
+      - claude-flow-memory:/app/memory
+      - claude-flow-config:/app/config
+      - claude-flow-logs:/app/logs
+    networks:
+      - claude-flow-net
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+
+  # === Database Services ===
+  postgres:
+    image: postgres:15-alpine
+    container_name: claude-flow-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: claude_flow
+      POSTGRES_USER: claude_flow
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
+      POSTGRES_INITDB_ARGS: "--auth-host=md5"
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+      - ./init-scripts:/docker-entrypoint-initdb.d
+    networks:
+      - claude-flow-net
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U claude_flow -d claude_flow"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+
+  redis:
+    image: redis:7-alpine
+    container_name: claude-flow-redis
+    restart: unless-stopped
+    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    networks:
+      - claude-flow-net
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  # === Load Balancer ===
+  nginx:
+    image: nginx:alpine
+    container_name: claude-flow-nginx
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./nginx/conf.d:/etc/nginx/conf.d:ro
+      - ./ssl:/etc/nginx/ssl:ro
+      - nginx-cache:/var/cache/nginx
+    networks:
+      - claude-flow-net
+    depends_on:
+      - claude-flow
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  # === Monitoring Stack ===
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: claude-flow-prometheus
+    restart: unless-stopped
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus-data:/prometheus
+    networks:
+      - claude-flow-net
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+      - '--storage.tsdb.retention.time=90d'
+      - '--web.enable-lifecycle'
+
+  grafana:
+    image: grafana/grafana:latest
+    container_name: claude-flow-grafana
+    restart: unless-stopped
+    ports:
+      - "3001:3000"
+    environment:
+      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD}
+      GF_INSTALL_PLUGINS: grafana-clock-panel,grafana-simple-json-datasource
+    volumes:
+      - grafana-data:/var/lib/grafana
+      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards
+      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources
+    networks:
+      - claude-flow-net
+
+  # === Backup Service ===
+  backup:
+    image: postgres:15-alpine
+    container_name: claude-flow-backup
+    restart: "no"
+    volumes:
+      - ./backups:/backups
+      - ./scripts/backup.sh:/backup.sh:ro
+    networks:
+      - claude-flow-net
+    environment:
+      DATABASE_URL: postgresql://claude_flow:${DB_PASSWORD}@postgres:5432/claude_flow
+    depends_on:
+      - postgres
+    profiles:
+      - backup
+
+volumes:
+  postgres-data:
+  redis-data:
+  prometheus-data:
+  grafana-data:
+  claude-flow-data:
+  claude-flow-memory:
+  claude-flow-config:
+  claude-flow-logs:
+  nginx-cache:
+
+networks:
+  claude-flow-net:
+    driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.0.0/16
+```
+
+### Building and Deployment
+
+```bash
+# Build production image
+docker build -f Dockerfile.production -t claude-flow:2.0.0-production .
+
+# Tag for registry
+docker tag claude-flow:2.0.0-production your-registry.com/claude-flow:2.0.0
+
+# Push to registry
+docker push your-registry.com/claude-flow:2.0.0
+
+# Deploy with Docker Compose
+cp .env.production .env
+docker-compose -f docker-compose.production.yml up -d
+
+# View logs
+docker-compose -f docker-compose.production.yml logs -f claude-flow
+
+# Scale services
+docker-compose -f docker-compose.production.yml up -d --scale claude-flow=3
+
+# Health check
+curl -f http://localhost/health
+
+# Stop services
+docker-compose -f docker-compose.production.yml down
+```
+
+### Docker Registry Setup
+
+```bash
+# Setup private registry (optional)
+docker run -d -p 5000:5000 --name registry \
+  -v /opt/docker-registry:/var/lib/registry \
+  registry:2
+
+# Build and push to private registry
+docker build -t localhost:5000/claude-flow:2.0.0 .
+docker push localhost:5000/claude-flow:2.0.0
+
+# Pull from registry
+docker pull localhost:5000/claude-flow:2.0.0
+```
+
+---
+
+## Docker Deployment
+
+### Dockerfile
+
+```dockerfile
+# Multi-stage build for optimal size
+FROM node:20-alpine AS builder
+
+# Install build dependencies
+RUN apk add --no-cache python3 make g++ sqlite-dev
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source code
+COPY . .
+
+# Build application
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine
+
+# Install runtime dependencies
+RUN apk add --no-cache sqlite
+
+WORKDIR /app
+
+# Copy built application
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package*.json ./
+
+# Create data directories
+RUN mkdir -p /data/.claude-flow /data/.swarm /data/memory
+
+# Set environment variables
+ENV NODE_ENV=production \
+    CLAUDE_FLOW_DATA_DIR=/data/.claude-flow \
+    CLAUDE_FLOW_MEMORY_DIR=/data/.swarm \
+    PORT=3000
+
+# Expose ports
+EXPOSE 3000 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD node -e "require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"
+
+# Run as non-root user
+USER node
+
+# Start application
+CMD ["node", "dist/cli/main.js", "server"]
+```
+
+### Docker Compose
+
+```yaml
+version: '3.8'
+
+services:
+  claude-flow:
+    build: .
+    image: claude-flow:latest
+    container_name: claude-flow
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+      - "8080:8080"
+    environment:
+      - NODE_ENV=production
+      - CLAUDE_API_KEY=${CLAUDE_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - CLAUDE_FLOW_LOG_LEVEL=info
+    volumes:
+      - ./data:/data
+      - ./config:/app/config
+      - ./logs:/app/logs
+    networks:
+      - claude-flow-network
+    depends_on:
+      - redis
+      - postgres
+
+  redis:
+    image: redis:7-alpine
+    container_name: claude-flow-redis
+    restart: unless-stopped
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    networks:
+      - claude-flow-network
+
+  postgres:
+    image: postgres:15-alpine
+    container_name: claude-flow-postgres
+    restart: unless-stopped
+    environment:
+      - POSTGRES_DB=claude_flow
+      - POSTGRES_USER=claude_flow
+      - POSTGRES_PASSWORD=${DB_PASSWORD}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - claude-flow-network
+
+  nginx:
+    image: nginx:alpine
+    container_name: claude-flow-nginx
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./ssl:/etc/nginx/ssl
+    depends_on:
+      - claude-flow
+    networks:
+      - claude-flow-network
+
+volumes:
+  redis-data:
+  postgres-data:
+
+networks:
+  claude-flow-network:
+    driver: bridge
+```
+
+### Building and Running
+
+```bash
+# Build Docker image
+docker build -t claude-flow:latest .
+
+# Run with Docker
+docker run -d \
+  --name claude-flow \
+  -p 3000:3000 \
+  -e CLAUDE_API_KEY=$CLAUDE_API_KEY \
+  -v $(pwd)/data:/data \
+  claude-flow:latest
+
+# Run with Docker Compose
+docker-compose up -d
+
+# View logs
+docker logs -f claude-flow
+
+# Stop container
+docker stop claude-flow
+
+# Remove container
+docker rm claude-flow
+```
+
+#### Services and Ingress
+
+```yaml
+# k8s/service.yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: claude-flow-service
+  namespace: claude-flow
+  labels:
+    app: claude-flow
+spec:
+  type: ClusterIP
+  selector:
+    app: claude-flow
+  ports:
+  - name: http
+    port: 80
+    targetPort: 3000
+    protocol: TCP
+  - name: mcp
+    port: 8080
+    targetPort: 8080
+    protocol: TCP
+  - name: metrics
+    port: 9090
+    targetPort: 9090
+    protocol: TCP
+---
+# Load Balancer Service
+apiVersion: v1
+kind: Service
+metadata:
+  name: claude-flow-lb
+  namespace: claude-flow
+  annotations:
+    service.beta.kubernetes.io/aws-load-balancer-type: "nlb"
+    service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn:aws:acm:us-west-2:123456789:certificate/..."
+    service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "https"
+spec:
+  type: LoadBalancer
+  selector:
+    app: claude-flow
+  ports:
+  - name: https
+    port: 443
+    targetPort: 3000
+    protocol: TCP
+  - name: http
+    port: 80
+    targetPort: 3000
+    protocol: TCP
+---
+# Ingress for advanced routing
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: claude-flow-ingress
+  namespace: claude-flow
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+    cert-manager.io/cluster-issuer: "letsencrypt-prod"
+    nginx.ingress.kubernetes.io/rate-limit: "100"
+    nginx.ingress.kubernetes.io/rate-limit-window: "1m"
+    nginx.ingress.kubernetes.io/ssl-redirect: "true"
+    nginx.ingress.kubernetes.io/proxy-body-size: "10m"
+    nginx.ingress.kubernetes.io/proxy-connect-timeout: "600"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
+spec:
+  tls:
+  - hosts:
+    - api.claude-flow.com
+    - mcp.claude-flow.com
+    secretName: claude-flow-tls
+  rules:
+  - host: api.claude-flow.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: claude-flow-service
+            port:
+              number: 80
+  - host: mcp.claude-flow.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: claude-flow-service
+            port:
+              number: 8080
+```
+
+#### Persistent Volumes and HPA
+
+```yaml
+# k8s/pvc.yaml
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: claude-flow-data-pvc
+  namespace: claude-flow
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 20Gi
+  storageClassName: gp3
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: claude-flow-memory-pvc
+  namespace: claude-flow
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 10Gi
+  storageClassName: gp3
+---
+# k8s/hpa.yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: claude-flow-hpa
+  namespace: claude-flow
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: claude-flow
+  minReplicas: 3
+  maxReplicas: 20
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        type: Utilization
+        averageUtilization: 70
+  - type: Resource
+    resource:
+      name: memory
+      target:
+        type: Utilization
+        averageUtilization: 80
+  - type: Pods
+    pods:
+      metric:
+        name: custom_metric_requests_per_second
+      target:
+        type: AverageValue
+        averageValue: "50"
+  behavior:
+    scaleUp:
+      stabilizationWindowSeconds: 60
+      policies:
+      - type: Percent
+        value: 50
+        periodSeconds: 60
+    scaleDown:
+      stabilizationWindowSeconds: 300
+      policies:
+      - type: Percent
+        value: 10
+        periodSeconds: 60
+```
+
+#### Kubernetes Deployment Commands
+
+```bash
+# Create namespace
+kubectl create namespace claude-flow
+
+# Apply RBAC
+kubectl apply -f k8s/namespace.yaml
+
+# Create secrets (encode values with base64)
+echo -n "your-claude-api-key" | base64
+kubectl create secret generic claude-flow-secrets \
+  --from-literal=claude-api-key="$(echo -n 'your-api-key' | base64)" \
+  --from-literal=database-url="$(echo -n 'postgresql://...' | base64)" \
+  --from-literal=jwt-secret="$(echo -n 'your-jwt-secret' | base64)" \
+  -n claude-flow
+
+# Apply configurations
+kubectl apply -f k8s/configmap.yaml
+kubectl apply -f k8s/pvc.yaml
+kubectl apply -f k8s/deployment.yaml
+kubectl apply -f k8s/service.yaml
+kubectl apply -f k8s/ingress.yaml
+kubectl apply -f k8s/hpa.yaml
+
+# Check deployment status
+kubectl get pods -n claude-flow -w
+kubectl get svc -n claude-flow
+kubectl get ingress -n claude-flow
+
+# View logs
+kubectl logs -f deployment/claude-flow -n claude-flow
+
+# Scale deployment manually
+kubectl scale deployment/claude-flow --replicas=5 -n claude-flow
+
+# Rolling update
+kubectl set image deployment/claude-flow claude-flow=your-registry.com/claude-flow:2.0.1 -n claude-flow
+kubectl rollout status deployment/claude-flow -n claude-flow
+
+# Rollback if needed
+kubectl rollout undo deployment/claude-flow -n claude-flow
+
+# Port forward for testing
+kubectl port-forward svc/claude-flow-service 3000:80 -n claude-flow
+
+# Delete deployment
+kubectl delete namespace claude-flow
+```
+
+---
+
+## CI/CD Pipeline
+
+### GitHub Actions Workflow
+
+```yaml
+# .github/workflows/deploy.yml
+name: Deploy Claude Flow
+
+on:
+  push:
+    branches: [main, staging, production]
+    tags: ['v*']
+  pull_request:
+    branches: [main]
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20]
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Run linting
+      run: npm run lint
+    
+    - name: Run type checking
+      run: npm run typecheck
+    
+    - name: Run tests
+      run: npm run test:coverage
+      env:
+        CLAUDE_API_KEY: ${{ secrets.CLAUDE_API_KEY }}
+    
+    - name: Upload coverage
+      uses: codecov/codecov-action@v3
+
+  security-scan:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Run Snyk to check for vulnerabilities
+      uses: snyk/actions/node@master
+      env:
+        SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+    
+    - name: Run Trivy vulnerability scanner
+      uses: aquasecurity/trivy-action@master
+      with:
+        scan-type: 'fs'
+        scan-ref: '.'
+
+  build:
+    needs: [test, security-scan]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    outputs:
+      image: ${{ steps.image.outputs.image }}
+      digest: ${{ steps.build.outputs.digest }}
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Docker Buildx
+      uses: docker/setup-buildx-action@v3
+    
+    - name: Login to Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+    
+    - name: Extract metadata
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=sha,prefix=sha-
+    
+    - name: Build and push
+      id: build
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./Dockerfile.production
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        platforms: linux/amd64,linux/arm64
+    
+    - name: Output image
+      id: image
+      run: |
+        echo "image=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.meta.outputs.version }}" >> $GITHUB_OUTPUT
+
+  deploy-staging:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/staging'
+    environment: staging
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: us-west-2
+    
+    - name: Setup kubectl
+      uses: azure/setup-kubectl@v3
+      with:
+        version: 'v1.28.0'
+    
+    - name: Update kubeconfig
+      run: aws eks update-kubeconfig --region us-west-2 --name claude-flow-staging
+    
+    - name: Deploy to staging
+      run: |
+        kubectl set image deployment/claude-flow claude-flow=${{ needs.build.outputs.image }} -n claude-flow-staging
+        kubectl rollout status deployment/claude-flow -n claude-flow-staging --timeout=300s
+    
+    - name: Run smoke tests
+      run: |
+        kubectl port-forward svc/claude-flow-service 3000:80 -n claude-flow-staging &
+        sleep 10
+        curl -f http://localhost:3000/health || exit 1
+        npx claude-flow@alpha swarm "test deployment" --agents 1 || exit 1
+
+  deploy-production:
+    needs: build
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment: production
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: us-west-2
+    
+    - name: Setup kubectl
+      uses: azure/setup-kubectl@v3
+    
+    - name: Update kubeconfig
+      run: aws eks update-kubeconfig --region us-west-2 --name claude-flow-production
+    
+    - name: Deploy to production
+      run: |
+        # Blue-green deployment
+        kubectl patch deployment claude-flow -p '{"spec":{"template":{"spec":{"containers":[{"name":"claude-flow","image":"${{ needs.build.outputs.image }}"}]}}}}' -n claude-flow
+        kubectl rollout status deployment/claude-flow -n claude-flow --timeout=600s
+    
+    - name: Run production tests
+      run: |
+        # Wait for deployment to be ready
+        kubectl wait --for=condition=available --timeout=300s deployment/claude-flow -n claude-flow
+        
+        # Run health checks
+        EXTERNAL_IP=$(kubectl get svc claude-flow-lb -n claude-flow -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
+        curl -f "https://$EXTERNAL_IP/health" || exit 1
+    
+    - name: Notify deployment
+      uses: 8398a7/action-slack@v3
+      with:
+        status: ${{ job.status }}
+        text: "Claude Flow ${{ github.ref_name }} deployed to production"
+      env:
+        SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+```
+
+### Terraform Infrastructure
+
+```hcl
+# infrastructure/main.tf
+terraform {
+  required_version = ">= 1.0"
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+    kubernetes = {
+      source  = "hashicorp/kubernetes"
+      version = "~> 2.20"
+    }
+  }
+  
+  backend "s3" {
+    bucket = "claude-flow-terraform-state"
+    key    = "production/terraform.tfstate"
+    region = "us-west-2"
+  }
+}
+
+# EKS Cluster
+resource "aws_eks_cluster" "claude_flow" {
+  name     = "claude-flow-production"
+  role_arn = aws_iam_role.cluster.arn
+  version  = "1.28"
+
+  vpc_config {
+    subnet_ids              = aws_subnet.private[*].id
+    endpoint_private_access = true
+    endpoint_public_access  = true
+    public_access_cidrs     = ["0.0.0.0/0"]
+  }
+
+  enabled_cluster_log_types = ["api", "audit", "authenticator", "controllerManager", "scheduler"]
+
+  depends_on = [
+    aws_iam_role_policy_attachment.cluster_AmazonEKSClusterPolicy,
+  ]
+}
+
+# Node Group
+resource "aws_eks_node_group" "claude_flow" {
+  cluster_name    = aws_eks_cluster.claude_flow.name
+  node_group_name = "claude-flow-nodes"
+  node_role_arn   = aws_iam_role.node_group.arn
+  subnet_ids      = aws_subnet.private[*].id
+  instance_types  = ["m5.large", "m5.xlarge"]
+  
+  scaling_config {
+    desired_size = 3
+    max_size     = 20
+    min_size     = 3
+  }
+  
+  update_config {
+    max_unavailable = 1
+  }
+
+  depends_on = [
+    aws_iam_role_policy_attachment.node_group_AmazonEKSWorkerNodePolicy,
+    aws_iam_role_policy_attachment.node_group_AmazonEKS_CNI_Policy,
+    aws_iam_role_policy_attachment.node_group_AmazonEC2ContainerRegistryReadOnly,
+  ]
+}
+
+# RDS Instance
+resource "aws_db_instance" "claude_flow" {
+  identifier             = "claude-flow-production"
+  engine                 = "postgres"
+  engine_version         = "15"
+  instance_class         = "db.r5.large"
+  allocated_storage      = 100
+  max_allocated_storage  = 1000
+  
+  db_name  = "claude_flow"
+  username = "claude_flow"
+  password = var.db_password
+  
+  vpc_security_group_ids = [aws_security_group.rds.id]
+  db_subnet_group_name   = aws_db_subnet_group.claude_flow.name
+  
+  backup_retention_period = 30
+  backup_window          = "03:00-04:00"
+  maintenance_window     = "sun:04:00-sun:05:00"
+  
+  performance_insights_enabled = true
+  monitoring_interval         = 60
+  monitoring_role_arn        = aws_iam_role.rds_enhanced_monitoring.arn
+  
+  deletion_protection = true
+  skip_final_snapshot = false
+  final_snapshot_identifier = "claude-flow-final-snapshot"
+  
+  tags = {
+    Environment = "production"
+    Application = "claude-flow"
+  }
+}
+
+# ElastiCache Redis
+resource "aws_elasticache_replication_group" "claude_flow" {
+  replication_group_id         = "claude-flow-redis"
+  description                  = "Redis cluster for Claude Flow"
+  
+  node_type                    = "cache.r6g.large"
+  port                         = 6379
+  parameter_group_name         = "default.redis7"
+  
+  num_cache_clusters           = 3
+  automatic_failover_enabled   = true
+  multi_az_enabled            = true
+  
+  subnet_group_name           = aws_elasticache_subnet_group.claude_flow.name
+  security_group_ids          = [aws_security_group.redis.id]
+  
+  at_rest_encryption_enabled  = true
+  transit_encryption_enabled  = true
+  auth_token                  = var.redis_auth_token
+  
+  snapshot_retention_limit    = 7
+  snapshot_window            = "03:00-05:00"
+  
+  tags = {
+    Environment = "production"
+    Application = "claude-flow"
+  }
+}
+
+# Application Load Balancer
+resource "aws_lb" "claude_flow" {
+  name               = "claude-flow-alb"
+  internal           = false
+  load_balancer_type = "application"
+  security_groups    = [aws_security_group.alb.id]
+  subnets            = aws_subnet.public[*].id
+
+  enable_deletion_protection = true
+  enable_http2              = true
+
+  access_logs {
+    bucket  = aws_s3_bucket.alb_logs.bucket
+    prefix  = "alb-logs"
+    enabled = true
+  }
+}
+```
+
+---
+
+## Monitoring & Observability
+
+### Prometheus Configuration
+
+```yaml
+# monitoring/prometheus.yml
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+  external_labels:
+    cluster: 'claude-flow-production'
+    environment: 'production'
+
+rule_files:
+  - "rules/*.yml"
+
+alerting:
+  alertmanagers:
+    - static_configs:
+        - targets: ['alertmanager:9093']
+
+scrape_configs:
+  # Claude Flow application
+  - job_name: 'claude-flow'
+    kubernetes_sd_configs:
+      - role: pod
+        namespaces:
+          names: ['claude-flow']
+    relabel_configs:
+      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
+        action: keep
+        regex: true
+      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
+        action: replace
+        target_label: __metrics_path__
+        regex: (.+)
+      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
+        action: replace
+        regex: ([^:]+)(?::\d+)?;(\d+)
+        replacement: $1:$2
+        target_label: __address__
+
+  # Node Exporter
+  - job_name: 'node-exporter'
+    kubernetes_sd_configs:
+      - role: node
+    relabel_configs:
+      - source_labels: [__address__]
+        regex: '(.*):10250'
+        replacement: '${1}:9100'
+        target_label: __address__
+
+  # PostgreSQL
+  - job_name: 'postgres'
+    static_configs:
+      - targets: ['postgres-exporter:9187']
+
+  # Redis
+  - job_name: 'redis'
+    static_configs:
+      - targets: ['redis-exporter:9121']
+```
+
+### Production Backup Strategy
+
+```bash
+#!/bin/bash
+# scripts/backup.sh - Production backup script
+
+set -euo pipefail
+
+BACKUP_DIR="/backups/$(date +%Y/%m/%d)"
+DATE=$(date +%Y%m%d_%H%M%S)
+RETENTION_DAYS=30
+S3_BUCKET="claude-flow-backups"
+
+# Create backup directory
+mkdir -p "$BACKUP_DIR"
+
+# Database backup
+echo "Starting PostgreSQL backup..."
+pg_dump "$DATABASE_URL" | gzip > "$BACKUP_DIR/postgres_$DATE.sql.gz"
+
+# Redis backup
+echo "Starting Redis backup..."
+redis-cli -u "$REDIS_URL" --rdb "$BACKUP_DIR/redis_$DATE.rdb"
+gzip "$BACKUP_DIR/redis_$DATE.rdb"
+
+# Configuration backup
+echo "Backing up configurations..."
+kubectl get secret claude-flow-secrets -n claude-flow -o yaml > "$BACKUP_DIR/secrets_$DATE.yaml"
+kubectl get configmap claude-flow-config -n claude-flow -o yaml > "$BACKUP_DIR/config_$DATE.yaml"
+
+# Application data backup
+echo "Backing up application data..."
+tar -czf "$BACKUP_DIR/app-data_$DATE.tar.gz" /app/data /app/memory
+
+# Upload to S3
+echo "Uploading backups to S3..."
+aws s3 cp "$BACKUP_DIR/" "s3://$S3_BUCKET/$(date +%Y/%m/%d)/" --recursive
+
+# Cleanup old backups
+echo "Cleaning up old backups..."
+find /backups -type f -mtime +$RETENTION_DAYS -delete
+aws s3 ls "s3://$S3_BUCKET/" --recursive | while read -r line; do
+    createDate=$(echo $line | awk '{print $1" "$2}')
+    createDate=$(date -d "$createDate" +%s)
+    olderThan=$(date -d "$RETENTION_DAYS days ago" +%s)
+    if [[ $createDate -lt $olderThan ]]; then
+        fileName=$(echo $line | awk '{$1=$2=$3=""; print $0}' | sed 's/^[ \t]*//')
+        aws s3 rm "s3://$S3_BUCKET/$fileName"
+    fi
+done
+
+echo "Backup completed successfully!"
+
+# Send notification
+curl -X POST -H 'Content-type: application/json' \
+    --data "{\"text\":\"✅ Claude Flow backup completed: $DATE\"}" \
+    "$SLACK_WEBHOOK_URL"
+```
+
+---
+
+## Security Configuration
+
+### Secrets Management with AWS Secrets Manager
+
+```bash
+# Create secrets in AWS Secrets Manager
+aws secretsmanager create-secret \
+    --name "claude-flow/api-keys" \
+    --description "Claude Flow API keys" \
+    --secret-string '{
+        "claude-api-key": "sk-ant-api03-...",
+        "openai-api-key": "sk-...",
+        "github-token": "ghp_..."
+    }'
+
+aws secretsmanager create-secret \
+    --name "claude-flow/database" \
+    --description "Database connection details" \
+    --secret-string '{
+        "url": "postgresql://claude_flow:password@hostname:5432/claude_flow",
+        "password": "secure-password"
+    }'
+
+aws secretsmanager create-secret \
+    --name "claude-flow/jwt" \
+    --description "JWT and encryption secrets" \
+    --secret-string '{
+        "jwt-secret": "your-jwt-secret-256-bits",
+        "encryption-key": "your-encryption-key-256-bits"
+    }'
+```
+
+### WAF Configuration
+
+```json
+{
+  "Name": "claude-flow-waf",
+  "Scope": "CLOUDFRONT",
+  "DefaultAction": {
+    "Allow": {}
+  },
+  "Rules": [
+    {
+      "Name": "AWSManagedRulesCommonRuleSet",
+      "Priority": 1,
+      "OverrideAction": {
+        "None": {}
+      },
+      "Statement": {
+        "ManagedRuleGroupStatement": {
+          "VendorName": "AWS",
+          "Name": "AWSManagedRulesCommonRuleSet"
+        }
+      },
+      "VisibilityConfig": {
+        "SampledRequestsEnabled": true,
+        "CloudWatchMetricsEnabled": true,
+        "MetricName": "CommonRuleSetMetric"
+      }
+    },
+    {
+      "Name": "RateLimitRule",
+      "Priority": 2,
+      "Action": {
+        "Block": {}
+      },
+      "Statement": {
+        "RateBasedStatement": {
+          "Limit": 2000,
+          "AggregateKeyType": "IP"
+        }
+      },
+      "VisibilityConfig": {
+        "SampledRequestsEnabled": true,
+        "CloudWatchMetricsEnabled": true,
+        "MetricName": "RateLimitMetric"
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Load Balancing
+
+### AWS Application Load Balancer
+
+```bash
+# Create ALB
+aws elbv2 create-load-balancer \
+    --name claude-flow-alb \
+    --subnets subnet-12345 subnet-67890 \
+    --security-groups sg-12345 \
+    --scheme internet-facing \
+    --type application \
+    --ip-address-type ipv4
+
+# Create target group
+aws elbv2 create-target-group \
+    --name claude-flow-targets \
+    --protocol HTTP \
+    --port 3000 \
+    --vpc-id vpc-12345 \
+    --target-type ip \
+    --health-check-enabled \
+    --health-check-interval-seconds 30 \
+    --health-check-path /health \
+    --health-check-protocol HTTP \
+    --health-check-timeout-seconds 5 \
+    --healthy-threshold-count 2 \
+    --unhealthy-threshold-count 2
+
+# Create listener
+aws elbv2 create-listener \
+    --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789:loadbalancer/app/claude-flow-alb/1234567890abcdef \
+    --protocol HTTPS \
+    --port 443 \
+    --certificates CertificateArn=arn:aws:acm:us-west-2:123456789:certificate/12345678-1234-1234-1234-123456789012 \
+    --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789:targetgroup/claude-flow-targets/1234567890abcdef
+```
+
+---
+
+## Cloud Deployment
+
+### AWS Production Deployment
+
+#### EKS Cluster Setup
+
+```bash
+#!/bin/bash
+# Deploy Claude Flow to AWS EKS
+
+# Variables
+CLUSTER_NAME="claude-flow-production"
+REGION="us-west-2"
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+
+# Create EKS cluster
+eksctl create cluster \
+  --name $CLUSTER_NAME \
+  --version 1.28 \
+  --region $REGION \
+  --nodegroup-name claude-flow-workers \
+  --node-type m5.large \
+  --nodes 3 \
+  --nodes-min 3 \
+  --nodes-max 20 \
+  --with-oidc \
+  --ssh-access \
+  --ssh-public-key ~/.ssh/id_rsa.pub \
+  --managed
+
+# Install AWS Load Balancer Controller
+eksctl create iamserviceaccount \
+  --cluster=$CLUSTER_NAME \
+  --namespace=kube-system \
+  --name=aws-load-balancer-controller \
+  --attach-policy-arn=arn:aws:iam::$ACCOUNT_ID:policy/AWSLoadBalancerControllerIAMPolicy \
+  --override-existing-serviceaccounts \
+  --approve
+
+helm repo add eks https://aws.github.io/eks-charts
+helm repo update
+helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
+  -n kube-system \
+  --set clusterName=$CLUSTER_NAME \
+  --set serviceAccount.create=false \
+  --set serviceAccount.name=aws-load-balancer-controller
+
+# Install EBS CSI driver
+eksctl create addon \
+  --name aws-ebs-csi-driver \
+  --cluster $CLUSTER_NAME \
+  --service-account-role-arn arn:aws:iam::$ACCOUNT_ID:role/AmazonEKS_EBS_CSI_DriverRole
+
+echo "EKS cluster $CLUSTER_NAME created successfully!"
+```
+
+#### ECS Fargate Deployment
+
+```json
+{
+  "family": "claude-flow",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "2048",
+  "memory": "4096",
+  "executionRoleArn": "arn:aws:iam::ACCOUNT:role/ecsTaskExecutionRole",
+  "taskRoleArn": "arn:aws:iam::ACCOUNT:role/claudeFlowTaskRole",
+  "containerDefinitions": [
+    {
+      "name": "claude-flow",
+      "image": "ACCOUNT.dkr.ecr.us-west-2.amazonaws.com/claude-flow:2.0.0",
+      "portMappings": [
+        {"containerPort": 3000, "protocol": "tcp"},
+        {"containerPort": 8080, "protocol": "tcp"}
+      ],
+      "environment": [
+        {"name": "NODE_ENV", "value": "production"},
+        {"name": "CLAUDE_FLOW_MAX_AGENTS", "value": "100"}
+      ],
+      "secrets": [
+        {
+          "name": "CLAUDE_API_KEY",
+          "valueFrom": "arn:aws:secretsmanager:us-west-2:ACCOUNT:secret:claude-flow/api-keys:claude-api-key::"
+        }
+      ],
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "options": {
+          "awslogs-group": "/ecs/claude-flow",
+          "awslogs-region": "us-west-2",
+          "awslogs-stream-prefix": "ecs"
+        }
+      },
+      "healthCheck": {
+        "command": ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
+        "interval": 30,
+        "timeout": 5,
+        "retries": 3,
+        "startPeriod": 60
+      }
+    }
+  ]
+}
+```
+
+```bash
+# Deploy ECS service
+aws ecs create-cluster --cluster-name claude-flow-production
+
+aws ecs register-task-definition --cli-input-json file://task-definition.json
+
+aws ecs create-service \
+  --cluster claude-flow-production \
+  --service-name claude-flow \
+  --task-definition claude-flow:1 \
+  --desired-count 3 \
+  --launch-type FARGATE \
+  --network-configuration "awsvpcConfiguration={subnets=[subnet-12345,subnet-67890],securityGroups=[sg-12345],assignPublicIp=DISABLED}" \
+  --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-west-2:ACCOUNT:targetgroup/claude-flow/12345,containerName=claude-flow,containerPort=3000" \
+  --enable-logging
+```
+
+### Google Cloud Platform Production
+
+#### GKE Deployment
+
+```bash
+#!/bin/bash
+# Deploy to Google Kubernetes Engine
+
+PROJECT_ID="your-project-id"
+CLUSTER_NAME="claude-flow-production"
+REGION="us-central1"
+
+# Create GKE cluster
+gcloud container clusters create $CLUSTER_NAME \
+  --project=$PROJECT_ID \
+  --region=$REGION \
+  --machine-type=e2-standard-4 \
+  --num-nodes=3 \
+  --min-nodes=3 \
+  --max-nodes=20 \
+  --enable-autoscaling \
+  --enable-autorepair \
+  --enable-autoupgrade \
+  --enable-network-policy \
+  --enable-ip-alias \
+  --disk-size=50GB \
+  --disk-type=pd-ssd \
+  --release-channel=stable
+
+# Get credentials
+gcloud container clusters get-credentials $CLUSTER_NAME --region=$REGION --project=$PROJECT_ID
+
+# Install ingress controller
+kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.8.2/deploy/static/provider/cloud/deploy.yaml
+
+# Deploy application
+kubectl create namespace claude-flow
+kubectl apply -f k8s/ -n claude-flow
+
+echo "GKE deployment completed!"
+```
+
+#### Cloud Run Deployment
+
+```yaml
+# cloud-run.yaml
+apiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: claude-flow
+  annotations:
+    run.googleapis.com/ingress: all
+    run.googleapis.com/execution-environment: gen2
+spec:
+  template:
+    metadata:
+      annotations:
+        autoscaling.knative.dev/minScale: "3"
+        autoscaling.knative.dev/maxScale: "100"
+        run.googleapis.com/cpu-throttling: "false"
+        run.googleapis.com/memory: "4Gi"
+        run.googleapis.com/cpu: "2"
+    spec:
+      containerConcurrency: 100
+      containers:
+      - image: gcr.io/PROJECT_ID/claude-flow:2.0.0
+        ports:
+        - containerPort: 3000
+        env:
+        - name: NODE_ENV
+          value: "production"
+        - name: CLAUDE_API_KEY
+          valueFrom:
+            secretKeyRef:
+              name: claude-flow-secrets
+              key: claude-api-key
+        resources:
+          limits:
+            cpu: "2"
+            memory: "4Gi"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 60
+          periodSeconds: 30
+        startupProbe:
+          httpGet:
+            path: /ready
+            port: 3000
+          initialDelaySeconds: 10
+          periodSeconds: 10
+          failureThreshold: 30
+```
+
+```bash
+# Deploy to Cloud Run
+gcloud run services replace cloud-run.yaml \
+  --region=us-central1 \
+  --project=your-project-id
+```
+
+### Azure Deployment
+
+```bash
+# Deploy to Azure Container Instances
+az container create \
+  --resource-group claude-flow-rg \
+  --name claude-flow \
+  --image claudeflow/claude-flow:latest \
+  --dns-name-label claude-flow \
+  --ports 3000 \
+  --environment-variables CLAUDE_API_KEY=$CLAUDE_API_KEY
+
+# Deploy to Azure App Service
+az webapp create \
+  --resource-group claude-flow-rg \
+  --plan claude-flow-plan \
+  --name claude-flow \
+  --deployment-container-image-name claudeflow/claude-flow:latest
+```
+
+### Heroku Deployment
+
+```bash
+# Create Heroku app
+heroku create claude-flow
+
+# Set environment variables
+heroku config:set CLAUDE_API_KEY=$CLAUDE_API_KEY
+heroku config:set NODE_ENV=production
+
+# Deploy
+git push heroku main
+
+# Scale dynos
+heroku ps:scale web=3
+
+# View logs
+heroku logs --tail
+```
+
+---
+
+## Production Setup
+
+### SSL/TLS Configuration
+
+```nginx
+# nginx.conf
+server {
+    listen 80;
+    server_name claude-flow.example.com;
+    return 301 https://$server_name$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name claude-flow.example.com;
+    
+    ssl_certificate /etc/nginx/ssl/cert.pem;
+    ssl_certificate_key /etc/nginx/ssl/key.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+    
+    location / {
+        proxy_pass http://claude-flow:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+```
+
+### Database Setup
+
+#### PostgreSQL
+
+```sql
+-- Create database
+CREATE DATABASE claude_flow;
+
+-- Create user
+CREATE USER claude_flow WITH ENCRYPTED PASSWORD 'secure_password';
+
+-- Grant privileges
+GRANT ALL PRIVILEGES ON DATABASE claude_flow TO claude_flow;
+
+-- Create tables
+\c claude_flow;
+
+CREATE TABLE agents (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name VARCHAR(255) NOT NULL,
+  type VARCHAR(50) NOT NULL,
+  status VARCHAR(50) NOT NULL,
+  config JSONB,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE tasks (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  type VARCHAR(50) NOT NULL,
+  description TEXT,
+  status VARCHAR(50) NOT NULL,
+  priority INTEGER DEFAULT 0,
+  assigned_agent UUID REFERENCES agents(id),
+  result JSONB,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  completed_at TIMESTAMP
+);
+
+-- Create indexes
+CREATE INDEX idx_agents_type ON agents(type);
+CREATE INDEX idx_agents_status ON agents(status);
+CREATE INDEX idx_tasks_status ON tasks(status);
+CREATE INDEX idx_tasks_assigned ON tasks(assigned_agent);
+```
+
+### Backup Strategy
+
+```bash
+#!/bin/bash
+# backup.sh
+
+# Configuration
+BACKUP_DIR="/backups"
+DATE=$(date +%Y%m%d_%H%M%S)
+DB_NAME="claude_flow"
+
+# Create backup directory
+mkdir -p $BACKUP_DIR
+
+# Backup SQLite database
+sqlite3 .swarm/memory.db ".backup '$BACKUP_DIR/memory_$DATE.db'"
+
+# Backup PostgreSQL (if used)
+pg_dump $DB_NAME > $BACKUP_DIR/postgres_$DATE.sql
+
+# Backup configuration files
+tar -czf $BACKUP_DIR/config_$DATE.tar.gz .claude-flow/
+
+# Backup logs
+tar -czf $BACKUP_DIR/logs_$DATE.tar.gz logs/
+
+# Upload to S3
+aws s3 cp $BACKUP_DIR/ s3://claude-flow-backups/ --recursive
+
+# Clean old backups (keep last 30 days)
+find $BACKUP_DIR -type f -mtime +30 -delete
+
+echo "Backup completed: $DATE"
+```
+
+### Monitoring Script
+
+```bash
+#!/bin/bash
+# monitor.sh
+
+# Check service health
+health_check() {
+  response=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health)
+  if [ $response -eq 200 ]; then
+    echo "✅ Service is healthy"
+  else
+    echo "❌ Service is unhealthy (HTTP $response)"
+    # Send alert
+    send_alert "Claude Flow service is down"
+  fi
+}
+
+# Check memory usage
+check_memory() {
+  memory=$(free -m | awk 'NR==2{printf "%.2f%%", $3*100/$2}')
+  echo "📊 Memory usage: $memory"
+  
+  if [ ${memory%.*} -gt 90 ]; then
+    send_alert "High memory usage: $memory"
+  fi
+}
+
+# Check disk usage
+check_disk() {
+  disk=$(df -h / | awk 'NR==2{print $5}')
+  echo "💾 Disk usage: $disk"
+  
+  if [ ${disk%?} -gt 90 ]; then
+    send_alert "High disk usage: $disk"
+  fi
+}
+
+# Send alert function
+send_alert() {
+  message=$1
+  # Send to Slack
+  curl -X POST -H 'Content-type: application/json' \
+    --data "{\"text\":\"Alert: $message\"}" \
+    $SLACK_WEBHOOK_URL
+}
+
+# Run checks
+while true; do
+  clear
+  echo "Claude Flow Monitoring - $(date)"
+  echo "================================"
+  health_check
+  check_memory
+  check_disk
+  sleep 60
+done
+```
+
+---
+
+## Monitoring & Maintenance
+
+### Health Checks
+
+```javascript
+// health-check.js
+const healthCheck = {
+  service: async () => {
+    try {
+      const response = await fetch('http://localhost:3000/health');
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  },
+  
+  database: async () => {
+    try {
+      const db = new Database('.swarm/memory.db');
+      const result = db.prepare('SELECT 1').get();
+      return result !== undefined;
+    } catch (error) {
+      return false;
+    }
+  },
+  
+  memory: () => {
+    const used = process.memoryUsage();
+    const limit = 2 * 1024 * 1024 * 1024; // 2GB
+    return used.heapUsed < limit;
+  }
+};
+
+// Run health checks
+setInterval(async () => {
+  const results = {
+    service: await healthCheck.service(),
+    database: await healthCheck.database(),
+    memory: healthCheck.memory()
+  };
+  
+  console.log('Health Check Results:', results);
+  
+  if (!Object.values(results).every(v => v)) {
+    console.error('Health check failed!');
+    // Send alert
+  }
+}, 60000); // Every minute
+```
+
+### Log Rotation
+
+```bash
+# /etc/logrotate.d/claude-flow
+/var/log/claude-flow/*.log {
+    daily
+    rotate 14
+    compress
+    delaycompress
+    notifempty
+    create 0640 node node
+    sharedscripts
+    postrotate
+        /usr/bin/killall -SIGUSR1 node
+    endscript
+}
+```
+
+### Performance Tuning
+
+```bash
+# System limits configuration
+# /etc/security/limits.conf
+node soft nofile 65536
+node hard nofile 65536
+node soft nproc 32768
+node hard nproc 32768
+
+# Sysctl optimization
+# /etc/sysctl.conf
+net.core.somaxconn = 65535
+net.ipv4.tcp_max_syn_backlog = 65535
+net.ipv4.tcp_tw_reuse = 1
+net.ipv4.tcp_fin_timeout = 30
+```
+
+---
+
+## Troubleshooting
+
+### Production Issues
+
+#### Issue: Pod Crashes with OOMKilled
+
+```bash
+# Check memory usage
+kubectl top pods -n claude-flow
+
+# Increase memory limits
+kubectl patch deployment claude-flow -n claude-flow -p='{"spec":{"template":{"spec":{"containers":[{"name":"claude-flow","resources":{"limits":{"memory":"8Gi"}}}]}}}}'
+
+# Enable memory profiling
+kubectl set env deployment/claude-flow NODE_OPTIONS="--max-old-space-size=6144" -n claude-flow
+```
+
+#### Issue: High Response Times
+
+```bash
+# Check pod resource usage
+kubectl describe pod -l app=claude-flow -n claude-flow
+
+# Scale up replicas
+kubectl scale deployment claude-flow --replicas=5 -n claude-flow
+
+# Check database connections
+kubectl exec deployment/claude-flow -n claude-flow -- psql $DATABASE_URL -c "SELECT count(*) FROM pg_stat_activity;"
+
+# Optimize database queries
+kubectl exec deployment/claude-flow -n claude-flow -- npx claude-flow@alpha db optimize
+```
+
+#### Issue: Database Connection Pool Exhaustion
+
+```bash
+# Check current connections
+psql $DATABASE_URL -c "
+SELECT 
+    state,
+    count(*) as connections 
+FROM pg_stat_activity 
+GROUP BY state;"
+
+# Increase connection limits
+kubectl patch configmap claude-flow-config -n claude-flow -p='{"data":{"config.json":"{\"database\":{\"pool\":{\"max\":50,\"min\":10}}}"}}'
+
+# Restart deployment
+kubectl rollout restart deployment/claude-flow -n claude-flow
+```
+
+#### Issue: Load Balancer Health Check Failures
+
+```bash
+# Check health endpoint
+kubectl exec deployment/claude-flow -n claude-flow -- curl -f http://localhost:3000/health
+
+# View detailed health status
+kubectl exec deployment/claude-flow -n claude-flow -- npx claude-flow@alpha diagnostics --health
+
+# Check ingress configuration
+kubectl describe ingress claude-flow-ingress -n claude-flow
+
+# Test from outside cluster
+curl -H "Host: api.claude-flow.com" http://$(kubectl get svc ingress-nginx-controller -n ingress-nginx -o jsonpath='{.status.loadBalancer.ingress[0].ip}')/health
+```
+
+#### Issue: SSL Certificate Errors
+
+```bash
+# Check certificate status
+kubectl get certificate claude-flow-tls -n claude-flow
+
+# Describe certificate for details
+kubectl describe certificate claude-flow-tls -n claude-flow
+
+# Check cert-manager logs
+kubectl logs deployment/cert-manager -n cert-manager
+
+# Force certificate renewal
+kubectl delete certificate claude-flow-tls -n claude-flow
+kubectl apply -f k8s/cert-issuer.yaml
+```
+
+#### Issue: High CPU Usage
+
+```bash
+# Check CPU metrics
+kubectl top pods -n claude-flow
+
+# Profile application
+kubectl exec deployment/claude-flow -n claude-flow -- node --prof /app/dist/index.js &
+# Let it run for a few minutes, then:
+kubectl exec deployment/claude-flow -n claude-flow -- node --prof-process isolate-*.log > profile.txt
+
+# Scale horizontally
+kubectl patch hpa claude-flow-hpa -n claude-flow -p='{"spec":{"minReplicas":5,"maxReplicas":30}}'
+```
+
+### Debug Mode & Diagnostics
+
+```bash
+# Enable production debugging (use cautiously)
+kubectl set env deployment/claude-flow -n claude-flow \
+  CLAUDE_FLOW_DEBUG=true \
+  CLAUDE_FLOW_LOG_LEVEL=debug
+
+# Get comprehensive diagnostics
+kubectl exec deployment/claude-flow -n claude-flow -- npx claude-flow@alpha diagnostics --full > diagnostic-report.txt
+
+# Monitor real-time logs
+kubectl logs -f deployment/claude-flow -n claude-flow --tail=100
+
+# Export cluster information
+kubectl cluster-info dump > cluster-dump.txt
+
+# Check resource quotas
+kubectl describe quota -n claude-flow
+
+# View events
+kubectl get events -n claude-flow --sort-by='.metadata.creationTimestamp'
+```
+
+### Emergency Procedures
+
+#### Emergency Shutdown
+
+```bash
+#!/bin/bash
+# emergency-shutdown.sh
+
+echo "🚨 EMERGENCY: Shutting down Claude Flow..."
+
+# Scale down to zero
+kubectl scale deployment claude-flow --replicas=0 -n claude-flow
+
+# Stop autoscaling
+kubectl patch hpa claude-flow-hpa -n claude-flow -p='{"spec":{"minReplicas":0,"maxReplicas":0}}'
+
+# Cordon nodes (if necessary)
+# kubectl cordon <node-name>
+
+# Send alert
+curl -X POST -H 'Content-type: application/json' \
+  --data '{"text":"🚨 EMERGENCY: Claude Flow has been shut down!"}' \
+  "$SLACK_WEBHOOK_URL"
+
+echo "✅ Emergency shutdown complete"
+```
+
+#### Circuit Breaker Response
+
+```bash
+# Implement circuit breaker for external APIs
+kubectl patch configmap claude-flow-config -n claude-flow -p='{
+  "data": {
+    "config.json": "{\"circuitBreaker\":{\"enabled\":true,\"threshold\":10,\"timeout\":60000}}"
+  }
+}'
+
+# Restart to apply changes
+kubectl rollout restart deployment/claude-flow -n claude-flow
+```
+
+### Performance Debugging
+
+```bash
+# Memory leak detection
+kubectl exec deployment/claude-flow -n claude-flow -- node --trace-gc --expose-gc /app/dist/index.js
+
+# CPU profiling in production
+kubectl exec deployment/claude-flow -n claude-flow -- node --prof-process /tmp/isolate-*.log > cpu-profile.txt
+
+# Network debugging
+kubectl exec deployment/claude-flow -n claude-flow -- netstat -tupln
+kubectl exec deployment/claude-flow -n claude-flow -- ss -tulpn
+
+# Database query analysis
+kubectl exec deployment/claude-flow -n claude-flow -- psql $DATABASE_URL -c "
+SELECT query, calls, total_time, mean_time 
+FROM pg_stat_statements 
+ORDER BY total_time DESC 
+LIMIT 10;"
+```
+
+---
+
+## Support & Resources
+
+### Production Support Runbook
+
+```bash
+#!/bin/bash
+# support-runbook.sh - Quick diagnostic commands
+
+echo "🔍 Claude Flow Production Diagnostics"
+echo "======================================"
+
+echo "📊 Cluster Status:"
+kubectl get nodes -o wide
+kubectl get pods -n claude-flow
+kubectl top pods -n claude-flow
+
+echo "📈 Application Health:"
+curl -s https://api.claude-flow.com/health | jq '.'
+
+echo "🐘 Database Status:"
+psql $DATABASE_URL -c "SELECT version();" -t
+psql $DATABASE_URL -c "SELECT count(*) as active_connections FROM pg_stat_activity WHERE state = 'active';" -t
+
+echo "📦 Redis Status:"
+redis-cli -u $REDIS_URL info memory | grep used_memory_human
+redis-cli -u $REDIS_URL ping
+
+echo "🔧 Recent Logs:"
+kubectl logs deployment/claude-flow -n claude-flow --tail=50 --timestamps
+
+echo "⚠️  Recent Alerts:"
+curl -s http://alertmanager:9093/api/v1/alerts | jq '.data[] | select(.state=="firing") | .labels.alertname'
+
+echo "📋 Resource Usage:"
+kubectl describe nodes | grep -A 5 "Allocated resources"
+```
+
+### Monitoring Dashboards
+
+- **Production Dashboard**: https://grafana.claude-flow.com/d/claude-flow-prod
+- **Infrastructure Dashboard**: https://grafana.claude-flow.com/d/infrastructure
+- **Application Metrics**: https://grafana.claude-flow.com/d/app-metrics
+- **Database Performance**: https://grafana.claude-flow.com/d/database
+- **Alert Manager**: https://alertmanager.claude-flow.com
+
+### Emergency Contacts
+
+```yaml
+# On-Call Escalation
+Level 1: DevOps Team
+  - Slack: #devops-alerts
+  - PagerDuty: claude-flow-devops
+  
+Level 2: Engineering Team
+  - Slack: #engineering-oncall
+  - Email: engineering-oncall@claude-flow.com
+  
+Level 3: Leadership
+  - Slack: #leadership-alerts
+  - Phone: Emergency hotline
+```
+
+### Documentation Links
+
+- **Architecture Guide**: [ARCHITECTURE.md](./ARCHITECTURE.md)
+- **API Documentation**: [API_DOCUMENTATION.md](./API_DOCUMENTATION.md)  
+- **Development Workflow**: [DEVELOPMENT_WORKFLOW.md](./DEVELOPMENT_WORKFLOW.md)
+- **Main Documentation**: [INDEX.md](./INDEX.md)
+- **Repository**: https://github.com/ruvnet/claude-flow
+- **Issues**: https://github.com/ruvnet/claude-flow/issues
+
+### Quick Commands Reference
+
+```bash
+# Essential production commands
+npx claude-flow@alpha --version                    # Check version
+npx claude-flow@alpha diagnostics --full           # Full system check
+npx claude-flow@alpha swarm "test" --agents 3      # Quick functionality test
+npx claude-flow@alpha config validate              # Validate configuration
+
+# Kubernetes shortcuts
+alias kgp="kubectl get pods -n claude-flow"
+alias kgs="kubectl get svc -n claude-flow"  
+alias kgi="kubectl get ingress -n claude-flow"
+alias kl="kubectl logs -f deployment/claude-flow -n claude-flow"
+alias kdp="kubectl describe pod -l app=claude-flow -n claude-flow"
+
+# Emergency commands
+kubectl scale deployment claude-flow --replicas=0 -n claude-flow  # Emergency stop
+kubectl rollout undo deployment/claude-flow -n claude-flow        # Rollback
+kubectl get events --sort-by='.metadata.creationTimestamp' -n claude-flow  # Recent events
+```
+
+---
+
+<div align="center">
+
+## 🚀 **Claude-Flow Production Deployment Guide v2.0.0**
+
+**Ready for Enterprise Scale • Production Tested • Fully Documented**
+
+[📚 Documentation Home](./INDEX.md) | [🏗️ Architecture](./ARCHITECTURE.md) | [📖 API Reference](./API_DOCUMENTATION.md) | [⚡ Development](./DEVELOPMENT_WORKFLOW.md)
+
+[🐙 GitHub Repository](https://github.com/ruvnet/claude-flow) | [🐛 Report Issues](https://github.com/ruvnet/claude-flow/issues) | [💬 Community Support](https://discord.gg/claude-flow)
+
+</div>