claude-flow-novice 2.6.0 → 2.9.0

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

@@ -1,352 +0,0 @@
-{
-  "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/redis-coordination/examples/hierarchical-pattern.sh

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

package/.claude/skills/redis-coordination/examples/mesh-pattern.sh

@@ -1,171 +0,0 @@
-#!/bin/bash
-# Mesh Pattern: Many:1 Aggregation Coordination
-# Use Case: Multiple agents complete independently, one agent waits for ALL
-# Pattern: Hybrid LPUSH (first waiter) + SET (additional readers)
-
-set -e
-
-TASK_ID="demo:mesh"
-TIMEOUT=300  # 5 minutes
-
-echo "=== Mesh Pattern Demo (Many:1 Aggregation) ==="
-echo "Scenario: [Coder, Tester, Reviewer] → Validator"
-echo ""
-
-# Cleanup previous demo data
-echo "Cleaning up previous demo data..."
-redis-cli del "${TASK_ID}:coder:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coder:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:tester:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:tester:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:reviewer:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:reviewer:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:validator:result" > /dev/null 2>&1 || true
-
-# Simulate Coder Agent (runs in background)
-(
-  echo "[Coder] Implementing authentication feature..."
-  sleep 2
-
-  RESULT='{
-    "agent": "coder",
-    "confidence": 0.86,
-    "filesModified": ["auth.js", "auth.test.js"],
-    "linesAdded": 245,
-    "status": "complete"
-  }'
-
-  # Hybrid pattern: LPUSH for first waiter, SET for additional readers
-  redis-cli lpush "${TASK_ID}:coder:done" "$RESULT" > /dev/null
-  redis-cli set "${TASK_ID}:coder:result" "$RESULT" > /dev/null
-  redis-cli expire "${TASK_ID}:coder:result" 3600 > /dev/null  # 1 hour TTL
-
-  echo "[Coder] Implementation complete, published results"
-) &
-
-# Simulate Tester Agent (runs in background)
-(
-  echo "[Tester] Running test suite..."
-  sleep 3
-
-  RESULT='{
-    "agent": "tester",
-    "confidence": 0.92,
-    "testsRun": 45,
-    "testsPassed": 45,
-    "coverage": 0.94,
-    "status": "complete"
-  }'
-
-  # Hybrid pattern: LPUSH + SET
-  redis-cli lpush "${TASK_ID}:tester:done" "$RESULT" > /dev/null
-  redis-cli set "${TASK_ID}:tester:result" "$RESULT" > /dev/null
-  redis-cli expire "${TASK_ID}:tester:result" 3600 > /dev/null
-
-  echo "[Tester] Tests complete (45/45 passed, 94% coverage)"
-) &
-
-# Simulate Reviewer Agent (runs in background)
-(
-  echo "[Reviewer] Reviewing code quality..."
-  sleep 2.5
-
-  RESULT='{
-    "agent": "reviewer",
-    "confidence": 0.88,
-    "issuesFound": 2,
-    "severity": "low",
-    "recommendations": ["Add input validation", "Improve error messages"],
-    "status": "complete"
-  }'
-
-  # Hybrid pattern: LPUSH + SET
-  redis-cli lpush "${TASK_ID}:reviewer:done" "$RESULT" > /dev/null
-  redis-cli set "${TASK_ID}:reviewer:result" "$RESULT" > /dev/null
-  redis-cli expire "${TASK_ID}:reviewer:result" 3600 > /dev/null
-
-  echo "[Reviewer] Review complete (2 low-severity issues)"
-) &
-
-# Validator: Wait for ALL three agents (first uses BLPOP, rest use GET)
-echo "[Validator] Waiting for coder, tester, and reviewer to complete..."
-
-# First agent: Use BLPOP (blocking wait)
-CODER_DATA=$(timeout $TIMEOUT redis-cli --csv blpop "${TASK_ID}:coder:done" 0 2>/dev/null || echo "")
-if [ -z "$CODER_DATA" ]; then
-  echo "[Validator] ERROR: Coder timeout after ${TIMEOUT}s"
-  exit 1
-fi
-echo "[Validator] ✓ Coder complete"
-
-# Second agent: Use GET (non-blocking, from persistent SET)
-TESTER_DATA=""
-for i in {1..60}; do
-  TESTER_DATA=$(redis-cli get "${TASK_ID}:tester:result" 2>/dev/null || echo "")
-  if [ -n "$TESTER_DATA" ]; then
-    break
-  fi
-  sleep 1
-done
-
-if [ -z "$TESTER_DATA" ]; then
-  echo "[Validator] ERROR: Tester timeout after 60s"
-  exit 1
-fi
-echo "[Validator] ✓ Tester complete"
-
-# Third agent: Use GET (non-blocking, from persistent SET)
-REVIEWER_DATA=""
-for i in {1..60}; do
-  REVIEWER_DATA=$(redis-cli get "${TASK_ID}:reviewer:result" 2>/dev/null || echo "")
-  if [ -n "$REVIEWER_DATA" ]; then
-    break
-  fi
-  sleep 1
-done
-
-if [ -z "$REVIEWER_DATA" ]; then
-  echo "[Validator] ERROR: Reviewer timeout after 60s"
-  exit 1
-fi
-echo "[Validator] ✓ Reviewer complete"
-
-# Wait for all background jobs to complete
-wait
-
-echo ""
-echo "[Validator] All agents complete, aggregating results..."
-
-# Calculate aggregate confidence (simple average)
-echo "[Validator] Aggregate confidence: ~0.89 (coder: 0.86, tester: 0.92, reviewer: 0.88)"
-
-VALIDATION_RESULT='{
-  "agent": "validator",
-  "status": "validated",
-  "aggregateConfidence": 0.89,
-  "summary": "All components validated successfully"
-}'
-
-redis-cli set "${TASK_ID}:validator:result" "$VALIDATION_RESULT" > /dev/null
-redis-cli expire "${TASK_ID}:validator:result" 3600 > /dev/null
-
-echo ""
-echo "=== Mesh Pattern Complete ==="
-echo "✅ Three agents completed independently in parallel"
-echo "✅ Validator successfully aggregated all results"
-echo "✅ Hybrid LPUSH+SET pattern prevented BLPOP message loss"
-echo ""
-echo "Key Pattern:"
-echo "  1. Each agent: LPUSH (for first waiter) + SET (for additional readers)"
-echo "  2. Validator: BLPOP for first agent, GET for remaining agents"
-echo "  3. SET keys have 1-hour expiry for cleanup"
-echo ""
-
-# Cleanup
-redis-cli del "${TASK_ID}:coder:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coder:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:tester:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:tester:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:reviewer:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:reviewer:result" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:validator:result" > /dev/null 2>&1 || true