claude-flow-novice 2.8.1 → 2.9.1

package/.claude/skills/redis-coordination/agent-log.sh

@@ -1,124 +0,0 @@
-#!/usr/bin/env bash
-
-# Agent Logging Utility - Dual output (terminal + Redis)
-#
-# Usage:
-#   source agent-log.sh
-#   agent_log "info" "Message here"
-#   agent_log "error" "Error occurred"
-#
-# Or as standalone:
-#   ./agent-log.sh "info" "Agent started" --agent-id "researcher-1" --task-id "task-123"
-
-set -euo pipefail
-
-# Color codes for terminal output
-COLOR_RESET="\033[0m"
-COLOR_DEBUG="\033[0;36m"   # Cyan
-COLOR_INFO="\033[0;32m"    # Green
-COLOR_WARN="\033[0;33m"    # Yellow
-COLOR_ERROR="\033[0;31m"   # Red
-COLOR_AGENT="\033[0;35m"   # Magenta
-
-# Get color for log level
-get_log_color() {
-  local level="$1"
-  case "$level" in
-    debug) echo "$COLOR_DEBUG" ;;
-    info)  echo "$COLOR_INFO" ;;
-    warn)  echo "$COLOR_WARN" ;;
-    error) echo "$COLOR_ERROR" ;;
-    *) echo "$COLOR_RESET" ;;
-  esac
-}
-
-# Main logging function
-# Usage: agent_log <level> <message> [--agent-id <id>] [--task-id <id>] [--no-terminal] [--no-redis]
-agent_log() {
-  local LEVEL="${1:-info}"
-  local MESSAGE="${2:-}"
-  local AGENT_ID="${AGENT_ID:-unknown}"
-  local TASK_ID="${TASK_ID:-unknown}"
-  local REPOSITORY=$(basename "$(pwd)")
-  local NO_TERMINAL=false
-  local NO_REDIS=false
-
-  # Parse optional arguments
-  shift 2 || true
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --agent-id)
-        AGENT_ID="$2"
-        shift 2
-        ;;
-      --task-id)
-        TASK_ID="$2"
-        shift 2
-        ;;
-      --no-terminal)
-        NO_TERMINAL=true
-        shift
-        ;;
-      --no-redis)
-        NO_REDIS=true
-        shift
-        ;;
-      *)
-        shift
-        ;;
-    esac
-  done
-
-  local TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-  local COLOR=$(get_log_color "$LEVEL")
-
-  # 1. Terminal output (with colors)
-  if [ "$NO_TERMINAL" = false ]; then
-    echo -e "${COLOR}[${LEVEL^^}]${COLOR_RESET} ${COLOR_AGENT}[${AGENT_ID}]${COLOR_RESET} ${MESSAGE}"
-  fi
-
-  # 2. File output (no colors, in /tmp)
-  local LOG_FILE="/tmp/agent-${AGENT_ID}.log"
-  echo "[${TIMESTAMP}] [${LEVEL^^}] [${AGENT_ID}] ${MESSAGE}" >> "$LOG_FILE"
-
-  # 3. Redis pub/sub (for portal)
-  if [ "$NO_REDIS" = false ]; then
-    local LOG_PAYLOAD=$(cat <<EOF
-{
-  "level": "${LEVEL}",
-  "message": "${MESSAGE}",
-  "agentId": "${AGENT_ID}",
-  "taskId": "${TASK_ID}",
-  "repository": "${REPOSITORY}",
-  "timestamp": "${TIMESTAMP}"
-}
-EOF
-)
-
-    # Publish to Redis channel: swarm:<task-id>:logs
-    redis-cli publish "swarm:${TASK_ID}:logs" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
-
-    # Also add to sorted set for persistence (with timestamp as score)
-    local SCORE=$(date +%s)
-    redis-cli zadd "swarm:${TASK_ID}:logs:history" "$SCORE" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
-
-    # Set TTL on history (7 days)
-    redis-cli expire "swarm:${TASK_ID}:logs:history" 604800 > /dev/null 2>&1 || true
-  fi
-}
-
-# If script is executed directly (not sourced)
-if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
-  if [ $# -lt 2 ]; then
-    echo "Usage: $0 <level> <message> [--agent-id <id>] [--task-id <id>]"
-    echo ""
-    echo "Levels: debug, info, warn, error"
-    echo ""
-    echo "Examples:"
-    echo "  $0 info \"Agent started\" --agent-id researcher-1 --task-id task-123"
-    echo "  $0 error \"Connection failed\" --agent-id reviewer-2 --task-id task-456"
-    exit 1
-  fi
-
-  agent_log "$@"
-fi

package/.claude/skills/redis-coordination/agent-recovery.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-# Redis Coordination Skill - Agent Emergency Recovery
-# Version: 1.0.0
-# Last Updated: 2025-10-19
-
-# Strict error handling
-set -euo pipefail
-
-# Default values
-TASK_ID=""
-AGENT_ID=""
-RECOVERY_MODE="soft"  # Options: soft, hard
-
-# Parse command-line arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --mode)
-            RECOVERY_MODE="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown parameter: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required parameters
-if [[ -z "$TASK_ID" || -z "$AGENT_ID" ]]; then
-    echo "Error: task-id and agent-id are required"
-    exit 1
-fi
-
-# Log recovery attempt
-echo "[$(date -u)] Attempting ${RECOVERY_MODE} recovery for agent: ${AGENT_ID}" >> /var/log/claude-flow/agent-recovery.log
-
-# Retrieve agent context before recovery
-AGENT_CONTEXT=$(redis-cli get "swarm:${TASK_ID}:${AGENT_ID}:context")
-
-# Recovery actions based on mode
-case "$RECOVERY_MODE" in
-    "soft")
-        # Soft recovery: Spawn new agent with previous context
-        npx claude-flow@alpha spawn "$AGENT_ID" \
-            --task-id "$TASK_ID" \
-            --recovery-context "$AGENT_CONTEXT"
-        ;;
-    "hard")
-        # Hard recovery: Full agent replacement
-        npx claude-flow@alpha spawn "$AGENT_ID" \
-            --task-id "$TASK_ID" \
-            --mode replace \
-            --recovery-context "$AGENT_CONTEXT"
-        ;;
-    *)
-        echo "Invalid recovery mode: ${RECOVERY_MODE}"
-        exit 1
-        ;;
-esac
-
-# Update active agents set
-redis-cli sadd "swarm:${TASK_ID}:active-agents" "$AGENT_ID"
-
-# Log recovery completion
-echo "[$(date -u)] Recovery completed for agent: ${AGENT_ID}" >> /var/log/claude-flow/agent-recovery.log
-
-exit 0

