claude-flow-novice 2.18.6 → 2.18.8

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

@@ -1,62 +0,0 @@
-# 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-planning/lib/coordinator/map-dependencies-conflicts.sh

@@ -1,376 +0,0 @@
-#!/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 "$@"

package/claude-assets/skills/cfn-planning/lib/coordinator/plan-coordinator-resources.sh

@@ -1,258 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/../cfn-redis-coordination/redis-utils.sh"
-
-# Configuration
-DEFAULT_MEMORY_PER_COORDINATOR=2048  # MB
-DEFAULT_CPU_PER_COORDINATOR=2
-DEFAULT_REDIS_DB_START=1
-DEFAULT_REDIS_DB_END=15
-CLEANUP_OVERHEAD=0.15  # 15%
-MONITORING_OVERHEAD=0.05  # 5%
-
-# 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}"
-}
-
-get_system_resources() {
-    local memory_kb cpu_cores
-    memory_kb=$(grep MemTotal /proc/meminfo | awk '{print $2}')
-    cpu_cores=$(nproc)
-
-    local memory_mb=$((memory_kb / 1024))
-
-    echo "{\"memory_mb\": $memory_mb, \"cpu_cores\": $cpu_cores}"
-}
-
-calculate_max_coordinators() {
-    local system_resources="$1"
-    local memory_mb cpu_cores
-
-    memory_mb=$(echo "$system_resources" | jq -r '.memory_mb')
-    cpu_cores=$(echo "$system_resources" | jq -r '.cpu_cores')
-
-    # Calculate with overhead
-    local effective_memory=$((memory_mb - (memory_mb * CLEANUP_OVERHEAD + memory_mb * MONITORING_OVERHEAD)))
-    local effective_cpu=$((cpu_cores - (cpu_cores * CLEANUP_OVERHEAD + cpu_cores * MONITORING_OVERHEAD)))
-
-    local max_by_memory=$((effective_memory / DEFAULT_MEMORY_PER_COORDINATOR))
-    local max_by_cpu=$((effective_cpu / DEFAULT_CPU_PER_COORDINATOR))
-
-    # Return the smaller of the two limits
-    if [[ $max_by_memory -lt $max_by_cpu ]]; then
-        echo $max_by_memory
-    else
-        echo $max_by_cpu
-    fi
-}
-
-reserve_redis_namespace() {
-    local zone_name="$1"
-    local task_id="$2"
-    local redis_db="$3"
-
-    local namespace_pattern="swarm:zone-${zone_name}:${task_id}"
-
-    # Test Redis connectivity
-    if ! redis-cli ping >/dev/null 2>&1; then
-        error "Redis connection failed"
-    fi
-
-    # Reserve namespace with SETNX and TTL
-    local reservation_key="${namespace_pattern}:reservation"
-    local reservation_result
-    reservation_result=$(redis-cli setnx "$reservation_key" "$(date '+%s')" 2>/dev/null || echo "0")
-
-    if [[ "$reservation_result" != "1" ]]; then
-        error "Namespace already reserved: $namespace_pattern"
-    fi
-
-    # Set TTL for reservation (1 hour)
-    redis-cli expire "$reservation_key" 3600 >/dev/null
-
-    log "✓ Redis namespace reserved: $namespace_pattern (DB: $redis_db)"
-    echo "$namespace_pattern"
-}
-
-allocate_redis_databases() {
-    local zone_count="$1"
-    local start_db="$2"
-    local end_db="$3"
-
-    local available_dbs=$((end_db - start_db + 1))
-
-    if [[ $zone_count -gt $available_dbs ]]; then
-        error "Too many zones: $zone_count (available DBs: $available_dbs)"
-    fi
-
-    local db_allocation=()
-    for ((i=0; i<zone_count; i++)); do
-        db_allocation+=($((start_db + i)))
-    done
-
-    printf '%s\n' "${db_allocation[@]}"
-}
-
-generate_task_id() {
-    local zone_name="$1"
-    local timestamp
-    timestamp=$(date '+%s')
-
-    echo "zone-${zone_name}-${timestamp}"
-}
-
-plan_zone_resources() {
-    local zone_name="$1"
-    local redis_db="$2"
-    local task_data="$3"
-
-    local task_id
-    task_id=$(generate_task_id "$zone_name")
-
-    # Reserve Redis namespace
-    local namespace_pattern
-    namespace_pattern=$(reserve_redis_namespace "$zone_name" "$task_id" "$redis_db")
-
-    # Generate resource plan
-    local resource_plan="{
-        \"zone_name\": \"$zone_name\",
-        \"task_id\": \"$task_id\",
-        \"namespace_pattern\": \"$namespace_pattern\",
-        \"redis_db\": $redis_db,
-        \"memory_mb\": $DEFAULT_MEMORY_PER_COORDINATOR,
-        \"cpu_cores\": $DEFAULT_CPU_PER_COORDINATOR,
-        \"working_directory\": \"/tmp/zone-${zone_name}-${task_id}\",
-        \"monitoring_port\": $((8080 + redis_db)),
-        \"timestamp\": $(date '+%s')
-    }"
-
-    log "✓ Resource plan generated for zone: $zone_name"
-    echo "$resource_plan"
-}
-
-validate_resource_availability() {
-    local zone_count="$1"
-    local system_resources="$2"
-
-    local max_coordinators
-    max_coordinators=$(calculate_max_coordinators "$system_resources")
-
-    if [[ $zone_count -gt $max_coordinators ]]; then
-        error "Insufficient resources for $zone_count coordinators (maximum: $max_coordinators)"
-    fi
-
-    log "✓ Resource availability validated: $zone_count zones (capacity: $max_coordinators)"
-}
-
-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 coordinator resource planning 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
-
-    local zone_count
-    zone_count=$(echo "$zone_config" | jq '.zones | length')
-
-    if [[ $zone_count -eq 0 ]]; then
-        error "No zones found in configuration"
-    fi
-
-    info "Planning resources for $zone_count zones"
-
-    # Get system resources
-    local system_resources
-    system_resources=$(get_system_resources)
-
-    # Validate resource availability
-    validate_resource_availability "$zone_count" "$system_resources"
-
-    # Allocate Redis databases
-    local redis_dbs
-    mapfile -t redis_dbs < <(allocate_redis_databases "$zone_count" "$DEFAULT_REDIS_DB_START" "$DEFAULT_REDIS_DB_END")
-
-    # Generate resource plan for each zone
-    local resource_plans="[]"
-    local i=0
-
-    while IFS= read -r zone_name; do
-        local zone_data
-        zone_data=$(echo "$zone_config" | jq -r ".zones[$i]")
-
-        local resource_plan
-        resource_plan=$(plan_zone_resources "$zone_name" "${redis_dbs[$i]}" "$zone_data")
-
-        resource_plans=$(echo "$resource_plans" | jq ". + [$resource_plan]")
-
-        ((i++))
-    done < <(echo "$zone_config" | jq -r '.zones[].name')
-
-    # Generate complete resource allocation plan
-    local allocation_plan="{
-        \"timestamp\": $(date '+%s'),
-        \"zone_count\": $zone_count,
-        \"system_resources\": $system_resources,
-        \"max_coordinators\": $(calculate_max_coordinators "$system_resources"),
-        \"resource_plans\": $resource_plans,
-        \"redis_allocation\": {
-            \"databases_used\": $(printf '%s,' "${redis_dbs[@]}" | sed 's/,$//'),
-            \"total_allocated\": $zone_count
-        }
-    }"
-
-    # Save allocation plan
-    local output_file="/tmp/coordinator-resource-plan-$(date '+%s').json"
-    echo "$allocation_plan" > "$output_file"
-
-    log "✅ Coordinator resource planning completed"
-    log "Resource allocation plan saved to: $output_file"
-
-    # Display summary
-    echo
-    info "=== Resource Allocation Summary ==="
-    echo "Zones to execute: $zone_count"
-    echo "System memory: $(echo "$system_resources" | jq -r '.memory_mb') MB"
-    echo "System CPUs: $(echo "$system_resources" | jq -r '.cpu_cores')"
-    echo "Memory per coordinator: ${DEFAULT_MEMORY_PER_COORDINATOR} MB"
-    echo "CPUs per coordinator: ${DEFAULT_CPU_PER_COORDINATOR}"
-    echo "Redis databases allocated: ${redis_dbs[*]}"
-    echo
-}
-
-# Execute main function with all arguments
-main "$@"