claude-flow-novice 2.9.1 → 2.10.1

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

@@ -0,0 +1,124 @@
+#!/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/cfn-redis-coordination/agent-recovery.sh

@@ -0,0 +1,75 @@
+#!/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/cfn-redis-coordination/analyze-task-complexity.sh

@@ -0,0 +1,277 @@
+#!/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/cfn-redis-coordination/cancel-swarm.sh

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