claude-flow-novice 2.6.0 → 2.9.0

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/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

package/.claude/skills/redis-coordination/cfn-loop-relaunch.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-TASK_ID="web-portal-skills-loop3"
-AGENT_ID="tester"
-CONTEXT="Relaunch Loop 3: Complete missing 5/8 test cases"
-
-# Enter waiting mode
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "$CONTEXT"
-
-# Signal task details via Redis
-redis-cli set "swarm:${TASK_ID}:details" "$CONTEXT"
-
-# TODO: Actual agent spawning logic would be here
-npx claude-flow-novice spawn-agent tester \
-  --task "Complete web portal skills test suite" \
-  --context "$CONTEXT" \
-  --skills cfn-loop-validation
-
-# Report completion and confidence
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.90 \
-  --iteration 1
-

package/.claude/skills/redis-coordination/check-dependencies.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-# Dependency checker for Redis Coordination
-
-check_command() {
-  if command -v "$1" &> /dev/null; then
-    VERSION=$($1 --version 2>&1 | head -n1)
-    echo "✅ $1: $VERSION"
-    return 0
-  else
-    echo "❌ $1: NOT FOUND"
-    return 1
-  fi
-}
-
-echo "Checking dependencies for Redis Coordination..."
-MISSING=0
-
-# Required dependencies
-check_command "node" || MISSING=$((MISSING+1))
-check_command "redis-server" || MISSING=$((MISSING+1))
-check_command "redis-cli" || MISSING=$((MISSING+1))
-check_command "jq" || MISSING=$((MISSING+1))
-
-if [ $MISSING -eq 0 ]; then
-  echo ""
-  echo "✅ All required dependencies installed"
-  exit 0
-else
-  echo ""
-  echo "❌ Missing $MISSING required dependencies"
-  exit 1
-fi

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

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Complete Swarm - Mark swarm as completed with final metrics
-#
-# Updates swarm metadata status to "completed" and stores final metrics.
-#
-# Usage:
-#   ./complete-swarm.sh --swarm-id <id> \
-#                       [--final-metric <name=value>] \
-#                       [--final-metric <name=value>] ...
-#
-# Example:
-#   ./complete-swarm.sh --swarm-id "swarm-auth-123" \
-#                       --final-metric "consensus=0.92" \
-#                       --final-metric "iterations=3"
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-SWARM_ID=""
-declare -A FINAL_METRICS
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --swarm-id)
-      SWARM_ID="$2"
-      shift 2
-      ;;
-    --final-metric)
-      # Parse name=value
-      IFS='=' read -r KEY VALUE <<< "$2"
-      FINAL_METRICS["$KEY"]="$VALUE"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      echo "Usage: $0 --swarm-id <id> [--final-metric <name=value>]"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$SWARM_ID" ]; then
-  echo "Error: --swarm-id required"
-  echo "Usage: $0 --swarm-id <id>"
-  exit 1
-fi
-
-METADATA_KEY="swarm:${SWARM_ID}:metadata"
-
-# Check if swarm exists
-if ! redis-cli exists "$METADATA_KEY" | grep -q "1"; then
-  echo "Error: Swarm not found: $SWARM_ID"
-  exit 1
-fi
-
-echo "[Swarm] Completing swarm: $SWARM_ID"
-
-# Update status
-redis-cli hset "$METADATA_KEY" \
-  status "completed" \
-  completed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
-
-# Add final metrics
-for KEY in "${!FINAL_METRICS[@]}"; do
-  VALUE="${FINAL_METRICS[$KEY]}"
-  redis-cli hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
-  echo "[Swarm] Stored metric: $KEY = $VALUE"
-done
-
-echo "[Swarm] ✅ Completion recorded"

package/.claude/skills/redis-coordination/config.json

