claude-flow-novice 2.14.13 → 2.14.15

package/claude-assets/skills/cfn-multi-coordinator-planning/README.md

@@ -0,0 +1,256 @@
+# Multi-Coordinator Planning Skill
+
+**Purpose:** Systematic planning and validation for parallel multi-coordinator execution workflows, designed to prevent Zone B-style execution failures.
+
+## Overview
+
+This skill provides comprehensive pre-flight planning for multi-coordinator execution, addressing the critical failures identified in the Zone B analysis:
+- Redis namespace collision (Echo zone)
+- Protocol compliance breakdown (Alpha/Charlie zones)
+- Orchestration gaps (Delta zone)
+- Consensus on vapor anti-patterns (Bravo zone)
+
+## Quick Start
+
+```bash
+# Create zone configuration
+cat > zone-config.json << 'EOF'
+{
+  "zones": [
+    {
+      "name": "zone-alpha",
+      "task_description": "Implement React authentication component with TypeScript interfaces",
+      "deliverables": [
+        "src/components/AuthForm.tsx",
+        "src/types/auth.ts",
+        "src/hooks/useAuth.ts",
+        "tests/auth.test.ts"
+      ],
+      "agent_types": ["react-frontend-engineer", "reviewer", "tester"],
+      "acceptance_criteria": [
+        "Form validates user input",
+        "Authentication state managed globally",
+        "Component tested with >80% coverage"
+      ],
+      "in_scope": ["React components", "TypeScript interfaces"],
+      "out_of_scope": ["Backend authentication"],
+      "directory": "src/auth"
+    }
+  ]
+}
+EOF
+
+# Execute planning
+./.claude/skills/cfn-multi-coordinator-planning/plan-multi-coordinator-work.sh zone-config.json
+```
+
+## Components
+
+### 1. Main Planning Script
+- **`plan-multi-coordinator-work.sh`** - Orchestrates all planning phases
+
+### 2. Planning Phase Scripts
+- **`validate-task-planning.sh`** - Task configuration validation
+- **`plan-coordinator-resources.sh`** - Resource allocation and namespace planning
+- **`map-dependencies-conflicts.sh`** - Dependency analysis and conflict resolution
+- **`plan-risk-rollout.sh`** - Risk-based rollout strategy
+
+### 3. Testing
+- **`test-multi-coordinator-planning.sh`** - Comprehensive test suite
+
+## Configuration Format
+
+### Zone Configuration Structure
+```json
+{
+  "zones": [
+    {
+      "name": "zone-identifier",
+      "task_description": "Specific implementation task with clear deliverables",
+      "deliverables": [
+        "file/path/to/deliverable.ext"
+      ],
+      "agent_types": ["required-agent-types"],
+      "acceptance_criteria": [
+        "Measurable acceptance criteria"
+      ],
+      "in_scope": ["items in scope"],
+      "out_of_scope": ["items out of scope"],
+      "directory": "working/directory",
+      "risk_factors": ["optional-risk-factors"]
+    }
+  ]
+}
+```
+
+### Validation Requirements
+- **Minimum 3 deliverables** for software tasks
+- **Minimum 2 agent types** (prevents single-agent anti-patterns)
+- **Specific task descriptions** (no generic "implementation" tasks)
+- **Acceptance criteria** required
+- **In-scope/out-of-scope boundaries** required
+
+## Usage Examples
+
+### Basic Planning
+```bash
+./plan-multi-coordinator-work.sh zone-config.json
+```
+
+### Advanced Planning with Custom Parameters
+```bash
+./plan-multi-coordinator-work.sh zone-config.json \
+  --max-zones-per-phase 3 \
+  --output-dir ./plans \
+  --dry-run
+```
+
+### Skip Validation (Not Recommended)
+```bash
+./plan-multi-coordinator-work.sh zone-config.json --skip-validation
+```
+
+## Planning Phases
+
+### Phase 1: Task Validation
+- Deliverable specificity verification
+- Agent type diversity requirements
+- Context completeness scoring
+- Anti-pattern detection
+
+### Phase 2: Resource Allocation
+- Redis namespace reservation and isolation
+- Memory/CPU capacity planning
+- Coordinator limit calculations
+- Working directory allocation
+
+### Phase 3: Dependency Analysis
+- Cross-zone dependency identification
+- Shared resource conflict detection
+- Completion pathway validation
+- Resolution strategy creation
+
+### Phase 4: Risk-Based Rollout
+- Zone complexity ranking
+- Graduated phase rollout
+- Success gate definition
+- Rollback trigger configuration
+
+## Output Files
+
+### Generated Plans
+- `coordinator-resource-plan-*.json` - Resource allocation mapping
+- `dependency-conflict-analysis-*.json` - Dependencies and conflicts analysis
+- `rollout-plan-*.json` - Risk-based rollout strategy
+- `multi-coordinator-planning-summary-*.json` - Execution summary
+
+### Structure
+```json
+{
+  "timestamp": 1699123456,
+  "zone_count": 2,
+  "system_resources": {...},
+  "resource_plans": [...],
+  "phases": [...],
+  "success_criteria": [...],
+  "rollback_triggers": [...]
+}
+```
+
+## Risk Mitigation
+
+### Prevents Zone B Failures
+1. **Namespace Collision Prevention** - Redis DB allocation per zone
+2. **Protocol Compliance** - Agent completion pathway validation
+3. **Orchestration Gaps** - Coordinator lifecycle management
+4. **Anti-Pattern Detection** - Consensus on vapor prevention
+
+### Rollback Strategies
+- Immediate rollback on critical failures
+- Phase-specific rollback triggers
+- Context preservation and recovery
+- Emergency stop and cleanup procedures
+
+## Testing
+
+```bash
+# Run comprehensive test suite
+./test-multi-coordinator-planning.sh
+
+# Test individual components
+./validate-task-planning.sh test-config.json
+./plan-coordinator-resources.sh test-config.json
+./map-dependencies-conflicts.sh test-config.json
+./plan-risk-rollout.sh test-config.json
+```
+
+## Integration with CFN Loop
+
+This skill integrates with the existing CFN Loop ecosystem:
+
+### Pre-Flight Validation
+- Use before `/cfn-loop-cli` multi-coordinator execution
+- Validates coordinator readiness and resource availability
+- Prevents execution failures through comprehensive planning
+
+### CLI Spawning Support
+- Generates CLI-compatible coordinator configurations
+- Supports the recommendation to spawn coordinators via CLI
+- Enables Main Chat monitoring and interjection capabilities
+
+### Redis Coordination
+- Uses existing Redis coordination patterns
+- Integrates with `cfn-redis-coordination` skill
+- Maintains namespace isolation standards
+
+## Best Practices
+
+### Planning Phase
+1. **Always validate configurations** before execution
+2. **Use graduated rollout** for complex multi-zone scenarios
+3. **Monitor resource utilization** during planning
+4. **Test rollback procedures** before production execution
+
+### Configuration
+1. **Be specific** about deliverables and acceptance criteria
+2. **Include risk factors** for accurate complexity assessment
+3. **Define clear scope boundaries** to prevent scope creep
+4. **Use appropriate agent types** for task complexity
+
+### Execution
+1. **Follow the rollout sequence** generated by the planner
+2. **Monitor each phase** before proceeding to the next
+3. **Be prepared to rollback** on trigger activation
+4. **Document lessons learned** for future planning
+
+## Troubleshooting
+
+### Common Issues
+- **Redis connection failures** - Check Redis service status
+- **Resource exhaustion** - Reduce concurrent zones or increase resources
+- **Validation failures** - Review configuration against requirements
+- **Namespace conflicts** - Ensure unique zone names and task IDs
+
+### Debug Mode
+```bash
+# Enable verbose output
+set -x
+./plan-multi-coordinator-work.sh zone-config.json
+set +x
+```
+
+## Dependencies
+
+- **jq** - JSON processing
+- **redis-cli** - Redis connectivity and namespace planning
+- **bc** - Mathematical calculations
+- **Redis server** - Namespace reservation and coordination
+
+## Maintenance
+
+- Regular testing of all planning phases
+- Update validation rules based on new failure patterns
+- Enhance resource planning algorithms
+- Extend rollback trigger configurations
+
+---

