claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/fleet-manager/SKILL.md

@@ -1,412 +0,0 @@
-# Fleet Manager Skill
-
-## Version
-**Version:** 1.0.0
-**Status:** OPERATIONAL
-
-## Overview
-Fleet Manager provides comprehensive resource allocation, tier-based resource management, performance monitoring, and load balancing for distributed agent swarms.
-
-## Features
-- Agent Registration with Resource Tiers
-- Dynamic Resource Allocation
-- Real-time Performance Metrics
-- Intelligent Load Balancing
-- Resource Quota Management
-- Health Monitoring
-
-## Resource Tiers
-
-### Shared Tier (Default)
-- **CPU:** 0.5 cores
-- **Memory:** 512 MB
-- **Use Case:** Lightweight tasks, research, documentation
-- **Cost:** Minimal
-
-### Dedicated Tier
-- **CPU:** 2.0 cores
-- **Memory:** 2048 MB
-- **Use Case:** Backend development, testing, code analysis
-- **Cost:** Standard
-
-### Premium Tier
-- **CPU:** 4.0 cores
-- **Memory:** 4096 MB
-- **Use Case:** CFN Loop validation, compilation, heavy processing
-- **Cost:** Maximum
-
-## Agent Integration Examples
-
-### 1. Register Agent with Resource Tier
-
-```bash
-# Register agent with shared tier (default)
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "researcher-1" \
-  --tier shared
-
-# Register agent with dedicated tier
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "backend-dev-1" \
-  --tier dedicated
-
-# Register agent with premium tier
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "cfn-validator-1" \
-  --tier premium
-```
-
-**Output:**
-```json
-{
-  "status": "registered",
-  "agentId": "backend-dev-1",
-  "tier": "dedicated",
-  "resources": {
-    "cpu": 2.0,
-    "memory": 2048
-  },
-  "timestamp": 1729332000
-}
-```
-
-### 2. Allocate Resources to Agent
-
-```bash
-# Allocate custom resources
-./.claude/skills/fleet-manager/invoke-fleet-allocate.sh \
-  --agent-id "backend-dev-1" \
-  --cpu 3.0 \
-  --memory 3072
-
-# Allocate with priority flag
-./.claude/skills/fleet-manager/invoke-fleet-allocate.sh \
-  --agent-id "cfn-validator-1" \
-  --cpu 4.0 \
-  --memory 4096 \
-  --priority high
-```
-
-**Output:**
-```json
-{
-  "status": "allocated",
-  "agentId": "backend-dev-1",
-  "allocated": {
-    "cpu": 3.0,
-    "memory": 3072
-  },
-  "availability": {
-    "cpuRemaining": 5.0,
-    "memoryRemaining": 4096
-  },
-  "timestamp": 1729332100
-}
-```
-
-### 3. Get Performance Metrics
-
-```bash
-# Get metrics for specific agent
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-  --agent-id "backend-dev-1"
-
-# Get metrics with detailed breakdown
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-  --agent-id "backend-dev-1" \
-  --detailed
-
-# Get fleet-wide metrics
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-  --all
-```
-
-**Output:**
-```json
-{
-  "agentId": "backend-dev-1",
-  "metrics": {
-    "cpuUsage": 2.4,
-    "cpuUtilization": 0.80,
-    "memoryUsage": 1800,
-    "memoryUtilization": 0.88,
-    "taskCompletionRate": 0.95,
-    "averageResponseTime": 120
-  },
-  "health": "healthy",
-  "timestamp": 1729332200
-}
-```
-
-### 4. Trigger Load Balancing
-
-```bash
-# Balance resources across multiple agents
-./.claude/skills/fleet-manager/invoke-fleet-balance.sh \
-  --agents "backend-dev-1,backend-dev-2,backend-dev-3"
-
-# Balance with strategy
-./.claude/skills/fleet-manager/invoke-fleet-balance.sh \
-  --agents "cfn-validator-1,cfn-validator-2" \
-  --strategy round-robin
-
-# Balance entire fleet
-./.claude/skills/fleet-manager/invoke-fleet-balance.sh \
-  --all
-```
-
-**Output:**
-```json
-{
-  "status": "balanced",
-  "strategy": "round-robin",
-  "agents": [
-    {
-      "agentId": "backend-dev-1",
-      "beforeLoad": 0.80,
-      "afterLoad": 0.65,
-      "adjustment": "reduced"
-    },
-    {
-      "agentId": "backend-dev-2",
-      "beforeLoad": 0.45,
-      "afterLoad": 0.60,
-      "adjustment": "increased"
-    }
-  ],
-  "timestamp": 1729332300
-}
-```
-
-## Integration Patterns
-
-### Pattern 1: CFN Loop with Resource Management
-
-```bash
-# Register all CFN Loop agents with appropriate tiers
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "coder-1" --tier dedicated
-
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "reviewer-1" --tier dedicated
-
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "product-owner-1" --tier premium
-
-# Monitor performance during loop
-metrics=$(
-  ./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-    --agent-id "coder-1"
-)
-
-# If CPU utilization high, trigger rebalancing
-cpu_util=$(echo "$metrics" | jq '.metrics.cpuUtilization')
-if (( $(echo "$cpu_util > 0.85" | bc -l) )); then
-  ./.claude/skills/fleet-manager/invoke-fleet-balance.sh \
-    --agents "coder-1,coder-2,coder-3"
-fi
-```
-
-### Pattern 2: Dynamic Resource Scaling
-
-```bash
-# Start with shared tier
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "researcher-1" --tier shared
-
-# If task complexity increases, allocate more resources
-./.claude/skills/fleet-manager/invoke-fleet-allocate.sh \
-  --agent-id "researcher-1" \
-  --cpu 2.0 \
-  --memory 2048
-
-# Monitor and adjust
-metrics=$(
-  ./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-    --agent-id "researcher-1"
-)
-
-memory_util=$(echo "$metrics" | jq '.metrics.memoryUtilization')
-if (( $(echo "$memory_util > 0.90" | bc -l) )); then
-  ./.claude/skills/fleet-manager/invoke-fleet-allocate.sh \
-    --agent-id "researcher-1" \
-    --memory 4096 \
-    --priority high
-fi
-```
-
-### Pattern 3: Health-Based Resource Adjustment
-
-```bash
-# Check agent health
-metrics=$(
-  ./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-    --agent-id "backend-dev-1"
-)
-
-health=$(echo "$metrics" | jq -r '.health')
-
-if [ "$health" = "degraded" ]; then
-  # Reduce load on degraded agent
-  ./.claude/skills/fleet-manager/invoke-fleet-balance.sh \
-    --agents "backend-dev-1,backend-dev-2" \
-    --strategy offload
-fi
-```
-
-## Performance Characteristics
-
-### Resource Allocation Latency
-- Registration: <50ms
-- Allocation: <100ms
-- Metrics Retrieval: <30ms
-- Load Balancing: <200ms
-
-### Scalability
-- Max Concurrent Agents: 100+
-- Max Resource Pool: 400 cores, 400GB RAM
-- Metrics Collection Rate: 1Hz per agent
-- Balancing Frequency: On-demand or scheduled
-
-### Resource Efficiency
-- Shared Tier: 95% resource utilization
-- Dedicated Tier: 85% resource utilization
-- Premium Tier: 75% resource utilization (reserved headroom)
-
-## Redis Key Structure
-
-```
-# Agent Registration
-fleet:agent:{agentId}:registration -> {tier, cpu, memory, timestamp}
-
-# Resource Allocation
-fleet:agent:{agentId}:allocation -> {cpu, memory, priority, timestamp}
-
-# Performance Metrics
-fleet:agent:{agentId}:metrics -> {cpuUsage, memoryUsage, health, timestamp}
-
-# Load Balancing State
-fleet:balance:{balanceId}:state -> {agents, strategy, status, timestamp}
-
-# Resource Pool
-fleet:pool:available -> {totalCpu, totalMemory, allocated, reserved}
-```
-
-## Error Handling
-
-### Common Errors
-
-**Insufficient Resources:**
-```json
-{
-  "error": "RESOURCE_UNAVAILABLE",
-  "message": "Requested resources exceed available pool",
-  "requested": {"cpu": 4.0, "memory": 4096},
-  "available": {"cpu": 2.0, "memory": 2048}
-}
-```
-
-**Agent Not Found:**
-```json
-{
-  "error": "AGENT_NOT_FOUND",
-  "message": "Agent backend-dev-1 not registered",
-  "suggestion": "Register agent first using invoke-fleet-register.sh"
-}
-```
-
-**Invalid Tier:**
-```json
-{
-  "error": "INVALID_TIER",
-  "message": "Tier 'ultra' not recognized",
-  "validTiers": ["shared", "dedicated", "premium"]
-}
-```
-
-## Best Practices
-
-1. **Register Before Allocation:** Always register agents before allocating custom resources
-2. **Monitor Regularly:** Check metrics at least once per iteration for long-running tasks
-3. **Balance Proactively:** Trigger load balancing when fleet-wide utilization >70%
-4. **Use Appropriate Tiers:** Match tier to task complexity to optimize cost
-5. **Graceful Degradation:** Handle resource scarcity by queuing tasks or reducing quality
-
-## Testing
-
-Run comprehensive test suite:
-```bash
-./.claude/skills/fleet-manager/test-fleet-manager.sh
-```
-
-### Test Coverage
-- Agent registration (all tiers)
-- Resource allocation (standard and high-priority)
-- Metrics collection (individual and fleet-wide)
-- Load balancing (multiple strategies)
-- Error handling (resource exhaustion, invalid inputs)
-- Concurrency (parallel agent operations)
-
-## Coordination with Other Skills
-
-### Redis Coordination Integration
-```bash
-# Register CFN Loop agents with Fleet Manager
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "coder-1" --tier dedicated
-
-# Start CFN Loop with orchestration
-./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
-  --task-id "auth-system" \
-  --loop3-agents "coder-1,coder-2" \
-  --loop2-agents "reviewer-1" \
-  --product-owner "product-owner-1"
-
-# Monitor resource usage during loop
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh \
-  --agent-id "coder-1"
-```
-
-### Agent Spawning Integration
-```bash
-# Register agent in spawning script
-./.claude/skills/fleet-manager/invoke-fleet-register.sh \
-  --agent-id "$AGENT_ID" --tier dedicated
-
-# Spawn agent with Task tool
-# ... agent spawning logic ...
-
-# Deallocate resources when agent completes
-./.claude/skills/fleet-manager/invoke-fleet-allocate.sh \
-  --agent-id "$AGENT_ID" --cpu 0 --memory 0
-```
-
-## Maintenance
-
-### Daily Health Checks
-```bash
-# Check fleet-wide health
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh --all | jq '.agents[] | select(.health != "healthy")'
-```
-
-### Weekly Resource Audits
-```bash
-# Identify underutilized agents
-./.claude/skills/fleet-manager/invoke-fleet-metrics.sh --all | jq '.agents[] | select(.metrics.cpuUtilization < 0.20)'
-```
-
-### Monthly Capacity Planning
-```bash
-# Analyze resource trends
-# Export metrics to analytics system for trend analysis
-```
-
-## Version History
-
-### v1.0.0 (2025-10-19)
-- Initial release
-- Agent registration with 3-tier resource model
-- Dynamic resource allocation
-- Real-time performance metrics
-- Load balancing with multiple strategies
-- Comprehensive test suite

