claude-flow-novice 2.9.1 → 2.10.1

package/.claude/skills/cfn-redis-coordination/demos/test-utils.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# Utility functions for quorum testing
+
+# Check absolute quorum
+check_quorum() {
+    local total_agents="$1"
+    local quorum="$2"
+    local completed_agents="$3"
+
+    if [ "$completed_agents" -ge "$quorum" ]; then
+        echo "SUCCESS"
+    else
+        echo "FAILURE"
+    fi
+}
+
+# Check percentage-based quorum
+check_percentage_quorum() {
+    local total_agents="$1"
+    local quorum_percentage="$2"
+    local completed_agents="$3"
+
+    # Calculate the minimum number of agents required (round up)
+    local required_agents=$(echo "scale=0; ceil($total_agents * $quorum_percentage)" | bc)
+
+    if [ "$completed_agents" -ge "$required_agents" ]; then
+        echo "SUCCESS"
+    else
+        echo "FAILURE"
+    fi
+}
+
+# Graceful degradation strategy
+simulate_graceful_degradation() {
+    local total_agents="$1"
+    local initial_quorum="$2"
+    local max_failures="$3"
+
+    # Dynamically adjust quorum based on failures
+    local current_quorum="$initial_quorum"
+    local adjusted_agents=$((total_agents - max_failures))
+    local adjusted_quorum_threshold=$(echo "scale=2; $current_quorum * 0.8" | bc)
+
+    if (( $(echo "$adjusted_quorum_threshold <= 0.65" | bc -l) )); then
+        echo "HALT"  # Prevent degradation below minimum viable quorum
+    else
+        echo "$(check_percentage_quorum "$adjusted_agents" "$adjusted_quorum_threshold" "$adjusted_agents")"
+    fi
+}
+
+# Assertion functions
+assert_equals() {
+    local actual="$1"
+    local expected="$2"
+    local message="${3:-Assertion failed}"
+
+    if [ "$actual" != "$expected" ]; then
+        echo "FAIL: $message (Expected: $expected, Got: $actual)"
+        exit 1
+    fi
+}
+
+assert_greater_than() {
+    local actual="$1"
+    local expected="$2"
+    local message="${3:-Assertion failed}"
+
+    if [ "$actual" -le "$expected" ]; then
+        echo "FAIL: $message (Expected > $expected, Got: $actual)"
+        exit 1
+    fi
+}
+
+assert_not_empty() {
+    local value="$1"
+    local message="${2:-Value is empty}"
+
+    if [ -z "$value" ]; then
+        echo "FAIL: $message"
+        exit 1
+    fi
+}
+
+# Error handling and logging
+log_error() {
+    local message="$1"
+    echo "[ERROR] $message" >&2
+}
+
+# Cleanup function
+cleanup() {
+    # Remove any temporary files or reset test environments
+    echo "Cleaning up test environment..."
+}
+
+# Trap to ensure cleanup happens even if script fails
+trap cleanup EXIT

package/.claude/skills/cfn-redis-coordination/demos/test-waiting-mode.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Test script for Redis Coordination Waiting Mode (v1.3.0)
+
+# Utility functions
+log_success() {
+  echo -e "\033[32m[PASS]\033[0m $1"
+}
+
+log_failure() {
+  echo -e "\033[31m[FAIL]\033[0m $1"
+  exit 1
+}
+
+# Setup test variables
+TASK_ID="test-task-$(date +%s)"
+AGENT_IDS=("agent1" "agent2" "agent3")
+
+# Ensure clean test environment
+./invoke-redis-pattern.sh
+
+# Test 1: Enter Waiting Mode
+echo "### Test 1: Enter Waiting Mode ###"
+wait_result=$(./invoke-redis-pattern.sh wait --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --context "test-context")
+echo "$wait_result" | jq -e '.status == "timeout"' > /dev/null || log_failure "Failed to enter waiting mode"
+log_success "Entered waiting mode successfully"
+
+# Test 2: Wake Agent
+echo -e "\n### Test 2: Wake Agent ###"
+payload='{"iteration": 2, "feedback": "Add error handling"}'
+wake_result=$(./invoke-redis-pattern.sh wake --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --payload "$payload")
+echo "$wake_result" | jq -e '.status == "success"' > /dev/null || log_failure "Failed to wake agent"
+log_success "Woke agent successfully"
+
+# Test 3: Report Result
+echo -e "\n### Test 3: Report Result ###"
+report_result=$(./invoke-redis-pattern.sh report --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --confidence 0.92 --result '{"key": "value"}')
+echo "$report_result" | jq -e '.status == "success" and .confidence == 0.92' > /dev/null || log_failure "Failed to report result"
+log_success "Reported result successfully"
+
+# Test 4: Collect Consensus
+echo -e "\n### Test 4: Collect Consensus ###"
+for agent in "${AGENT_IDS[@]}"; do
+  ./invoke-redis-pattern.sh report --task-id "$TASK_ID" --agent-id "$agent" --confidence 0.95 --result "{\"result\": \"test-$agent\"}"
+done
+
+collect_result=$(./invoke-redis-pattern.sh collect --task-id "$TASK_ID" --agent-ids "$(IFS=,; echo "${AGENT_IDS[*]}")")
+echo "$collect_result" | jq -e '.status == "consensus" and .avgConfidence >= 0.90' > /dev/null || log_failure "Failed to collect consensus"
+log_success "Collected consensus successfully"
+
+# Test 5: Timeout Handling
+echo -e "\n### Test 5: Timeout Handling ###"
+timeout_task_id="timeout-test-$(date +%s)"
+timeout_result=$(./invoke-redis-pattern.sh wait --task-id "$timeout_task_id" --agent-id "${AGENT_IDS[0]}" --context "timeout-test")
+echo "$timeout_result" | jq -e '.status == "timeout"' > /dev/null || log_failure "Failed to handle timeout"
+log_success "Timeout handled successfully"
+
+echo -e "\n\033[32m✅ ALL REDIS COORDINATION TESTS PASSED!\033[0m"

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