package/claude-assets/skills/cfn-multi-coordinator-planning/SKILL.md

@@ -0,0 +1,62 @@
+# Multi-Coordinator Planning Skill
+
+**Purpose:** Systematic planning and validation for parallel multi-coordinator execution workflows.
+
+**Usage:**
+```bash
+./.claude/skills/cfn-multi-coordinator-planning/plan-multi-coordinator-work.sh [zone-config-file]
+```
+
+## Overview
+
+Prevents Zone B-style execution failures through comprehensive pre-flight planning, resource allocation, and risk-based rollout validation.
+
+## Core Functions
+
+### 1. Task Configuration Validation
+- Deliverable specificity verification
+- Agent type diversity requirements
+- Context completeness scoring
+- Anti-pattern detection (consensus on vapor)
+
+### 2. Resource Allocation Planning
+- Redis namespace reservation and isolation
+- Memory/CPU capacity planning per coordinator
+- Coordinator limit calculations
+- Monitoring overhead allocation
+
+### 3. Dependency & Conflict Mapping
+- Cross-zone dependency identification
+- Shared resource conflict resolution
+- Completion pathway validation
+- Failure escalation planning
+
+### 4. Risk-Based Rollout Strategy
+- Zone complexity ranking
+- Graduated phase rollout
+- Success gate validation
+- Rollback trigger definition
+
+## Inputs
+
+- Zone configuration file (JSON format)
+- Task definitions per zone
+- Resource availability parameters
+- Risk tolerance settings
+
+## Outputs
+
+- Validated execution plan
+- Resource allocation mapping
+- Rollout sequence with success gates
+- Risk assessment and mitigation strategies
+
+## Validation
+
+Comprehensive test suite covering:
+- Namespace collision detection
+- Resource capacity validation
+- Dependency conflict resolution
+- Rollout scenario testing
+
+---

