claude-flow-novice 2.14.3 → 2.14.5

package/.claude/skills/cfn-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/cfn-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

package/.claude/skills/cfn-redis-coordination/examples/timeout-handling.sh

@@ -1,227 +0,0 @@
-#!/bin/bash
-# Timeout Handling: Comprehensive timeout patterns for Redis coordination
-# Demonstrates proper timeout handling, error reporting, and recovery strategies
-
-set -e
-
-TASK_ID="demo:timeout"
-SHORT_TIMEOUT=5    # 5 seconds (for demo of timeout failure)
-NORMAL_TIMEOUT=300 # 5 minutes (production default)
-
-echo "=== Timeout Handling Demo ==="
-echo ""
-
-# Cleanup previous demo data
-echo "Cleaning up previous demo data..."
-redis-cli del "${TASK_ID}:slow-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:fast-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:error" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true
-
-echo "--- Scenario 1: Timeout Failure (Agent Too Slow) ---"
-echo ""
-
-# Simulate slow agent that exceeds timeout (runs in background)
-(
-  echo "[Slow Agent] Starting work..."
-  sleep 10  # Takes 10s but timeout is 5s
-
-  RESULT='{"agent":"slow-agent","confidence":0.85,"status":"complete"}'
-  redis-cli lpush "${TASK_ID}:slow-agent:done" "$RESULT" > /dev/null
-  echo "[Slow Agent] Work complete (but too late...)"
-) &
-
-SLOW_AGENT_PID=$!
-
-# Coordinator waits with short timeout
-echo "[Coordinator] Waiting for slow-agent with ${SHORT_TIMEOUT}s timeout..."
-RESULT=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:slow-agent:done" 0 2>/dev/null || echo "")
-EXIT_CODE=$?
-
-if [ $EXIT_CODE -eq 124 ]; then
-  echo "[Coordinator] ❌ ERROR: Slow agent timeout after ${SHORT_TIMEOUT}s"
-
-  # Report error to coordinator error channel
-  ERROR_REPORT='{
-    "agent": "slow-agent",
-    "error": "timeout",
-    "timeout": '${SHORT_TIMEOUT}',
-    "timestamp": "'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'"
-  }'
-
-  redis-cli lpush "${TASK_ID}:coordinator:error" "$ERROR_REPORT" > /dev/null
-  echo "[Coordinator] Error reported to ${TASK_ID}:coordinator:error"
-
-  # Kill slow agent background process
-  kill $SLOW_AGENT_PID 2>/dev/null || true
-
-  echo "[Coordinator] Decision: Terminate slow agent and retry with different agent"
-else
-  echo "[Coordinator] ✓ Slow agent completed within timeout"
-fi
-
-echo ""
-echo "--- Scenario 2: Timeout Success (Agent Fast Enough) ---"
-echo ""
-
-# Simulate fast agent that completes within timeout (runs in background)
-(
-  echo "[Fast Agent] Starting work..."
-  sleep 2  # Takes 2s, well within 5s timeout
-
-  RESULT='{"agent":"fast-agent","confidence":0.90,"status":"complete"}'
-  redis-cli lpush "${TASK_ID}:fast-agent:done" "$RESULT" > /dev/null
-  echo "[Fast Agent] Work complete"
-) &
-
-# Coordinator waits with short timeout
-echo "[Coordinator] Waiting for fast-agent with ${SHORT_TIMEOUT}s timeout..."
-RESULT=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:fast-agent:done" 0 2>/dev/null || echo "")
-EXIT_CODE=$?
-
-if [ $EXIT_CODE -eq 124 ]; then
-  echo "[Coordinator] ❌ ERROR: Fast agent timeout after ${SHORT_TIMEOUT}s"
-else
-  echo "[Coordinator] ✓ Fast agent completed within timeout"
-  echo "[Coordinator] Result: ${RESULT:0:80}..."
-fi
-
-wait
-
-echo ""
-echo "--- Scenario 3: Multi-Agent Timeout with Recovery ---"
-echo ""
-
-# Cleanup
-redis-cli del "${TASK_ID}:agent-1:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-2:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-3:done" > /dev/null 2>&1 || true
-
-# Simulate 3 agents with varying completion times
-(
-  sleep 1
-  redis-cli lpush "${TASK_ID}:agent-1:done" '{"agent":"agent-1","confidence":0.85}' > /dev/null
-  echo "[Agent 1] Complete (1s)"
-) &
-
-(
-  sleep 2
-  redis-cli lpush "${TASK_ID}:agent-2:done" '{"agent":"agent-2","confidence":0.90}' > /dev/null
-  echo "[Agent 2] Complete (2s)"
-) &
-
-(
-  sleep 15  # Too slow - exceeds 5s timeout
-  redis-cli lpush "${TASK_ID}:agent-3:done" '{"agent":"agent-3","confidence":0.88}' > /dev/null
-  echo "[Agent 3] Complete (15s - too late)"
-) &
-
-AGENT_3_PID=$!
-
-echo "[Coordinator] Waiting for 3 agents with ${SHORT_TIMEOUT}s timeout each..."
-
-# Wait for agent 1
-RESULT_1=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-1:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_1" ]; then
-  echo "[Coordinator] ❌ Agent 1 timeout"
-  AGENT_1_FAILED=1
-else
-  echo "[Coordinator] ✓ Agent 1 complete"
-  AGENT_1_FAILED=0
-fi
-
-# Wait for agent 2
-RESULT_2=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-2:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_2" ]; then
-  echo "[Coordinator] ❌ Agent 2 timeout"
-  AGENT_2_FAILED=1
-else
-  echo "[Coordinator] ✓ Agent 2 complete"
-  AGENT_2_FAILED=0
-fi
-
-# Wait for agent 3
-RESULT_3=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-3:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_3" ]; then
-  echo "[Coordinator] ❌ Agent 3 timeout"
-  AGENT_3_FAILED=1
-
-  # Kill agent 3 background process
-  kill $AGENT_3_PID 2>/dev/null || true
-else
-  echo "[Coordinator] ✓ Agent 3 complete"
-  AGENT_3_FAILED=0
-fi
-
-# Calculate success rate
-FAILED_COUNT=$((AGENT_1_FAILED + AGENT_2_FAILED + AGENT_3_FAILED))
-SUCCESS_COUNT=$((3 - FAILED_COUNT))
-
-echo ""
-echo "[Coordinator] Results: $SUCCESS_COUNT/3 agents completed within timeout"
-
-if [ $SUCCESS_COUNT -ge 2 ]; then
-  echo "[Coordinator] Decision: PROCEED with partial results (2/3 quorum met)"
-
-  STATUS='{"status":"partial_success","completed":'$SUCCESS_COUNT',"failed":'$FAILED_COUNT',"decision":"proceed"}'
-  redis-cli set "${TASK_ID}:coordinator:status" "$STATUS" > /dev/null
-else
-  echo "[Coordinator] Decision: RETRY all agents (quorum not met)"
-
-  STATUS='{"status":"insufficient_quorum","completed":'$SUCCESS_COUNT',"failed":'$FAILED_COUNT',"decision":"retry"}'
-  redis-cli set "${TASK_ID}:coordinator:status" "$STATUS" > /dev/null
-fi
-
-wait
-
-echo ""
-echo "--- Scenario 4: Timeout Best Practices ---"
-echo ""
-
-echo "✓ Timeout Guidelines:"
-echo "  - Normal operations: 300s (5 minutes)"
-echo "  - Research tasks: 600s (10 minutes)"
-echo "  - Complex builds: 900s (15 minutes)"
-echo "  - Testing: 600s (10 minutes)"
-echo ""
-
-echo "✓ Timeout Handling Pattern:"
-echo '  result=$(timeout 300 redis-cli --csv blpop "channel" 0 2>/dev/null || echo "")'
-echo '  if [ $? -eq 124 ]; then'
-echo '    echo "TIMEOUT"'
-echo '    redis-cli lpush "coordinator:error" '"'"'{"error":"timeout"}'"'"
-echo '  fi'
-echo ""
-
-echo "✓ Error Reporting:"
-echo "  - Always report timeout to coordinator:error channel"
-echo "  - Include agent ID, timeout duration, timestamp"
-echo "  - Coordinator decides: retry, skip, or escalate"
-echo ""
-
-echo "✓ Recovery Strategies:"
-echo "  - Single agent timeout: Retry once with extended timeout"
-echo "  - Multiple agent timeout: Check quorum (2/3 pass = proceed)"
-echo "  - Critical agent timeout: Escalate to main chat"
-echo "  - Repeated timeouts: Switch to different agent type"
-echo ""
-
-echo "=== Timeout Handling Demo Complete ==="
-echo ""
-echo "Key Takeaways:"
-echo "  1. ALWAYS use timeout command with BLPOP"
-echo "  2. Check exit code 124 for timeout detection"
-echo "  3. Report timeouts to coordinator:error channel"
-echo "  4. Implement recovery strategies (retry/skip/escalate)"
-echo "  5. Use appropriate timeout values for task type"
-echo "  6. Kill/cleanup timed-out background processes"
-echo ""
-
-# Cleanup
-redis-cli del "${TASK_ID}:slow-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:fast-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-1:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-2:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-3:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:error" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true