claude-flow-novice 2.9.1 → 2.10.1

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

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

@@ -0,0 +1,227 @@
+#!/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/cfn-redis-coordination/examples/waiting-mode-pattern.sh

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