package/.claude/skills/fleet-manager/config.json

@@ -1,60 +0,0 @@
-{
-  "skillName": "fleet-manager",
-  "version": "1.0.0",
-  "status": "operational",
-  "description": "Resource allocation, performance monitoring, and load balancing for distributed agent swarms",
-  "capabilities": [
-    "agent-registration",
-    "resource-allocation",
-    "performance-metrics",
-    "load-balancing"
-  ],
-  "resourceTiers": {
-    "shared": {
-      "cpu": 0.5,
-      "memory": 512,
-      "useCase": "Lightweight tasks, research, documentation"
-    },
-    "dedicated": {
-      "cpu": 2.0,
-      "memory": 2048,
-      "useCase": "Backend development, testing, code analysis"
-    },
-    "premium": {
-      "cpu": 4.0,
-      "memory": 4096,
-      "useCase": "CFN Loop validation, compilation, heavy processing"
-    }
-  },
-  "scripts": [
-    "invoke-fleet-register.sh",
-    "invoke-fleet-allocate.sh",
-    "invoke-fleet-metrics.sh",
-    "invoke-fleet-balance.sh",
-    "test-fleet-manager.sh"
-  ],
-  "dependencies": {
-    "redis": "required",
-    "jq": "required",
-    "bc": "required"
-  },
-  "integrations": [
-    "redis-coordination",
-    "agent-spawning",
-    "cfn-loop-validation"
-  ],
-  "performance": {
-    "registrationLatency": "<50ms",
-    "allocationLatency": "<100ms",
-    "metricsLatency": "<30ms",
-    "balancingLatency": "<200ms"
-  },
-  "scalability": {
-    "maxConcurrentAgents": 100,
-    "maxResourcePool": {
-      "cpu": 400,
-      "memory": 409600
-    },
-    "metricsCollectionRate": "1Hz"
-  }
-}

