claude-flow-novice 2.10.4 → 2.10.6

package/claude-assets/skills/cfn-redis-coordination/collect-confidence-scores.sh

@@ -0,0 +1,179 @@
+#!/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
+
+# 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-assets/skills/cfn-redis-coordination/collect-results.sh

@@ -0,0 +1,75 @@
+#!/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-assets/skills/cfn-redis-coordination/complete-swarm.sh

@@ -0,0 +1,75 @@
+#!/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-assets/skills/cfn-redis-coordination/config.json

@@ -0,0 +1,61 @@
+{
+  "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-assets/skills/cfn-redis-coordination/demos/phase4-wake-queue-test-report.md

@@ -0,0 +1,82 @@
+# Redis Priority Wake-Up Queue Test Report
+## Task ID: redis-phase4-1760896217
+## Date: 2025-10-19
+
+### Test Objective
+Validate the implementation of a priority-based wake-up queue using Redis BZPOPMIN, focusing on:
+1. Priority ordering
+2. FIFO behavior within same priority
+3. Timeout handling
+4. Shutdown grace
+
+### Test Environment
+- Redis Version: 7.0.15
+- Platform: Linux 6.6.87.2-microsoft-standard-WSL2
+- Test Agent: tester-4
+
+### Test Results Summary
+
+| Test                   | Status      | Confidence | Notes                                   |
+|------------------------|-------------|------------|------------------------------------------|
+| Priority Ordering     | ❌ FAILED   | 0.00       | Unable to verify BZPOPMIN order         |
+| FIFO Same Priority    | ❌ FAILED   | 0.00       | Blocking pop did not return expected values |
+| Timeout Handling      | ❌ FAILED   | 0.00       | Timeout duration inconsistent           |
+| Shutdown Handling     | 🟡 SKIPPED  | N/A        | Requires specialized mock                |
+
+### Detailed Findings
+
+#### 1. Priority Ordering
+**Expected:** Highest priority message should be retrieved first
+**Actual:** No messages retrieved from queue
+**Potential Issues:**
+- Redis configuration blocking mechanism
+- Synchronization between ZADD and BZPOPMIN
+- Timestamp or score calculation
+
+#### 2. FIFO Same Priority
+**Expected:** Messages with same priority returned in order of insertion
+**Actual:** No messages retrieved
+**Potential Issues:**
+- Microsecond timestamp precision
+- Redis sorted set behavior
+
+#### 3. Timeout Handling
+**Expected:** Consistent 1-second timeout
+**Actual:** Timeout exceeded 3.4 seconds
+**Potential Issues:**
+- System load
+- Redis blocking mechanism configuration
+- Potential system-level timing discrepancies
+
+### Recommendations
+
+1. **Configuration Validation**
+   - Verify Redis server configuration
+   - Check blocking primitives implementation
+   - Validate network and system timing
+
+2. **Alternative Testing Strategies**
+   - Use non-blocking Redis commands for initial validation
+   - Implement mock Redis server for precise control
+   - Write comprehensive unit tests with controlled environment
+
+3. **Fallback Mechanisms**
+   - Implement retry logic
+   - Add detailed logging
+   - Create graceful degradation path
+
+### Next Steps
+- Conduct low-level Redis configuration review
+- Develop specialized test harness
+- Implement comprehensive mocking framework
+
+### Confidence Level: LOW (0.10)
+
+**Additional Notes:**
+- Requires in-depth investigation
+- May need collaboration with Redis core team
+- Potential platform-specific quirk
+
+---
+
+Logged by: Claude Tester Agent (Claude 3.5 Haiku)