@@ -0,0 +1,73 @@
+# 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

package/.claude/skills/cfn-redis-coordination/examples/grafana-dashboard.json

@@ -0,0 +1,352 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": null,
+  "links": [],
+  "panels": [
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "prometheus",
+      "description": "Duration of each CFN Loop iteration over time",
+      "fill": 1,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "cfn_loop_iteration_duration_seconds",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "Iteration {{iteration}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Iteration Duration Trends",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "s",
+          "label": "Duration",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "cacheTimeout": null,
+      "datasource": "prometheus",
+      "description": "Consensus and confidence across CFN Loop iterations",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "red",
+                "value": null
+              },
+              {
+                "color": "yellow",
+                "value": 0.75
+              },
+              {
+                "color": "green",
+                "value": 0.90
+              }
+            ]
+          },
+          "unit": "percentunit"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 2,
+      "links": [],
+      "options": {
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": [
+            "mean"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "showThresholdLabels": false,
+        "showThresholdMarkers": true
+      },
+      "pluginVersion": "7.3.7",
+      "targets": [
+        {
+          "expr": "cfn_loop_confidence{stage=\"loop3\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "Loop 3 Confidence",
+          "refId": "A"
+        },
+        {
+          "expr": "cfn_loop_consensus{stage=\"loop2\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "Loop 2 Consensus",
+          "refId": "B"
+        }
+      ],
+      "timeFrom": null,
+      "title": "Consensus Convergence",
+      "type": "gauge"
+    },
+    {
+      "cards": {
+        "cardPadding": null,
+        "cardRound": null
+      },
+      "color": {
+        "cardColor": "#FADE2A",
+        "colorScale": "linear",
+        "colorScheme": "interpolateOranges",
+        "exponent": 0.5,
+        "mode": "opacity"
+      },
+      "datasource": "prometheus",
+      "description": "Agent latency heatmap to identify performance bottlenecks",
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "heatmap": {},
+      "hideZeroBuckets": false,
+      "highlightCards": true,
+      "id": 3,
+      "legend": {
+        "show": false
+      },
+      "links": [],
+      "targets": [
+        {
+          "expr": "sum(rate(cfn_loop_agent_latency_seconds_bucket[5m])) by (agent_id)",
+          "format": "heatmap",
+          "intervalFactor": 2,
+          "legendFormat": "{{agent_id}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Agent Latency Heatmap",
+      "tooltip": {
+        "show": true,
+        "showPalette": false
+      },
+      "type": "heatmap",
+      "xAxis": {
+        "show": true
+      },
+      "yAxis": {
+        "decimals": 0,
+        "show": true,
+        "title": "Agent"
+      },
+      "yBucketBound": "auto"
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "prometheus",
+      "description": "Error and fallback metrics for CFN Loop iterations",
+      "fill": 1,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 4,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": false,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(increase(cfn_loop_errors_total[1h])) by (error_type)",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{error_type}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Error Rates",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": "Error Count",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "schemaVersion": 22,
+  "style": "dark",
+  "tags": [
+    "cfn-loop",
+    "redis-coordination",
+    "performance"
+  ],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ]
+  },
+  "timezone": "",
+  "title": "CFN Loop Metrics",
+  "uid": "cfn_loop_metrics",
+  "version": 1
+}