package/claude-assets/skills/cfn-multi-coordinator-planning/map-dependencies-conflicts.sh

@@ -0,0 +1,376 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Configuration
+SHARED_RESOURCES=("redis" "file_system" "network_ports" "memory" "cpu")
+CONFLICT_RESOLUTION_STRATEGIES=("queue_based_priority" "resource_isolation" "time_sharing" "fail_fast")
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log() {
+    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+info() {
+    echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1${NC}"
+}
+
+identify_shared_resources() {
+    local zone_config="$1"
+    local shared_resources_analysis="[]"
+
+    # Analyze each zone for shared resource usage
+    local i=0
+    while IFS= read -r zone_name; do
+        local zone_data
+        zone_data=$(echo "$zone_config" | jq ".zones[$i]")
+
+        local resource_usage="{
+            \"zone\": \"$zone_name\",
+            \"redis_usage\": \"isolated_namespace\",
+            \"file_system_usage\": \"/tmp/zone-${zone_name}-*\",
+            \"network_ports\": \"dynamic_allocation\",
+            \"memory_requirement\": \"2GB\",
+            \"cpu_requirement\": \"2_cores\"
+        }"
+
+        shared_resources_analysis=$(echo "$shared_resources_analysis" | jq ". + [$resource_usage]")
+        ((i++))
+    done < <(echo "$zone_config" | jq -r '.zones[].name')
+
+    echo "$shared_resources_analysis"
+}
+
+detect_potential_conflicts() {
+    local shared_resources="$1"
+    local conflicts="[]"
+
+    # Check for Redis key pattern conflicts
+    local redis_patterns
+    redis_patterns=$(echo "$shared_resources" | jq -r '.[].redis_usage')
+    local unique_redis_patterns
+    unique_redis_patterns=$(echo "$redis_patterns" | sort -u | wc -l)
+
+    if [[ $unique_redis_patterns -lt $(echo "$shared_resources" | jq 'length') ]]; then
+        local conflict="{
+            \"type\": \"redis_namespace_collision\",
+            \"severity\": \"high\",
+            \"description\": \"Multiple zones may use overlapping Redis namespaces\",
+            \"affected_zones\": $(echo "$shared_resources" | jq 'map(.zone)'),
+            \"resolution_strategy\": \"namespace_isolation\"
+        }"
+        conflicts=$(echo "$conflicts" | jq ". + [$conflict]")
+    fi
+
+    # Check for file system path conflicts
+    local file_patterns
+    file_patterns=$(echo "$shared_resources" | jq -r '.[].file_system_usage')
+
+    # Look for potential conflicts in temporary directories
+    if echo "$file_patterns" | grep -q "/tmp/"; then
+        local conflict="{
+            \"type\": \"temporary_directory_conflict\",
+            \"severity\": \"medium\",
+            \"description\": \"Multiple zones using /tmp directory may conflict\",
+            \"affected_zones\": $(echo "$shared_resources" | jq 'map(.zone)'),
+            \"resolution_strategy\": \"zone_specific_subdirectories\"
+        }"
+        conflicts=$(echo "$conflicts" | jq ". + [$conflict]")
+    fi
+
+    # Check for network port conflicts
+    local network_usage
+    network_usage=$(echo "$shared_resources" | jq -r '.[].network_ports')
+
+    if echo "$network_usage" | grep -q "dynamic"; then
+        local conflict="{
+            \"type\": \"dynamic_port_allocation_conflict\",
+            \"severity\": \"low\",
+            \"description\": \"Dynamic port allocation may cause conflicts\",
+            \"affected_zones\": $(echo "$shared_resources" | jq 'map(.zone)'),
+            \"resolution_strategy\": \"port_range_reservation\"
+        }"
+        conflicts=$(echo "$conflicts" | jq ". + [$conflict]")
+    fi
+
+    echo "$conflicts"
+}
+
+analyze_dependencies() {
+    local zone_config="$1"
+    local dependencies="[]"
+
+    # Check for cross-zone dependencies in task descriptions
+    local i=0
+    while IFS= read -r zone_name; do
+        local zone_data
+        zone_data=$(echo "$zone_config" | jq ".zones[$i]")
+        local task_description
+        task_description=$(echo "$zone_data" | jq -r '.task_description // ""')
+
+        # Look for dependency keywords
+        local dependency_patterns=("depends on" "requires" "after" "waits for" "needs")
+        local found_dependencies="[]"
+
+        for pattern in "${dependency_patterns[@]}"; do
+            if [[ "$task_description" =~ $pattern ]]; then
+                # Extract potential dependency target
+                local dependency_target
+                dependency_target=$(echo "$task_description" | grep -o "$pattern [^.]*" | sed "s/$pattern //" | xargs)
+
+                if [[ -n "$dependency_target" ]]; then
+                    found_dependencies=$(echo "$found_dependencies" | jq ". + [\"$dependency_target\"]")
+                fi
+            fi
+        done
+
+        if [[ "$(echo "$found_dependencies" | jq 'length')" -gt 0 ]]; then
+            local dependency_entry="{
+                \"zone\": \"$zone_name\",
+                \"dependencies\": $found_dependencies,
+                \"dependency_type\": \"explicit_text\"
+            }"
+            dependencies=$(echo "$dependencies" | jq ". + [$dependency_entry]")
+        fi
+
+        ((i++))
+    done < <(echo "$zone_config" | jq -r '.zones[].name')
+
+    echo "$dependencies"
+}
+
+create_resolution_strategies() {
+    local conflicts="$1"
+    local strategies="{}"
+
+    local conflict_count
+    conflict_count=$(echo "$conflicts" | jq 'length')
+
+    for ((i=0; i<conflict_count; i++)); do
+        local conflict
+        conflict=$(echo "$conflicts" | jq ".[$i]")
+        local conflict_type
+        conflict_type=$(echo "$conflict" | jq -r '.type')
+        local resolution_strategy
+        resolution_strategy=$(echo "$conflict" | jq -r '.resolution_strategy')
+
+        case "$conflict_type" in
+            "redis_namespace_collision")
+                local strategy="{
+                    \"approach\": \"namespace_isolation\",
+                    \"implementation\": \"zone_specific_redis_databases\",
+                    \"priority\": \"high\",
+                    \"estimated_effort\": \"low\",
+                    \"success_probability\": 0.95
+                }"
+                ;;
+            "temporary_directory_conflict")
+                local strategy="{
+                    \"approach\": \"zone_specific_subdirectories\",
+                    \"implementation\": \"timestamped_zone_directories\",
+                    \"priority\": \"medium\",
+                    \"estimated_effort\": \"low\",
+                    \"success_probability\": 0.90
+                }"
+                ;;
+            "dynamic_port_allocation_conflict")
+                local strategy="{
+                    \"approach\": \"port_range_reservation\",
+                    \"implementation\": \"pre_allocated_port_ranges_per_zone\",
+                    \"priority\": \"low\",
+                    \"estimated_effort\": \"medium\",
+                    \"success_probability\": 0.85
+                }"
+                ;;
+            *)
+                local strategy="{
+                    \"approach\": \"monitor_and_remediate\",
+                    \"implementation\": \"runtime_detection_and_correction\",
+                    \"priority\": \"medium\",
+                    \"estimated_effort\": \"high\",
+                    \"success_probability\": 0.70
+                }"
+                ;;
+        esac
+
+        strategies=$(echo "$strategies" | jq ".[\"$conflict_type\"] = $strategy")
+    done
+
+    echo "$strategies"
+}
+
+create_completion_pathways() {
+    local zone_config="$1"
+    local pathways="[]"
+
+    local i=0
+    while IFS= read -r zone_name; do
+        local zone_data
+        zone_data=$(echo "$zone_config" | jq ".zones[$i]")
+
+        local pathway="{
+            \"zone\": \"$zone_name\",
+            \"normal_flow\": [
+                \"agent_completion\",
+                \"coordinator_processing\",
+                \"main_chat_notification\"
+            ],
+            \"failure_flows\": {
+                \"agent_timeout\": [
+                    \"timeout_detection\",
+                    \"agent_cleanup\",
+                    \"coordinator_restart_or_abort\"
+                ],
+                \"coordinator_failure\": [
+                    \"failure_detection\",
+                    \"context_preservation\",
+                    \"coordinator_restart\",
+                    \"work_resumption\"
+                ],
+                \"namespace_corruption\": [
+                    \"corruption_detection\",
+                    \"emergency_stop\",
+                    \"context_recovery\",
+                    \"coordinator_restart\"
+                ]
+            },
+            \"escalation_triggers\": [
+                \"multiple_agent_failures\",
+                \"repeated_timeout_cycles\",
+                \"resource_exhaustion\"
+            ]
+        }"
+
+        pathways=$(echo "$pathways" | jq ". + [$pathway]")
+        ((i++))
+    done < <(echo "$zone_config" | jq -r '.zones[].name')
+
+    echo "$pathways"
+}
+
+generate_dependency_conflict_plan() {
+    local zone_config="$1"
+
+    info "Analyzing dependencies and conflicts for multi-coordinator execution"
+
+    # Identify shared resources
+    local shared_resources
+    shared_resources=$(identify_shared_resources "$zone_config")
+
+    # Detect potential conflicts
+    local conflicts
+    conflicts=$(detect_potential_conflicts "$shared_resources")
+
+    # Analyze dependencies
+    local dependencies
+    dependencies=$(analyze_dependencies "$zone_config")
+
+    # Create resolution strategies
+    local resolution_strategies
+    resolution_strategies=$(create_resolution_strategies "$conflicts")
+
+    # Create completion pathways
+    local completion_pathways
+    completion_pathways=$(create_completion_pathways "$zone_config")
+
+    # Generate complete analysis plan
+    local analysis_plan="{
+        \"timestamp\": $(date '+%s'),
+        \"zone_count\": $(echo "$zone_config" | jq '.zones | length'),
+        \"shared_resources_analysis\": $shared_resources,
+        \"detected_conflicts\": $conflicts,
+        \"dependency_analysis\": $dependencies,
+        \"resolution_strategies\": $resolution_strategies,
+        \"completion_pathways\": $completion_pathways,
+        \"recommendations\": {
+            \"isolation_level\": \"zone_based\",
+            \"monitoring_priority\": \"high\",
+            \"auto_recovery_enabled\": true,
+            \"manual_intervention_points\": [\"critical_conflicts\", \"escalation_triggers\"]
+        }
+    }"
+
+    echo "$analysis_plan"
+}
+
+display_analysis_summary() {
+    local analysis_plan="$1"
+
+    echo
+    info "=== Dependencies & Conflicts Analysis ==="
+    echo "Zones analyzed: $(echo "$analysis_plan" | jq -r '.zone_count')"
+    echo "Shared resources identified: $(echo "$analysis_plan" | jq -r '.shared_resources_analysis | length')"
+    echo "Potential conflicts detected: $(echo "$analysis_plan" | jq -r '.detected_conflicts | length')"
+    echo "Dependencies found: $(echo "$analysis_plan" | jq -r '.dependency_analysis | length')"
+    echo
+
+    if [[ "$(echo "$analysis_plan" | jq -r '.detected_conflicts | length')" -gt 0 ]]; then
+        echo "Conflict Summary:"
+        echo "$analysis_plan" | jq -r '.detected_conflicts[] | "  - \(.type): \(.description) (severity: \(.severity))"'
+        echo
+    fi
+
+    echo "Resolution Strategies:"
+    echo "$analysis_plan" | jq -r '.resolution_strategies | to_entries[] | "  - \(.key): \(.value.approach) (\(.value.success_probability * 100)% success)"'
+    echo
+
+    echo "Recommendations:"
+    echo "  - Isolation level: $(echo "$analysis_plan" | jq -r '.recommendations.isolation_level')"
+    echo "  - Monitoring priority: $(echo "$analysis_plan" | jq -r '.recommendations.monitoring_priority')"
+    echo "  - Auto recovery: $(echo "$analysis_plan" | jq -r '.recommendations.auto_recovery_enabled')"
+    echo
+}
+
+main() {
+    local config_file="$1"
+
+    if [[ -z "$config_file" ]]; then
+        error "Usage: $0 <zone-config-file>"
+    fi
+
+    if [[ ! -f "$config_file" ]]; then
+        error "Configuration file not found: $config_file"
+    fi
+
+    log "Starting dependency and conflict analysis for: $config_file"
+
+    # Read configuration
+    local zone_config
+    if ! zone_config=$(jq . "$config_file" 2>/dev/null); then
+        error "Invalid JSON in configuration file: $config_file"
+    fi
+
+    # Generate analysis plan
+    local analysis_plan
+    analysis_plan=$(generate_dependency_conflict_plan "$zone_config")
+
+    # Save analysis plan
+    local output_file="/tmp/dependency-conflict-analysis-$(date '+%s').json"
+    echo "$analysis_plan" > "$output_file"
+
+    log "✅ Dependency and conflict analysis completed"
+    log "Analysis plan saved to: $output_file"
+
+    # Display summary
+    display_analysis_summary "$analysis_plan"
+}
+
+# Execute main function with all arguments
+main "$@"