@@ -1,61 +0,0 @@
-{
-  "version": "4.0.0",
-  "host": "localhost",
-  "port": 6379,
-  "db": 0,
-  "retryPolicy": {
-    "enabled": true,
-    "maxRetries": 3,
-    "retryDelay": 5000,
-    "exponentialBackoff": true,
-    "dlq": {
-      "enabled": true,
-      "ttl": 604800
-    }
-  },
-  "waitingMode": {
-    "defaultTimeout": 300000,
-    "wakeChannelPattern": "task:{taskId}:agent:{agentId}:wake",
-    "resultKeyPattern": "task:{taskId}:agent:{agentId}:result",
-    "consensusThreshold": 0.90
-  },
-  "heartbeat": {
-    "enabled": true,
-    "ttl": 60,
-    "checkInterval": 30,
-    "missThreshold": 2,
-    "agentMonitorKey": "swarm:agent:{agentId}:heartbeat",
-    "fallbackStrategy": "quorum_recalculation"
-  },
-  "patterns": {
-    "chain": { "enabled": true },
-    "hierarchical": { "enabled": true },
-    "mesh": { "enabled": true }
-  },
-  "metrics": {
-    "enabled": true,
-    "retention": 604800,
-    "export_formats": ["json", "prometheus"]
-  },
-  "features": {
-    "enableRetry": true,
-    "enableQuorum": false,
-    "enablePriorityWake": {
-      "default": false,
-      "description": "Enable priority-based wake mechanism",
-      "stage": "experimental",
-      "rollout_percentage": 10
-    },
-    "enableHeartbeat": true,
-    "enableMetrics": true
-  },
-  "priorityWakeSettings": {
-    "priorityMultiplier": 1000000,
-    "priorityLevels": {
-      "critical": {"range": [0, 10], "description": "Product Owner, System Coordinators"},
-      "high": {"range": [11, 30], "description": "Loop 2 Validators"},
-      "medium": {"range": [31, 60], "description": "Loop 3 Implementers"},
-      "low": {"range": [61, 100], "description": "Background Tasks"}
-    }
-  }
-}

package/.claude/skills/redis-coordination/examples/README.md

@@ -1,73 +0,0 @@
-# CFN Loop Metrics Dashboard
-
-## Grafana Dashboard for CFN Loop Performance Monitoring
-
-### Dashboard Overview
-
-This Grafana dashboard is designed to visualize and monitor the performance metrics of Continuous Flow Normalization (CFN) Loop iterations. It provides insights into:
-
-- Iteration Duration Trends
-- Consensus Convergence
-- Agent Latency
-- Error Rates
-
-### Prerequisites
-
-- Prometheus as the metrics backend
-- Grafana 7.3.7 or higher
-- Configured Prometheus metrics for CFN Loop
-
-### Metrics Requirements
-
-The following Prometheus metrics must be exported:
-
-1. `cfn_loop_iteration_duration_seconds`
-   - Time series of iteration durations
-   - Labels: `iteration`
-
-2. `cfn_loop_confidence`
-   - Confidence scores for Loop 3
-   - Labels: `stage="loop3"`
-
-3. `cfn_loop_consensus`
-   - Consensus scores for Loop 2
-   - Labels: `stage="loop2"`
-
-4. `cfn_loop_agent_latency_seconds_bucket`
-   - Histogram of agent latencies
-   - Labels: `agent_id`
-
-5. `cfn_loop_errors_total`
-   - Counter for different error types
-   - Labels: `error_type` (e.g., "timeout", "retry", "quorum_fallback", "gate_failure")
-
-### Installation Steps
-
-1. Open Grafana
-2. Navigate to Dashboard > Import
-3. Upload `grafana-dashboard.json`
-4. Select Prometheus data source
-5. Click "Import"
-
-### Customization
-
-- Adjust time ranges in the dashboard settings
-- Modify thresholds in panel configurations as needed
-
-### Troubleshooting
-
-- Ensure all required Prometheus metrics are being exported
-- Check data source configuration
-- Verify metric naming matches exported metrics
-
-### Performance Tuning
-
-The dashboard is optimized for minimal performance overhead:
-- Uses efficient PromQL queries
-- Configurable refresh intervals
-- Dark theme for reduced eye strain during long monitoring sessions
-
-### Version
-
-- Dashboard Version: 1.0.0
-- Last Updated: 2025-10-19