package/.claude/skills/cfn-redis-coordination/examples/hierarchical-pattern.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# Hierarchical Pattern: 1:Many Broadcast Coordination
+# Use Case: One agent's output feeds multiple downstream agents
+# Pattern: Coordinator receives result and broadcasts to multiple agent inboxes
+
+set -e
+
+TASK_ID="demo:hierarchical"
+TIMEOUT=300  # 5 minutes
+
+echo "=== Hierarchical Pattern Demo (1:Many Broadcast) ==="
+echo "Scenario: Researcher → [Analyzer, Architect, Coder]"
+echo ""
+
+# Cleanup previous demo data
+echo "Cleaning up previous demo data..."
+redis-cli del "${TASK_ID}:researcher:done" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:analyzer:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:architect:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:coder:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true
+
+# Simulate Researcher Agent (runs in background)
+(
+  echo "[Researcher] Starting research..."
+  sleep 2
+
+  FINDINGS='{
+    "agent": "researcher",
+    "confidence": 0.85,
+    "findings": "JWT-based authentication recommended",
+    "patterns": ["OAuth2", "JWT", "Session-based"],
+    "recommendation": "Use JWT with refresh tokens"
+  }'
+
+  redis-cli lpush "${TASK_ID}:researcher:done" "$FINDINGS" > /dev/null
+  echo "[Researcher] Research complete, published to ${TASK_ID}:researcher:done"
+) &
+
+# Coordinator: Wait for researcher, then broadcast to multiple agents
+echo "[Coordinator] Waiting for researcher to complete..."
+RESEARCH_DATA=$(timeout $TIMEOUT redis-cli --csv blpop "${TASK_ID}:researcher:done" 0 2>/dev/null || echo "")
+
+if [ -z "$RESEARCH_DATA" ]; then
+  echo "[Coordinator] ERROR: Researcher timeout after ${TIMEOUT}s"
+  redis-cli lpush "${TASK_ID}:coordinator:status" '{"status":"error","error":"researcher_timeout"}' > /dev/null
+  exit 1
+fi
+
+echo "[Coordinator] Received research data, broadcasting to 3 agents..."
+
+# Broadcast to multiple agents (separate inboxes)
+redis-cli lpush "${TASK_ID}:analyzer:inbox" "$RESEARCH_DATA" > /dev/null
+redis-cli lpush "${TASK_ID}:architect:inbox" "$RESEARCH_DATA" > /dev/null
+redis-cli lpush "${TASK_ID}:coder:inbox" "$RESEARCH_DATA" > /dev/null
+
+echo "[Coordinator] Broadcast complete to: analyzer, architect, coder"
+
+# Simulate Analyzer Agent
+(
+  echo "[Analyzer] Waiting for research data in inbox..."
+  DATA=$(timeout $TIMEOUT redis-cli --csv blpop "${TASK_ID}:analyzer:inbox" 0 2>/dev/null || echo "")
+
+  if [ -z "$DATA" ]; then
+    echo "[Analyzer] ERROR: Timeout waiting for data"
+    exit 1
+  fi
+
+  echo "[Analyzer] Received data: ${DATA:0:50}..."
+  echo "[Analyzer] Analyzing security implications..."
+  sleep 1
+  echo "[Analyzer] Analysis complete (confidence: 0.90)"
+) &
+
+# Simulate Architect Agent
+(
+  echo "[Architect] Waiting for research data in inbox..."
+  DATA=$(timeout $TIMEOUT redis-cli --csv blpop "${TASK_ID}:architect:inbox" 0 2>/dev/null || echo "")
+
+  if [ -z "$DATA" ]; then
+    echo "[Architect] ERROR: Timeout waiting for data"
+    exit 1
+  fi
+
+  echo "[Architect] Received data: ${DATA:0:50}..."
+  echo "[Architect] Designing authentication architecture..."
+  sleep 1
+  echo "[Architect] Architecture designed (confidence: 0.88)"
+) &
+
+# Simulate Coder Agent
+(
+  echo "[Coder] Waiting for research data in inbox..."
+  DATA=$(timeout $TIMEOUT redis-cli --csv blpop "${TASK_ID}:coder:inbox" 0 2>/dev/null || echo "")
+
+  if [ -z "$DATA" ]; then
+    echo "[Coder] ERROR: Timeout waiting for data"
+    exit 1
+  fi
+
+  echo "[Coder] Received data: ${DATA:0:50}..."
+  echo "[Coder] Implementing JWT authentication..."
+  sleep 1
+  echo "[Coder] Implementation complete (confidence: 0.86)"
+) &
+
+# Wait for all background jobs to complete
+wait
+
+echo ""
+echo "=== Hierarchical Pattern Complete ==="
+echo "✅ Coordinator successfully broadcast researcher data to 3 agents"
+echo "✅ All agents received data in parallel from dedicated inboxes"
+echo "✅ No message loss (BLPOP destructive limitation solved)"
+echo ""
+echo "Key Pattern:"
+echo "  1. Researcher → coordinator (LPUSH/BLPOP)"
+echo "  2. Coordinator → 3 separate agent inboxes (LPUSH x3)"
+echo "  3. Each agent reads from dedicated inbox (BLPOP)"
+echo ""
+
+# Cleanup
+redis-cli del "${TASK_ID}:researcher:done" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:analyzer:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:architect:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:coder:inbox" > /dev/null 2>&1 || true
+redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true