package/.claude/skills/fleet-manager/invoke-fleet-allocate.sh

@@ -1,182 +0,0 @@
-#!/bin/bash
-#
-# Fleet Manager - Resource Allocation CLI Wrapper
-#
-# Usage:
-#   ./invoke-fleet-allocate.sh --agent-id <id> --cpu <value> --memory <value> [--priority <low|normal|high>]
-#
-# Examples:
-#   # Allocate custom resources
-#   ./invoke-fleet-allocate.sh --agent-id backend-dev-1 --cpu 3.0 --memory 3072
-#
-#   # Allocate with priority flag
-#   ./invoke-fleet-allocate.sh --agent-id cfn-validator-1 --cpu 4.0 --memory 4096 --priority high
-
-set -euo pipefail
-
-# Parse arguments
-AGENT_ID=""
-CPU=""
-MEMORY=""
-PRIORITY="normal"
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --cpu)
-            CPU="$2"
-            shift 2
-            ;;
-        --memory)
-            MEMORY="$2"
-            shift 2
-            ;;
-        --priority)
-            PRIORITY="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$AGENT_ID" ] || [ -z "$CPU" ] || [ -z "$MEMORY" ]; then
-    echo "Error: --agent-id, --cpu, and --memory are required"
-    echo ""
-    echo "Usage: $0 --agent-id <id> --cpu <value> --memory <value> [--priority <low|normal|high>]"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --agent-id backend-dev-1 --cpu 3.0 --memory 3072"
-    echo "  $0 --agent-id cfn-validator-1 --cpu 4.0 --memory 4096 --priority high"
-    exit 1
-fi
-
-# Validate priority
-if [[ ! "$PRIORITY" =~ ^(low|normal|high)$ ]]; then
-    echo "Error: Invalid priority '$PRIORITY'"
-    echo "Valid priorities: low, normal, high"
-    exit 1
-fi
-
-# Check if agent is registered
-REGISTRATION_KEY="fleet:agent:${AGENT_ID}:registration"
-REGISTRATION=$(redis-cli GET "$REGISTRATION_KEY")
-
-if [ -z "$REGISTRATION" ] || [ "$REGISTRATION" = "(nil)" ]; then
-    echo "Error: Agent $AGENT_ID not registered"
-    echo "Suggestion: Register agent first using invoke-fleet-register.sh"
-
-    ERROR_RESULT=$(jq -n \
-        --arg error "AGENT_NOT_FOUND" \
-        --arg message "Agent $AGENT_ID not registered" \
-        --arg suggestion "Register agent first using invoke-fleet-register.sh" \
-        '{
-            error: $error,
-            message: $message,
-            suggestion: $suggestion
-        }')
-
-    echo "$ERROR_RESULT"
-    exit 1
-fi
-
-# Calculate available resources (mock calculation for demo)
-# In production, this would check actual resource pool
-TOTAL_CPU=100.0
-TOTAL_MEMORY=102400
-
-# Get currently allocated resources
-POOL_KEY="fleet:pool:allocated"
-ALLOCATED_CPU=$(redis-cli HGET "$POOL_KEY" "${AGENT_ID}:cpu" || echo "0")
-ALLOCATED_MEMORY=$(redis-cli HGET "$POOL_KEY" "${AGENT_ID}:memory" || echo "0")
-
-# Calculate remaining resources (simplified for demo)
-CPU_REMAINING=$(echo "$TOTAL_CPU - $CPU" | bc)
-MEMORY_REMAINING=$(echo "$TOTAL_MEMORY - $MEMORY" | bc)
-
-# Check resource availability
-if (( $(echo "$CPU_REMAINING < 0" | bc -l) )) || (( $(echo "$MEMORY_REMAINING < 0" | bc -l) )); then
-    echo "Error: Insufficient resources"
-
-    ERROR_RESULT=$(jq -n \
-        --arg error "RESOURCE_UNAVAILABLE" \
-        --arg message "Requested resources exceed available pool" \
-        --arg req_cpu "$CPU" \
-        --arg req_mem "$MEMORY" \
-        --arg avail_cpu "$CPU_REMAINING" \
-        --arg avail_mem "$MEMORY_REMAINING" \
-        '{
-            error: $error,
-            message: $message,
-            requested: {
-                cpu: ($req_cpu | tonumber),
-                memory: ($req_mem | tonumber)
-            },
-            available: {
-                cpu: ($avail_cpu | tonumber),
-                memory: ($avail_mem | tonumber)
-            }
-        }')
-
-    echo "$ERROR_RESULT"
-    exit 1
-fi
-
-# Create allocation record in Redis
-ALLOCATION_KEY="fleet:agent:${AGENT_ID}:allocation"
-TIMESTAMP=$(date +%s)
-
-ALLOCATION_DATA=$(jq -n \
-    --arg cpu "$CPU" \
-    --arg memory "$MEMORY" \
-    --arg priority "$PRIORITY" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        cpu: ($cpu | tonumber),
-        memory: ($memory | tonumber),
-        priority: $priority,
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$ALLOCATION_DATA" | redis-cli -x SET "$ALLOCATION_KEY" >/dev/null
-
-# Update resource pool
-redis-cli HSET "$POOL_KEY" "${AGENT_ID}:cpu" "$CPU" >/dev/null
-redis-cli HSET "$POOL_KEY" "${AGENT_ID}:memory" "$MEMORY" >/dev/null
-
-# Output success message
-echo "[$AGENT_ID] Resources allocated"
-echo "  CPU: $CPU cores"
-echo "  Memory: $MEMORY MB"
-echo "  Priority: $PRIORITY"
-
-# Return JSON result
-RESULT=$(jq -n \
-    --arg status "allocated" \
-    --arg agent_id "$AGENT_ID" \
-    --arg cpu "$CPU" \
-    --arg memory "$MEMORY" \
-    --arg cpu_rem "$CPU_REMAINING" \
-    --arg mem_rem "$MEMORY_REMAINING" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        status: $status,
-        agentId: $agent_id,
-        allocated: {
-            cpu: ($cpu | tonumber),
-            memory: ($memory | tonumber)
-        },
-        availability: {
-            cpuRemaining: ($cpu_rem | tonumber),
-            memoryRemaining: ($mem_rem | tonumber)
-        },
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$RESULT"