claude-flow-novice 2.18.6 → 2.18.8

package/.claude/skills/cfn-memory-persistence/lib/redis/cfn-loop-relaunch.sh.backup

@@ -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/cfn-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/cfn-redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.90 \
-  --iteration 1
-

package/.claude/skills/cfn-memory-persistence/lib/redis/collect-confidence-scores.sh.backup

@@ -1,209 +0,0 @@
-#!/bin/bash
-#
-# Collect Confidence Scores - Stateless Agent Coordination
-#
-# Extracts confidence scores from multiple agents after they exit.
-# Replaces the 'collect' function from invoke-waiting-mode.sh for stateless architecture.
-#
-# Usage:
-#   ./collect-confidence-scores.sh --task-id <task> --agent-ids <id1,id2,id3> [--min-quorum <0.66|66%|2>] [--namespace swarm]
-#
-# Returns:
-#   Average confidence score (0.0-1.0) to stdout
-#   Verbose messages to stderr
-#
-# Exit Codes:
-#   0 - Success (consensus calculated)
-#   1 - Quorum not met or missing required parameters
-
-set -euo pipefail
-
-# Validate required tools are available
-MISSING_TOOLS=()
-for TOOL in redis-cli jq bc; do
-    if ! command -v "$TOOL" >/dev/null 2>&1; then
-        MISSING_TOOLS+=("$TOOL")
-    fi
-done
-
-if [ ${#MISSING_TOOLS[@]} -gt 0 ]; then
-    echo "❌ ERROR: Required tools not found: ${MISSING_TOOLS[*]}" >&2
-    echo "   Install missing tools and retry" >&2
-    exit 1
-fi
-
-# Source centralized Redis functions (provides graceful fallback for Task mode)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Verify redis-functions.sh exists and is readable before sourcing
-REDIS_FUNCTIONS="${SCRIPT_DIR}/redis-functions.sh"
-if [ ! -r "$REDIS_FUNCTIONS" ]; then
-    echo "❌ ERROR: Cannot read redis-functions.sh at: $REDIS_FUNCTIONS" >&2
-    exit 1
-fi
-
-# Source with explicit error handling
-if ! source "$REDIS_FUNCTIONS"; then
-    echo "❌ ERROR: Failed to source redis-functions.sh" >&2
-    exit 1
-fi
-
-# Debug mode (set DEBUG=true for verbose output)
-DEBUG="${DEBUG:-false}"
-
-# Parse arguments
-TASK_ID=""
-AGENT_IDS=""
-MIN_QUORUM=""
-NAMESPACE="swarm"
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-ids)
-            AGENT_IDS="$2"
-            shift 2
-            ;;
-        --min-quorum)
-            MIN_QUORUM="$2"
-            shift 2
-            ;;
-        --namespace)
-            NAMESPACE="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required parameters
-if [ -z "$TASK_ID" ] || [ -z "$AGENT_IDS" ]; then
-    echo "Error: collect-confidence-scores requires --task-id and --agent-ids" >&2
-    echo "" >&2
-    echo "Usage:" >&2
-    echo "  ./collect-confidence-scores.sh --task-id <task> --agent-ids <id1,id2,id3> [--min-quorum <0.66|66%|2>]" >&2
-    exit 1
-fi
-
-# Output verbose messages to stderr
-echo "[Coordinator] Collecting confidence scores from agents..." >&2
-echo "" >&2
-
-# Split agent IDs
-IFS=',' read -ra AGENTS <<< "$AGENT_IDS"
-
-RESULTS=()
-CONFIDENCES=()
-ALL_FEEDBACK=()
-
-for AGENT in "${AGENTS[@]}"; do
-    RESULT_KEY="${NAMESPACE}:${TASK_ID}:${AGENT}:result"
-
-    # Get latest result (non-blocking)
-    RESULT=$(redis-cli LPOP "$RESULT_KEY" 2>/dev/null || echo "")
-
-    if [ -n "$RESULT" ] && [ "$RESULT" != "(nil)" ]; then
-        # Handle both simple numeric format and JSON format
-        # Try to parse as JSON first, fall back to simple number
-        if CONF=$(echo "$RESULT" | jq -r '.confidence' 2>/dev/null) && [ "$CONF" != "null" ]; then
-            # JSON format: {"confidence":0.85,"iteration":1,...}
-            echo "  [$AGENT] Confidence: $CONF" >&2
-            RESULTS+=("$RESULT")
-            CONFIDENCES+=("$CONF")
-
-            # Check if result includes feedback array
-            FEEDBACK=$(echo "$RESULT" | jq -r '.feedback // empty | .[]?' 2>/dev/null || echo "")
-            if [ -n "$FEEDBACK" ]; then
-                echo "  [$AGENT] Feedback provided:" >&2
-                echo "$RESULT" | jq -r '.feedback[]' 2>/dev/null | sed 's/^/    - /' >&2
-
-                # Collect all feedback items
-                while IFS= read -r ITEM; do
-                    [ -n "$ITEM" ] && ALL_FEEDBACK+=("$ITEM")
-                done < <(echo "$RESULT" | jq -r '.feedback[]' 2>/dev/null || echo "")
-            fi
-        elif [[ "$RESULT" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-            # Simple numeric format: "0.85"
-            CONF="$RESULT"
-            echo "  [$AGENT] Confidence: $CONF" >&2
-            CONFIDENCES+=("$CONF")
-        else
-            echo "  [$AGENT] ⚠️  Invalid result format: $RESULT" >&2
-        fi
-    else
-        echo "  [$AGENT] ⚠️  No result found" >&2
-    fi
-done
-
-# Validate quorum if specified
-TOTAL_AGENTS=${#AGENTS[@]}
-RESPONDING_AGENTS=${#CONFIDENCES[@]}
-
-if [ -n "$MIN_QUORUM" ]; then
-    # Parse min-quorum (supports: absolute number, percentage, or decimal)
-    if [[ "$MIN_QUORUM" =~ ^[0-9]+%$ ]]; then
-        # Percentage format: "66%"
-        PCT=${MIN_QUORUM%\%}
-        REQUIRED=$(echo "scale=0; ($TOTAL_AGENTS * $PCT) / 100" | bc)
-    elif [[ "$MIN_QUORUM" =~ ^0\.[0-9]+$ ]]; then
-        # Decimal format: "0.66"
-        REQUIRED=$(echo "scale=0; ($TOTAL_AGENTS * $MIN_QUORUM) / 1" | bc)
-    else
-        # Absolute number format: "2"
-        REQUIRED=$MIN_QUORUM
-    fi
-
-    if [ "$RESPONDING_AGENTS" -lt "$REQUIRED" ]; then
-        echo "" >&2
-        echo "[Coordinator] ❌ Quorum not met" >&2
-        echo "  Required: $REQUIRED agents" >&2
-        echo "  Responding: $RESPONDING_AGENTS agents" >&2
-        exit 1
-    fi
-fi
-
-# Calculate consensus
-if [ ${#CONFIDENCES[@]} -gt 0 ]; then
-    SUM=0
-    for CONF in "${CONFIDENCES[@]}"; do
-        SUM=$(echo "$SUM + $CONF" | bc)
-    done
-    COUNT=${#CONFIDENCES[@]}
-    CONSENSUS=$(echo "scale=2; $SUM / $COUNT" | bc)
-
-    # Ensure leading zero for bc output (handles .87 -> 0.87)
-    if [[ "$CONSENSUS" =~ ^\. ]]; then
-        CONSENSUS="0$CONSENSUS"
-    fi
-
-    echo "" >&2
-    echo "[Coordinator] Average Confidence: $CONSENSUS" >&2
-
-    # Print aggregated feedback if available
-    if [ ${#ALL_FEEDBACK[@]} -gt 0 ]; then
-        echo "" >&2
-        echo "[Coordinator] Aggregated Feedback:" >&2
-        for ITEM in "${ALL_FEEDBACK[@]}"; do
-            echo "  - $ITEM" >&2
-        done
-
-        # Store feedback in Redis for next iteration
-        FEEDBACK_JSON=$(jq -n --argjson items "$(printf '%s\n' "${ALL_FEEDBACK[@]}" | jq -R . | jq -s .)" '$items')
-        FEEDBACK_KEY="${NAMESPACE}:${TASK_ID}:aggregated-feedback"
-        echo "$FEEDBACK_JSON" | redis-cli -x SET "$FEEDBACK_KEY" >/dev/null
-        redis-cli EXPIRE "$FEEDBACK_KEY" 3600 >/dev/null
-    fi
-
-    # Output consensus to stdout (for script callers)
-    echo "$CONSENSUS"
-else
-    echo "" >&2
-    echo "[Coordinator] ❌ No confidence scores collected" >&2
-    exit 1
-fi

package/.claude/skills/cfn-memory-persistence/lib/redis/collect-results.sh.backup

@@ -1,75 +0,0 @@
-#!/bin/bash
-
-# Redis Results Collection Primitive
-# Updated interface to match orchestrator expectations
-# Supports both legacy (--key) and new (--task-id --agent-ids --namespace) interfaces
-
-# Initialize variables
-task_id=""
-agent_ids=""
-key=""
-namespace="swarm"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            task_id="$2"
-            shift 2
-            ;;
-        --agent-ids)
-            agent_ids="$2"
-            shift 2
-            ;;
-        --key)
-            key="$2"
-            shift 2
-            ;;
-        --namespace)
-            namespace="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Construct Redis key based on interface mode
-if [[ -n "$task_id" && -n "$agent_ids" ]]; then
-    # New interface: collect from multiple agents
-    # Format: {namespace}:{task_id}:results
-    redis_key="${namespace}:${task_id}:results"
-
-    # Collect results from each agent
-    IFS=',' read -ra AGENTS <<< "$agent_ids"
-    results=""
-    for agent in "${AGENTS[@]}"; do
-        agent_key="${namespace}:${task_id}:${agent}:result"
-        agent_result=$(redis-cli get "$agent_key" 2>/dev/null)
-        if [[ -n "$agent_result" && "$agent_result" != "(nil)" ]]; then
-            results="${results}${agent}:${agent_result}"$'\n'
-        fi
-    done
-
-    # Print collected results
-    echo -n "$results"
-elif [[ -n "$key" ]]; then
-    # Legacy interface: key is used directly (list-based)
-    redis_key="$key"
-
-    # Collect results from Redis list
-    results=$(redis-cli lrange "$redis_key" 0 -1 2>/dev/null)
-
-    # Print the results
-    echo "$results"
-else
-    echo "Error: Either (--task-id and --agent-ids) or --key is required" >&2
-    echo "Usage: $0 --task-id <id> --agent-ids <comma-separated-ids> [--namespace <ns>]" >&2
-    echo "   or: $0 --key <full-key>" >&2
-    exit 1
-fi
-
-# Exit successfully
-exit 0

package/.claude/skills/cfn-memory-persistence/lib/redis/complete-swarm.sh.backup

@@ -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 -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" 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 -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" 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 -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
-  echo "[Swarm] Stored metric: $KEY = $VALUE"
-done
-
-echo "[Swarm] ✅ Completion recorded"

package/.claude/skills/cfn-memory-persistence/lib/redis/get-context.sh.backup

@@ -1,146 +0,0 @@
-#!/bin/bash
-# Retrieve CFN Loop task context from Redis
-# Used by CLI-spawned agents to get structured context from orchestrator
-#
-# Usage:
-#   get-context.sh --task-id <id> [--namespace <ns>]
-#   get-context.sh --task-id <id> --key <key> [--namespace <ns>]
-#   get-context.sh <task_id> (legacy mode)
-
-set -euo pipefail
-
-# Source centralized Redis functions with defensive fallback
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REDIS_FUNCTIONS="${SCRIPT_DIR}/redis-functions.sh"
-
-# Check if redis-functions.sh exists and is readable
-if [ ! -r "$REDIS_FUNCTIONS" ]; then
-    echo "⚠️  WARNING: Cannot read redis-functions.sh at: $REDIS_FUNCTIONS" >&2
-    echo "   Operating in Task mode-only (no Redis coordination)" >&2
-    # Define minimal fallback stubs for Task mode
-    redis-cli() {
-        echo "⚠️  Redis unavailable in Task mode - no-op" >&2
-        return 0
-    }
-    export -f redis-cli
-else
-    # Attempt to source with controlled error handling
-    set +e  # Temporarily disable errexit
-    source "$REDIS_FUNCTIONS" 2>/dev/null
-    SOURCE_STATUS=$?
-    set -e  # Re-enable errexit
-
-    if [ $SOURCE_STATUS -ne 0 ]; then
-        echo "⚠️  WARNING: Failed to source redis-functions.sh (exit code: $SOURCE_STATUS)" >&2
-        echo "   Operating in Task mode-only (no Redis coordination)" >&2
-        # Define minimal fallback stubs
-        redis-cli() {
-            echo "⚠️  Redis unavailable - no-op" >&2
-            return 0
-        }
-        export -f redis-cli
-    fi
-fi
-
-# Initialize variables
-TASK_ID=""
-KEY=""
-NAMESPACE="swarm"
-FORMAT="json"  # json or raw
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --key)
-      KEY="$2"
-      shift 2
-      ;;
-    --namespace)
-      NAMESPACE="$2"
-      shift 2
-      ;;
-    --format)
-      FORMAT="$2"
-      shift 2
-      ;;
-    *)
-      # Legacy mode: positional argument
-      if [ -z "$TASK_ID" ]; then
-        TASK_ID="$1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [ -z "$TASK_ID" ]; then
-    echo "Error: --task-id or TASK_ID required" >&2
-    echo "Usage: $0 --task-id <id> [--key <key>] [--namespace <ns>] [--format <json|raw>]" >&2
-    echo "   or: $0 <task_id> (legacy)" >&2
-    exit 1
-fi
-
-REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
-
-# Check if context exists
-if ! redis-cli EXISTS "$REDIS_KEY" >/dev/null 2>&1; then
-    echo "⚠️  No context found for task: $TASK_ID" >&2
-    exit 1
-fi
-
-# Handle specific key retrieval
-if [ -n "$KEY" ]; then
-  VALUE=$(redis-cli HGET "$REDIS_KEY" "$KEY" 2>/dev/null || echo "")
-  if [ -z "$VALUE" ]; then
-    echo "⚠️  Key '$KEY' not found in context for task: $TASK_ID" >&2
-    exit 1
-  fi
-
-  if [ "$FORMAT" = "raw" ]; then
-    echo "$VALUE"
-  else
-    echo "{\"$KEY\":$VALUE}"
-  fi
-  exit 0
-fi
-
-# Handle full context retrieval
-ALL_FIELDS=$(redis-cli HGETALL "$REDIS_KEY" 2>/dev/null || echo "")
-
-if [ -z "$ALL_FIELDS" ]; then
-    echo "⚠️  Empty context for task: $TASK_ID" >&2
-    exit 1
-fi
-
-# Format as JSON
-if [ "$FORMAT" = "json" ]; then
-  echo "{"
-  first=true
-  while IFS= read -r field; do
-    if [ -z "$field" ]; then continue; fi
-    if [ "$first" = true ]; then
-      first=false
-    else
-      echo ","
-    fi
-    # Skip empty lines and properly format JSON values
-    if [[ $field =~ ^[0-9]+$ ]]; then
-      # Numeric value
-      echo -n "  \"$field\": $(redis-cli HGET "$REDIS_KEY" "$field")"
-    else
-      # String value
-      value=$(redis-cli HGET "$REDIS_KEY" "$field" | sed 's/"/\\"/g')
-      echo -n "  \"$field\": \"$value\""
-    fi
-  done <<< "$ALL_FIELDS"
-  echo ""
-  echo "}"
-else
-  # Raw format
-  redis-cli HGETALL "$REDIS_KEY"
-fi

package/.claude/skills/cfn-memory-persistence/lib/redis/get-success-criteria.sh.backup

@@ -1,54 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Retrieve success criteria from Redis
-# Usage: get-success-criteria.sh --task-id TASK_ID
-# Output: JSON string (stdout) or error message (stderr)
-
-TASK_ID=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        *)
-            echo "❌ Unknown option: $1" >&2
-            echo "Usage: get-success-criteria.sh --task-id TASK_ID" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Validate input
-if [[ -z "$TASK_ID" ]]; then
-    echo "❌ --task-id required" >&2
-    exit 1
-fi
-
-# SECURITY FIX: Validate TASK_ID format (prevent Redis key injection)
-if ! [[ "$TASK_ID" =~ ^[a-zA-Z0-9_-]+$ ]]; then
-    echo "❌ Invalid TASK_ID format: $TASK_ID (must be alphanumeric, dash, underscore only)" >&2
-    exit 1
-fi
-
-# Retrieve from Redis
-REDIS_KEY="swarm:${TASK_ID}:config:success_criteria"
-CRITERIA=$(redis-cli GET "$REDIS_KEY" 2>/dev/null || echo "")
-
-# Check if criteria exists
-if [[ -z "$CRITERIA" ]] || [[ "$CRITERIA" == "null" ]]; then
-    echo "⚠️  No success criteria found for task $TASK_ID" >&2
-    exit 1
-fi
-
-# Validate JSON before output
-if ! echo "$CRITERIA" | jq empty 2>/dev/null; then
-    echo "❌ Invalid JSON in stored criteria" >&2
-    exit 1
-fi
-
-# Output to stdout (clean output for piping)
-echo "$CRITERIA"