package/.claude/skills/redis-coordination/analyze-task-complexity.sh

@@ -1,277 +0,0 @@
-#!/usr/bin/env bash
-##############################################################################
-# Task Complexity Analyzer
-#
-# Purpose: Deterministically analyze task complexity and determine optimal
-#          number of Loop 3 agents needed.
-#
-# Usage:
-#   ./analyze-task-complexity.sh --task "Build React dashboard" [--difficulty auto]
-#
-# Output (JSON):
-#   {
-#     "complexity_score": 7.5,
-#     "difficulty": "standard",
-#     "domains": ["frontend", "backend"],
-#     "suggested_agents": {
-#       "loop3_count": 3,
-#       "loop2_count": 4
-#     },
-#     "reasoning": "Multi-domain task with moderate scope"
-#   }
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_DESCRIPTION=""
-DIFFICULTY="auto"  # auto | simple | standard | complex | enterprise
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task)
-      TASK_DESCRIPTION="$2"
-      shift 2
-      ;;
-    --difficulty)
-      DIFFICULTY="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-if [ -z "$TASK_DESCRIPTION" ]; then
-  echo "Error: --task required" >&2
-  exit 1
-fi
-
-##############################################################################
-# Complexity Scoring Algorithm
-##############################################################################
-
-TASK_LOWER=$(echo "$TASK_DESCRIPTION" | tr '[:upper:]' '[:lower:]')
-COMPLEXITY_SCORE=0
-DETECTED_DOMAINS=()
-REASONING=""
-
-# 1. Word Count (longer = more complex)
-WORD_COUNT=$(echo "$TASK_DESCRIPTION" | wc -w)
-if [ "$WORD_COUNT" -lt 5 ]; then
-  WORD_SCORE=1
-elif [ "$WORD_COUNT" -lt 10 ]; then
-  WORD_SCORE=2
-elif [ "$WORD_COUNT" -lt 20 ]; then
-  WORD_SCORE=3
-else
-  WORD_SCORE=4
-fi
-COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + WORD_SCORE))
-
-# 2. Domain Detection (multi-domain = more complex)
-DOMAIN_COUNT=0
-
-if [[ "$TASK_LOWER" =~ react|frontend|ui|component|dashboard ]]; then
-  DETECTED_DOMAINS+=("frontend")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ api|backend|server|endpoint|rest|graphql ]]; then
-  DETECTED_DOMAINS+=("backend")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ database|db|sql|postgres|mongo|redis ]]; then
-  DETECTED_DOMAINS+=("database")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ deploy|infra|docker|k8s|kubernetes|aws|cloud ]]; then
-  DETECTED_DOMAINS+=("infrastructure")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ auth|security|encrypt|permission|rbac ]]; then
-  DETECTED_DOMAINS+=("security")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ test|qa|validation|coverage ]]; then
-  DETECTED_DOMAINS+=("testing")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ architect|design|pattern|system ]]; then
-  DETECTED_DOMAINS+=("architecture")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-if [[ "$TASK_LOWER" =~ rust|cargo|tokio ]]; then
-  DETECTED_DOMAINS+=("rust")
-  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
-fi
-
-# Domain score: 2 points per domain
-DOMAIN_SCORE=$((DOMAIN_COUNT * 2))
-COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + DOMAIN_SCORE))
-
-# 3. Explicit Scope Indicators
-if [[ "$TASK_LOWER" =~ simple|quick|small|basic|minimal|mvp ]]; then
-  SCOPE_MODIFIER=-2
-  SCOPE_LABEL="reduced (MVP scope detected)"
-elif [[ "$TASK_LOWER" =~ production|enterprise|scalable|robust|complete|full ]]; then
-  SCOPE_MODIFIER=3
-  SCOPE_LABEL="increased (enterprise scope detected)"
-elif [[ "$TASK_LOWER" =~ prototype|poc|proof.of.concept ]]; then
-  SCOPE_MODIFIER=-1
-  SCOPE_LABEL="slightly reduced (prototype scope)"
-else
-  SCOPE_MODIFIER=0
-  SCOPE_LABEL="standard"
-fi
-COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + SCOPE_MODIFIER))
-
-# 4. Feature Counting (and, with, includes, etc.)
-FEATURE_COUNT=0
-if [[ "$TASK_LOWER" =~ " and " ]]; then
-  FEATURE_COUNT=$((FEATURE_COUNT + 1))
-fi
-if [[ "$TASK_LOWER" =~ " with " ]]; then
-  FEATURE_COUNT=$((FEATURE_COUNT + 1))
-fi
-if [[ "$TASK_LOWER" =~ " including " ]]; then
-  FEATURE_COUNT=$((FEATURE_COUNT + 1))
-fi
-
-FEATURE_SCORE=$((FEATURE_COUNT))
-COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + FEATURE_SCORE))
-
-# 5. Integration Keywords (increases complexity)
-INTEGRATION_COUNT=0
-if [[ "$TASK_LOWER" =~ integrat|connect|sync|webhook ]]; then
-  INTEGRATION_COUNT=$((INTEGRATION_COUNT + 1))
-fi
-if [[ "$TASK_LOWER" =~ third.party|external|api ]]; then
-  INTEGRATION_COUNT=$((INTEGRATION_COUNT + 1))
-fi
-
-INTEGRATION_SCORE=$((INTEGRATION_COUNT))
-COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + INTEGRATION_SCORE))
-
-##############################################################################
-# Difficulty Classification
-##############################################################################
-
-if [ "$DIFFICULTY" = "auto" ]; then
-  if [ "$COMPLEXITY_SCORE" -le 3 ]; then
-    DIFFICULTY="simple"
-  elif [ "$COMPLEXITY_SCORE" -le 7 ]; then
-    DIFFICULTY="standard"
-  elif [ "$COMPLEXITY_SCORE" -le 12 ]; then
-    DIFFICULTY="complex"
-  else
-    DIFFICULTY="enterprise"
-  fi
-fi
-
-##############################################################################
-# Agent Count Calculation
-##############################################################################
-
-case "$DIFFICULTY" in
-  simple)
-    # MVP/Simple: 1-2 Loop 3 agents
-    BASE_LOOP3=1
-    BASE_LOOP2=2
-    REASONING="Simple task with minimal scope"
-    ;;
-  standard)
-    # Standard: 2-3 Loop 3 agents
-    BASE_LOOP3=2
-    BASE_LOOP2=3
-    REASONING="Standard task with moderate complexity"
-    ;;
-  complex)
-    # Complex: 3-5 Loop 3 agents
-    BASE_LOOP3=3
-    BASE_LOOP2=4
-    REASONING="Complex task with multiple domains"
-    ;;
-  enterprise)
-    # Enterprise: 5-8 Loop 3 agents
-    BASE_LOOP3=5
-    BASE_LOOP2=5
-    REASONING="Enterprise-grade task with high complexity"
-    ;;
-  *)
-    echo "Error: Invalid difficulty: $DIFFICULTY" >&2
-    exit 1
-    ;;
-esac
-
-# Scale by domain count (1 extra agent per additional domain beyond 2)
-if [ "$DOMAIN_COUNT" -gt 2 ]; then
-  EXTRA_AGENTS=$((DOMAIN_COUNT - 2))
-  LOOP3_COUNT=$((BASE_LOOP3 + EXTRA_AGENTS))
-else
-  LOOP3_COUNT=$BASE_LOOP3
-fi
-
-# Cap at reasonable limits
-if [ "$LOOP3_COUNT" -gt 8 ]; then
-  LOOP3_COUNT=8
-fi
-
-# Loop 2 scales with Loop 3 (but slower: +1 validator per 2 implementers)
-LOOP2_COUNT=$((BASE_LOOP2 + (LOOP3_COUNT - BASE_LOOP3) / 2))
-if [ "$LOOP2_COUNT" -gt 6 ]; then
-  LOOP2_COUNT=6
-fi
-
-# Ensure minimum validators
-if [ "$LOOP2_COUNT" -lt 2 ]; then
-  LOOP2_COUNT=2
-fi
-
-##############################################################################
-# Build Reasoning String
-##############################################################################
-
-REASONING_DETAILS="$REASONING (complexity score: $COMPLEXITY_SCORE, domains: $DOMAIN_COUNT, scope: $SCOPE_LABEL)"
-
-##############################################################################
-# Output JSON
-##############################################################################
-
-# Convert array to JSON array
-DOMAINS_JSON=$(printf '%s\n' "${DETECTED_DOMAINS[@]}" | jq -R . | jq -s .)
-
-jq -nc \
-  --arg complexity "$COMPLEXITY_SCORE" \
-  --arg difficulty "$DIFFICULTY" \
-  --argjson domains "$DOMAINS_JSON" \
-  --arg loop3 "$LOOP3_COUNT" \
-  --arg loop2 "$LOOP2_COUNT" \
-  --arg reasoning "$REASONING_DETAILS" \
-  --arg word_count "$WORD_COUNT" \
-  --arg domain_count "$DOMAIN_COUNT" \
-  --arg feature_count "$FEATURE_COUNT" \
-  '{
-    complexity_score: ($complexity | tonumber),
-    difficulty: $difficulty,
-    domains: $domains,
-    suggested_agents: {
-      loop3_count: ($loop3 | tonumber),
-      loop2_count: ($loop2 | tonumber)
-    },
-    reasoning: $reasoning,
-    analysis: {
-      word_count: ($word_count | tonumber),
-      domain_count: ($domain_count | tonumber),
-      feature_count: ($feature_count | tonumber)
-    }
-  }'

