claude-flow-novice 2.8.1 → 2.9.1

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

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

package/.claude/skills/redis-coordination/examples/waiting-mode-pattern.sh

@@ -1,239 +0,0 @@
-#!/bin/bash
-# Waiting Mode + Coordinator Wake-Up Pattern
-# Agents enter waiting mode, coordinator/peers wake them for iterations/fixes
-
-set -euo pipefail
-
-# Configuration
-TASK_ID="auth-system"
-ITERATION=1
-MAX_ITERATIONS=10
-CONSENSUS_THRESHOLD=0.90
-
-echo "========================================="
-echo "Waiting Mode + Coordinator Wake-Up Demo"
-echo "========================================="
-echo ""
-
-# Simulate coordinator spawning agents in waiting mode
-echo "Step 1: Coordinator spawns agents in waiting mode"
-echo "  Task: agent-coder, agent-reviewer, agent-tester, agent-security"
-echo ""
-
-# Agent Pattern: Enter waiting mode immediately after spawn
-agent_enter_waiting_mode() {
-    local agent_id=$1
-    local context=$2
-
-    echo "[$agent_id] Entering waiting mode..."
-    redis-cli lpush "swarm:$TASK_ID:$agent_id:ready" "{
-        \"status\": \"waiting\",
-        \"context\": \"$context\",
-        \"timestamp\": $(date +%s)
-    }" > /dev/null
-
-    echo "[$agent_id] Blocked on swarm:$TASK_ID:$agent_id:wake (infinite timeout)"
-    echo "[$agent_id] Zero token cost while waiting..."
-}
-
-# Simulate 4 agents entering waiting mode
-agent_enter_waiting_mode "agent-coder" "iteration-1"
-agent_enter_waiting_mode "agent-reviewer" "iteration-1"
-agent_enter_waiting_mode "agent-tester" "iteration-1"
-agent_enter_waiting_mode "agent-security" "iteration-1"
-
-echo ""
-echo "========================================="
-echo "CFN Loop Iteration 1: Wake agents"
-echo "========================================="
-echo ""
-
-# Coordinator wakes agents for first iteration
-wake_agent() {
-    local agent_id=$1
-    local iteration=$2
-    local task=$3
-
-    echo "[Coordinator] Waking $agent_id for iteration $iteration..."
-    redis-cli lpush "swarm:$TASK_ID:$agent_id:wake" "{
-        \"reason\": \"cfn_loop_iteration\",
-        \"iteration\": $iteration,
-        \"task\": \"$task\",
-        \"timestamp\": $(date +%s)
-    }" > /dev/null
-
-    echo "[Coordinator] Wake signal sent to $agent_id"
-}
-
-# Wake all agents for iteration 1
-wake_agent "agent-coder" $ITERATION "Implement authentication logic"
-wake_agent "agent-reviewer" $ITERATION "Review code quality"
-wake_agent "agent-tester" $ITERATION "Write and run tests"
-wake_agent "agent-security" $ITERATION "Security audit"
-
-echo ""
-echo "Agents process tasks..."
-sleep 2
-
-# Simulate agents reporting back
-echo ""
-echo "Agents report confidence and return to waiting mode:"
-redis-cli lpush "swarm:$TASK_ID:agent-coder:result" '{"confidence":0.75,"iteration":1,"status":"needs_improvement"}' > /dev/null
-echo "  [agent-coder] Confidence: 0.75 (needs improvement)"
-
-redis-cli lpush "swarm:$TASK_ID:agent-reviewer:result" '{"confidence":0.80,"iteration":1,"issues":["Missing error handling"]}' > /dev/null
-echo "  [agent-reviewer] Confidence: 0.80 (issues found)"
-
-redis-cli lpush "swarm:$TASK_ID:agent-tester:result" '{"confidence":0.72,"iteration":1,"coverage":0.65}' > /dev/null
-echo "  [agent-tester] Confidence: 0.72 (low coverage)"
-
-redis-cli lpush "swarm:$TASK_ID:agent-security:result" '{"confidence":0.85,"iteration":1}' > /dev/null
-echo "  [agent-security] Confidence: 0.85"
-
-# Calculate consensus
-echo ""
-echo "[Coordinator] Calculating consensus..."
-CONSENSUS=$(echo "scale=2; (0.75 + 0.80 + 0.72 + 0.85) / 4" | bc)
-echo "[Coordinator] Iteration $ITERATION Consensus: $CONSENSUS"
-echo "[Coordinator] Threshold: $CONSENSUS_THRESHOLD"
-
-if (( $(echo "$CONSENSUS < $CONSENSUS_THRESHOLD" | bc -l) )); then
-    echo "[Coordinator] ⚠️  Consensus below threshold - triggering iteration 2"
-
-    # Agents automatically return to waiting mode
-    echo ""
-    echo "Agents return to waiting mode (context preserved):"
-    agent_enter_waiting_mode "agent-coder" "iteration-2"
-    agent_enter_waiting_mode "agent-reviewer" "iteration-2"
-    agent_enter_waiting_mode "agent-tester" "iteration-2"
-    agent_enter_waiting_mode "agent-security" "iteration-2"
-
-    echo ""
-    echo "========================================="
-    echo "CFN Loop Iteration 2: Wake with feedback"
-    echo "========================================="
-    echo ""
-
-    # Wake agents with feedback from previous iteration
-    echo "[Coordinator] Waking agents with feedback from iteration 1..."
-
-    redis-cli lpush "swarm:$TASK_ID:agent-coder:wake" "{
-        \"reason\": \"cfn_loop_iteration\",
-        \"iteration\": 2,
-        \"previous_consensus\": $CONSENSUS,
-        \"feedback\": [\"Add error handling\", \"Improve test coverage\"],
-        \"context_from_iteration_1\": \"maintained\"
-    }" > /dev/null
-    echo "  [agent-coder] Woke with feedback: Add error handling"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-reviewer:wake" "{
-        \"reason\": \"cfn_loop_iteration\",
-        \"iteration\": 2,
-        \"previous_consensus\": $CONSENSUS,
-        \"feedback\": [\"Validate error handling fixes\"]
-    }" > /dev/null
-    echo "  [agent-reviewer] Woke with feedback: Validate fixes"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-tester:wake" "{
-        \"reason\": \"cfn_loop_iteration\",
-        \"iteration\": 2,
-        \"previous_consensus\": $CONSENSUS,
-        \"feedback\": [\"Increase coverage to 85%\"]
-    }" > /dev/null
-    echo "  [agent-tester] Woke with feedback: Increase coverage"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-security:wake" "{
-        \"reason\": \"cfn_loop_iteration\",
-        \"iteration\": 2,
-        \"previous_consensus\": $CONSENSUS
-    }" > /dev/null
-    echo "  [agent-security] Woke for re-validation"
-
-    echo ""
-    echo "Agents process iteration 2 tasks (with context from iteration 1)..."
-    sleep 2
-
-    # Simulate improved results
-    echo ""
-    echo "Agents report improved confidence:"
-    redis-cli lpush "swarm:$TASK_ID:agent-coder:result" '{"confidence":0.90,"iteration":2}' > /dev/null
-    echo "  [agent-coder] Confidence: 0.90 ✅"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-reviewer:result" '{"confidence":0.92,"iteration":2}' > /dev/null
-    echo "  [agent-reviewer] Confidence: 0.92 ✅"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-tester:result" '{"confidence":0.88,"iteration":2,"coverage":0.87}' > /dev/null
-    echo "  [agent-tester] Confidence: 0.88 ✅"
-
-    redis-cli lpush "swarm:$TASK_ID:agent-security:result" '{"confidence":0.94,"iteration":2}' > /dev/null
-    echo "  [agent-security] Confidence: 0.94 ✅"
-
-    CONSENSUS=$(echo "scale=2; (0.90 + 0.92 + 0.88 + 0.94) / 4" | bc)
-    echo ""
-    echo "[Coordinator] Iteration 2 Consensus: $CONSENSUS"
-    echo "[Coordinator] ✅ Consensus >= threshold - PROCEED"
-fi
-
-echo ""
-echo "========================================="
-echo "Example 2: Incomplete Work Wake-Up"
-echo "========================================="
-echo ""
-
-# Simulate incomplete work detection
-echo "[Coordinator] Detected incomplete work in agent-coder..."
-redis-cli lpush "swarm:$TASK_ID:agent-coder:wake" '{
-    "reason": "incomplete_work",
-    "issues": ["Missing test coverage", "Type errors in auth.ts"],
-    "priority": "high"
-}' > /dev/null
-
-echo "[Coordinator] Woke agent-coder to fix issues"
-echo "  Issues: Missing test coverage, Type errors"
-echo ""
-
-echo "========================================="
-echo "Example 3: Agent-to-Agent Clarification"
-echo "========================================="
-echo ""
-
-# Simulate peer-to-peer clarification
-echo "[agent-reviewer] Has question for agent-coder..."
-redis-cli lpush "swarm:$TASK_ID:agent-coder:wake" '{
-    "reason": "clarification",
-    "from_agent": "reviewer",
-    "question": "Should we use JWT or session cookies for auth?",
-    "urgent": false
-}' > /dev/null
-
-echo "[agent-reviewer] Sent clarification question to agent-coder"
-echo "  Question: JWT or session cookies?"
-echo ""
-
-echo "========================================="
-echo "Benefits Summary"
-echo "========================================="
-echo ""
-echo "✅ Zero token cost while agents wait (BLPOP blocks, no API calls)"
-echo "✅ Context preserved across iterations (agents remember previous work)"
-echo "✅ Instant wake-up (<100ms latency)"
-echo "✅ Scalable (10+ agents can cycle indefinitely)"
-echo "✅ CFN Loop native (agents maintain state across consensus cycles)"
-echo ""
-
-# Cleanup
-echo "Cleaning up Redis keys..."
-redis-cli del "swarm:$TASK_ID:agent-coder:ready" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-coder:wake" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-coder:result" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-reviewer:ready" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-reviewer:wake" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-reviewer:result" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-tester:ready" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-tester:wake" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-tester:result" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-security:ready" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-security:wake" > /dev/null
-redis-cli del "swarm:$TASK_ID:agent-security:result" > /dev/null
-
-echo "Demo complete!"