package/.claude/skills/redis-coordination/cancel-swarm.sh

@@ -1,221 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Cancel Swarm - Graceful shutdown for all agents in a swarm
-#
-# Publishes shutdown signals to all active agents via their wake channels,
-# marks swarm status as cancelled, and reports cancellation metrics.
-#
-# Usage:
-#   ./cancel-swarm.sh --task-id <id> \
-#                     [--reason <text>] \
-#                     [--initiator <name>] \
-#                     [--force]
-#
-# Options:
-#   --task-id      Task/swarm identifier (required)
-#   --reason       Cancellation reason (default: user_requested_cancellation)
-#   --initiator    Who initiated cancellation (default: main-chat)
-#   --force        Skip confirmation prompt
-#
-# Shutdown Signal Format (broadcasted to shutdown channel):
-# {
-#   "reason": "user_requested_cancellation",
-#   "timestamp": 1760896218,
-#   "initiator": "main-chat"
-# }
-#
-# How It Works:
-#   1. Broadcasts a single shutdown message to swarm:${TASK_ID}:shutdown
-#   2. All agents in waiting mode poll this key every 1 second
-#   3. When agents detect the shutdown signal, they exit gracefully (exit 130)
-#   4. Swarm metadata is updated to status="cancelled" with metrics
-#
-# Benefits:
-#   - Graceful agent termination (agents receive explicit shutdown signal)
-#   - Prevents orphaned BLPOP operations
-#   - Audit trail (cancellation reason + timestamp)
-#   - Cleanup coordination (all agents notified simultaneously)
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_ID=""
-REASON="user_requested_cancellation"
-INITIATOR="main-chat"
-FORCE=false
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --reason)
-      REASON="$2"
-      shift 2
-      ;;
-    --initiator)
-      INITIATOR="$2"
-      shift 2
-      ;;
-    --force)
-      FORCE=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      echo "Usage: $0 --task-id <id> [--reason <text>] [--initiator <name>] [--force]"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ]; then
-  echo "Error: --task-id required"
-  echo "Usage: $0 --task-id <id>"
-  exit 1
-fi
-
-# Look for swarm metadata (try both task-id and swarm-id patterns)
-METADATA_KEY="swarm:${TASK_ID}:metadata"
-SWARM_ID_KEY=""
-
-# Check if metadata exists with task-id
-if redis-cli exists "$METADATA_KEY" | grep -q "1"; then
-  SWARM_ID_KEY="$METADATA_KEY"
-else
-  # Try to find swarm by task_id field
-  SWARM_KEYS=$(redis-cli --scan --pattern "swarm:*:metadata" 2>/dev/null || echo "")
-
-  if [ -n "$SWARM_KEYS" ]; then
-    for KEY in $SWARM_KEYS; do
-      TASK_VAL=$(redis-cli hget "$KEY" task_id 2>/dev/null || echo "")
-      if [ "$TASK_VAL" = "$TASK_ID" ]; then
-        SWARM_ID_KEY="$KEY"
-        break
-      fi
-    done
-  fi
-fi
-
-# Validate swarm exists
-if [ -z "$SWARM_ID_KEY" ]; then
-  echo "Error: No swarm found for task-id: $TASK_ID"
-  echo "Hint: Verify task-id or check 'list-active-swarms.sh' for active swarms"
-  exit 1
-fi
-
-# Extract swarm_id from key
-SWARM_ID=$(redis-cli hget "$SWARM_ID_KEY" swarm_id)
-
-# Get agent list
-AGENTS_STR=$(redis-cli hget "$SWARM_ID_KEY" agents)
-if [ -z "$AGENTS_STR" ] || [ "$AGENTS_STR" = "(nil)" ]; then
-  echo "Warning: No agents found in swarm metadata"
-  AGENTS_STR=""
-fi
-
-# Get current swarm status
-CURRENT_STATUS=$(redis-cli hget "$SWARM_ID_KEY" status)
-
-echo "========================================="
-echo "Swarm Cancellation Request"
-echo "========================================="
-echo "Swarm ID:       $SWARM_ID"
-echo "Task ID:        $TASK_ID"
-echo "Current Status: $CURRENT_STATUS"
-echo "Agents:         $AGENTS_STR"
-echo "Reason:         $REASON"
-echo "Initiator:      $INITIATOR"
-echo "========================================="
-
-# Confirmation prompt (unless --force)
-if [ "$FORCE" = false ]; then
-  read -p "Proceed with cancellation? (yes/no): " CONFIRM
-  if [ "$CONFIRM" != "yes" ]; then
-    echo "Cancellation aborted by user."
-    exit 0
-  fi
-fi
-
-echo ""
-echo "[Cancel] Starting graceful shutdown..."
-
-# Build shutdown message
-TIMESTAMP=$(date +%s)
-SHUTDOWN_MSG=$(jq -n \
-  --arg reason "$REASON" \
-  --arg ts "$TIMESTAMP" \
-  --arg init "$INITIATOR" \
-  '{
-    reason: $reason,
-    timestamp: ($ts | tonumber),
-    initiator: $init
-  }')
-
-# Broadcast shutdown signal to all waiting agents
-SHUTDOWN_KEY="swarm:${TASK_ID}:shutdown"
-
-# Use LPUSH to add shutdown signal (all agents in waiting mode will check this key)
-if echo "$SHUTDOWN_MSG" | redis-cli -x LPUSH "$SHUTDOWN_KEY" > /dev/null 2>&1; then
-  echo "[Cancel] ✓ Shutdown signal broadcasted to: $SHUTDOWN_KEY"
-else
-  echo "[Cancel] ✗ Failed to broadcast shutdown signal"
-  exit 1
-fi
-
-# Set TTL on shutdown key to prevent indefinite retention
-redis-cli expire "$SHUTDOWN_KEY" 3600 > /dev/null 2>&1 || true
-
-# Counter for agent list (for metrics)
-AGENT_COUNT=0
-if [ -n "$AGENTS_STR" ]; then
-  IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS_STR"
-  AGENT_COUNT=${#AGENT_ARRAY[@]}
-
-  echo "[Cancel] Agents in swarm: $AGENT_COUNT"
-  for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-    AGENT_ID=$(echo "$AGENT_ID" | xargs)
-    if [ -n "$AGENT_ID" ]; then
-      echo "[Cancel]   - $AGENT_ID (will receive shutdown on next poll)"
-    fi
-  done
-else
-  echo "[Cancel] No agents in swarm"
-fi
-
-# Note: We broadcast once to all agents instead of individual notifications
-# This is more efficient and follows the same pattern as invoke-waiting-mode.sh shutdown command
-NOTIFIED_COUNT="$AGENT_COUNT"
-FAILED_COUNT=0
-
-# Update swarm metadata
-redis-cli hset "$SWARM_ID_KEY" \
-  status "cancelled" \
-  cancelled_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  cancellation_reason "$REASON" \
-  cancellation_initiator "$INITIATOR" \
-  agents_notified "$NOTIFIED_COUNT" \
-  agents_failed "$FAILED_COUNT" > /dev/null
-
-echo ""
-echo "========================================="
-echo "Cancellation Summary"
-echo "========================================="
-echo "Swarm ID:          $SWARM_ID"
-echo "Status:            cancelled"
-echo "Agents in Swarm:   $NOTIFIED_COUNT"
-echo "Shutdown Broadcast: Sent to $SHUTDOWN_KEY"
-echo ""
-echo "Note: All agents in waiting mode will receive"
-echo "      the shutdown signal on their next poll"
-echo "      cycle (max 1 second delay)."
-echo "========================================="
-echo ""
-
-echo "[Cancel] ✅ Graceful shutdown complete"
-exit 0