claude-flow-novice 2.5.2 → 2.6.0

package/.claude/skills/redis-coordination/AGENT_LOGGING.md

@@ -0,0 +1,280 @@
+# Agent Logging System
+
+Dual-output logging for CLI-spawned agents: terminal + Redis + portal visibility.
+
+## Features
+
+✅ **Terminal output** - Colored logs for debugging in tmux/terminal
+✅ **File logging** - Persisted to `/tmp/agent-*.log`
+✅ **Redis pub/sub** - Real-time streaming to web portal
+✅ **Redis history** - Last 7 days stored in sorted sets
+✅ **Portal filters** - Filter by repository, agent, or log level
+
+## Quick Start
+
+### 1. Source in Agent Scripts
+
+```bash
+#!/usr/bin/env bash
+source .claude/skills/redis-coordination/agent-log.sh
+
+# Set context
+export AGENT_ID="backend-dev-1"
+export TASK_ID="$1"  # Pass from command line
+
+# Log throughout execution
+agent_log "info" "Starting task execution"
+agent_log "debug" "Loading configuration from $CONFIG_FILE"
+agent_log "warn" "High memory usage detected: ${MEMORY}MB"
+agent_log "error" "Connection failed: $ERROR_MSG"
+```
+
+### 2. Standalone Usage
+
+```bash
+# Direct command-line usage
+./.claude/skills/redis-coordination/agent-log.sh info "Agent initialized" \
+  --agent-id researcher-1 \
+  --task-id task-auth-123
+
+# From any script
+./.claude/skills/redis-coordination/agent-log.sh error "Validation failed" \
+  --agent-id reviewer-2 \
+  --task-id task-auth-123
+```
+
+### 3. Log Levels
+
+- **debug** - Detailed debugging information (cyan)
+- **info** - General informational messages (green)
+- **warn** - Warning messages (yellow)
+- **error** - Error conditions (red)
+
+## Output Destinations
+
+**1. Terminal (with colors)**
+```
+[INFO] [backend-dev-1] Starting authentication implementation
+[WARN] [backend-dev-1] Database connection slow
+[ERROR] [reviewer-1] JWT validation failed
+```
+
+**2. File (`/tmp/agent-<id>.log`)**
+```
+[2025-10-20T07:02:48Z] [INFO] [backend-dev-1] Starting authentication implementation
+[2025-10-20T07:02:48Z] [WARN] [backend-dev-1] Database connection slow
+[2025-10-20T07:02:48Z] [ERROR] [reviewer-1] JWT validation failed
+```
+
+**3. Redis (`swarm:<task-id>:logs`)**
+```json
+{
+  "level": "info",
+  "message": "Starting authentication implementation",
+  "agentId": "backend-dev-1",
+  "taskId": "task-auth-123",
+  "repository": "claude-flow-novice",
+  "timestamp": "2025-10-20T07:02:48Z"
+}
+```
+
+**4. Web Portal (http://localhost:3456 → Logs tab)**
+- Real-time streaming via WebSocket
+- Filter by repository, agent, or level
+- Shows last 1000 logs (100 displayed)
+- Auto-refreshes on new logs
+
+## Integration Points
+
+### Option 1: Source in Main Agent Script
+
+```bash
+# In your main agent script
+source .claude/skills/redis-coordination/agent-log.sh
+
+# Set global context once
+export AGENT_ID="${AGENT_TYPE}-${AGENT_NUM}"
+export TASK_ID="$TASK_ID"
+
+# Then log freely
+agent_log "info" "Agent spawned successfully"
+# ... agent work ...
+agent_log "info" "Task completed with confidence 0.95"
+```
+
+### Option 2: Wrap Agent Spawning
+
+```bash
+# In orchestrate-cfn-loop.sh or spawn-agent.sh
+./.claude/skills/redis-coordination/agent-log.sh info \
+  "Spawning agent: $AGENT_ID for task: $TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --task-id "$TASK_ID"
+
+# Spawn agent
+npx claude-flow-novice agent "$AGENT_TYPE" --task-id "$TASK_ID"
+
+# Log completion
+./.claude/skills/redis-coordination/agent-log.sh info \
+  "Agent $AGENT_ID completed" \
+  --agent-id "$AGENT_ID" \
+  --task-id "$TASK_ID"
+```
+
+### Option 3: Add to Existing Agent Logic
+
+If you have existing CLI agent code, wrap key operations:
+
+```bash
+# Before long operation
+agent_log "info" "Starting database migration"
+
+# During operation
+if [ "$ROWS_UPDATED" -gt 10000 ]; then
+  agent_log "warn" "Large migration in progress: $ROWS_UPDATED rows"
+fi
+
+# On error
+if ! run_migration; then
+  agent_log "error" "Migration failed: $ERROR"
+  exit 1
+fi
+
+# On success
+agent_log "info" "Migration completed: $ROWS_UPDATED rows updated"
+```
+
+## Advanced Options
+
+### Skip Terminal Output (Quiet Mode)
+
+```bash
+agent_log "info" "Background task started" --no-terminal
+```
+
+### Skip Redis Output (Local Only)
+
+```bash
+agent_log "debug" "Local debug info" --no-redis
+```
+
+### Manual Context Override
+
+```bash
+agent_log "error" "Connection timeout" \
+  --agent-id "custom-agent" \
+  --task-id "override-task-id"
+```
+
+## Portal Usage
+
+1. **Open portal:** http://localhost:3456
+2. **Go to Logs tab** (📝 Logs)
+3. **Filter logs:**
+   - Repository: Select specific repo or "All Repositories"
+   - Agent: Select specific agent or "All Agents"
+   - Level: debug/info/warn/error or "All Levels"
+4. **Clear logs:** Click "Clear Logs" button
+
+**Stats shown:**
+- Total logs in memory
+- Number of repositories logging
+- Number of active agents
+
+## Redis Keys
+
+**Pub/Sub Channel:**
+```
+swarm:<task-id>:logs
+```
+
+**Sorted Set (History):**
+```
+swarm:<task-id>:logs:history
+```
+- Score: Unix timestamp
+- Value: JSON log entry
+- TTL: 7 days (604800 seconds)
+
+## Examples
+
+### Example 1: CFN Loop Agent
+
+```bash
+#!/usr/bin/env bash
+source .claude/skills/redis-coordination/agent-log.sh
+
+AGENT_ID="coder-3"
+TASK_ID="$1"
+
+agent_log "info" "Starting Loop 3 implementation phase"
+
+# Implement feature
+agent_log "debug" "Reading specification from spec.md"
+agent_log "info" "Implementing authentication service"
+
+if ! run_tests; then
+  agent_log "error" "Tests failed - iteration needed"
+  exit 1
+fi
+
+agent_log "info" "Implementation complete - confidence: 0.88"
+```
+
+### Example 2: Orchestrator Logging
+
+```bash
+# In orchestrate-cfn-loop.sh
+agent_log "info" "CFN Loop started - mode: $MODE" \
+  --agent-id "orchestrator" \
+  --task-id "$TASK_ID"
+
+agent_log "info" "Spawning Loop 3 agents: $LOOP3_AGENTS" \
+  --agent-id "orchestrator" \
+  --task-id "$TASK_ID"
+
+# ... spawn agents ...
+
+agent_log "info" "Loop 3 consensus: $CONSENSUS (gate: $GATE_THRESHOLD)" \
+  --agent-id "orchestrator" \
+  --task-id "$TASK_ID"
+```
+
+## Troubleshooting
+
+**Logs not appearing in portal:**
+1. Check Redis connection: `redis-cli ping`
+2. Check portal subscription: Look for "✅ Subscribed to swarm:*:logs" in portal startup
+3. Verify task ID matches swarm task ID
+4. Check Redis pub/sub: `redis-cli psubscribe "swarm:*:logs"`
+
+**Colors not showing in terminal:**
+- WSL/Linux should show colors automatically
+- tmux: Colors should work by default
+- If colors missing, terminal may not support ANSI codes
+
+**Log file not created:**
+- Check permissions on `/tmp/`
+- Verify `AGENT_ID` is set (file named `/tmp/agent-${AGENT_ID}.log`)
+
+## Performance
+
+- **Minimal overhead:** ~5ms per log entry
+- **Non-blocking:** Redis operations use `> /dev/null 2>&1 || true`
+- **Memory efficient:** Portal keeps max 1000 logs, shows 100
+- **Auto-cleanup:** Redis history expires after 7 days
+
+## Migration from Old Logging
+
+**Before:**
+```bash
+echo "[INFO] Agent started"
+```
+
+**After:**
+```bash
+source .claude/skills/redis-coordination/agent-log.sh
+agent_log "info" "Agent started"
+```
+
+Benefits: Same terminal output + Redis pub/sub + portal visibility + file logging

package/.claude/skills/redis-coordination/agent-log.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+
+# Agent Logging Utility - Dual output (terminal + Redis)
+#
+# Usage:
+#   source agent-log.sh
+#   agent_log "info" "Message here"
+#   agent_log "error" "Error occurred"
+#
+# Or as standalone:
+#   ./agent-log.sh "info" "Agent started" --agent-id "researcher-1" --task-id "task-123"
+
+set -euo pipefail
+
+# Color codes for terminal output
+COLOR_RESET="\033[0m"
+COLOR_DEBUG="\033[0;36m"   # Cyan
+COLOR_INFO="\033[0;32m"    # Green
+COLOR_WARN="\033[0;33m"    # Yellow
+COLOR_ERROR="\033[0;31m"   # Red
+COLOR_AGENT="\033[0;35m"   # Magenta
+
+# Get color for log level
+get_log_color() {
+  local level="$1"
+  case "$level" in
+    debug) echo "$COLOR_DEBUG" ;;
+    info)  echo "$COLOR_INFO" ;;
+    warn)  echo "$COLOR_WARN" ;;
+    error) echo "$COLOR_ERROR" ;;
+    *) echo "$COLOR_RESET" ;;
+  esac
+}
+
+# Main logging function
+# Usage: agent_log <level> <message> [--agent-id <id>] [--task-id <id>] [--no-terminal] [--no-redis]
+agent_log() {
+  local LEVEL="${1:-info}"
+  local MESSAGE="${2:-}"
+  local AGENT_ID="${AGENT_ID:-unknown}"
+  local TASK_ID="${TASK_ID:-unknown}"
+  local REPOSITORY=$(basename "$(pwd)")
+  local NO_TERMINAL=false
+  local NO_REDIS=false
+
+  # Parse optional arguments
+  shift 2 || true
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --agent-id)
+        AGENT_ID="$2"
+        shift 2
+        ;;
+      --task-id)
+        TASK_ID="$2"
+        shift 2
+        ;;
+      --no-terminal)
+        NO_TERMINAL=true
+        shift
+        ;;
+      --no-redis)
+        NO_REDIS=true
+        shift
+        ;;
+      *)
+        shift
+        ;;
+    esac
+  done
+
+  local TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+  local COLOR=$(get_log_color "$LEVEL")
+
+  # 1. Terminal output (with colors)
+  if [ "$NO_TERMINAL" = false ]; then
+    echo -e "${COLOR}[${LEVEL^^}]${COLOR_RESET} ${COLOR_AGENT}[${AGENT_ID}]${COLOR_RESET} ${MESSAGE}"
+  fi
+
+  # 2. File output (no colors, in /tmp)
+  local LOG_FILE="/tmp/agent-${AGENT_ID}.log"
+  echo "[${TIMESTAMP}] [${LEVEL^^}] [${AGENT_ID}] ${MESSAGE}" >> "$LOG_FILE"
+
+  # 3. Redis pub/sub (for portal)
+  if [ "$NO_REDIS" = false ]; then
+    local LOG_PAYLOAD=$(cat <<EOF
+{
+  "level": "${LEVEL}",
+  "message": "${MESSAGE}",
+  "agentId": "${AGENT_ID}",
+  "taskId": "${TASK_ID}",
+  "repository": "${REPOSITORY}",
+  "timestamp": "${TIMESTAMP}"
+}
+EOF
+)
+
+    # Publish to Redis channel: swarm:<task-id>:logs
+    redis-cli publish "swarm:${TASK_ID}:logs" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
+
+    # Also add to sorted set for persistence (with timestamp as score)
+    local SCORE=$(date +%s)
+    redis-cli zadd "swarm:${TASK_ID}:logs:history" "$SCORE" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
+
+    # Set TTL on history (7 days)
+    redis-cli expire "swarm:${TASK_ID}:logs:history" 604800 > /dev/null 2>&1 || true
+  fi
+}
+
+# If script is executed directly (not sourced)
+if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
+  if [ $# -lt 2 ]; then
+    echo "Usage: $0 <level> <message> [--agent-id <id>] [--task-id <id>]"
+    echo ""
+    echo "Levels: debug, info, warn, error"
+    echo ""
+    echo "Examples:"
+    echo "  $0 info \"Agent started\" --agent-id researcher-1 --task-id task-123"
+    echo "  $0 error \"Connection failed\" --agent-id reviewer-2 --task-id task-456"
+    exit 1
+  fi
+
+  agent_log "$@"
+fi

package/.claude/skills/redis-coordination/init-swarm.sh

@@ -116,6 +116,9 @@ echo "[Swarm] TTL: $TTL seconds ($(($TTL / 86400)) days)"
 METADATA_KEY="swarm:${SWARM_ID}:metadata"
 
 # Store base metadata
+# Extract repository name from PWD
+REPO_NAME=$(basename "$(pwd)")
+
 redis-cli hset "$METADATA_KEY" \
   swarm_id "$SWARM_ID" \
   task_id "$TASK_ID" \
@@ -123,7 +126,9 @@ redis-cli hset "$METADATA_KEY" \
   max_agents "$MAX_AGENTS" \
   agents "$AGENTS" \
   created_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  status "in_progress" > /dev/null
+  status "in_progress" \
+  repository "$REPO_NAME" \
+  cwd "$(pwd)" > /dev/null
 
 # Add extra metadata if provided (JSON string)
 if [ -n "$METADATA_EXTRA" ]; then

package/.claude/skills/redis-coordination/invoke-waiting-mode.sh

@@ -199,6 +199,40 @@ case "$COMMAND" in
                 timestamp: ($ts | tonumber)
             }')
 
+        # Store feedback in Redis for agent to read (if provided and iteration > 0)
+        # Debug: Echo values before conditional (only if feedback provided)
+        if [ -n "$FEEDBACK" ]; then
+            [ "$DEBUG" = "true" ] && echo "[DEBUG] Checking feedback storage: FEEDBACK='$FEEDBACK', ITERATION='${ITERATION:-0}'"
+        fi
+
+        # Only store feedback if: feedback is non-empty AND iteration > 0
+        # Check iteration value explicitly (not just default)
+        if [ -n "$FEEDBACK" ] && [ -n "$ITERATION" ] && [ "$ITERATION" -gt 0 ]; then
+            FEEDBACK_KEY="swarm:${TASK_ID}:${AGENT_ID}:feedback:iteration-${ITERATION}"
+            FEEDBACK_ARRAY=$(echo "$FEEDBACK" | jq -Rc 'split(",") | map(select(length > 0))')
+
+            # Only store if feedback array is not empty after filtering
+            ARRAY_LENGTH=$(echo "$FEEDBACK_ARRAY" | jq 'length')
+            if [ "$ARRAY_LENGTH" -gt 0 ]; then
+                # Store as JSON array with 24-hour TTL using redis-cli -x (reads from stdin)
+                # Note: -x reads LAST argument from stdin, so we can't use SET key value EX ttl
+                # Instead: SET key (value from stdin), then EXPIRE key ttl
+                REDIS_RESULT=$(printf '%s' "$FEEDBACK_ARRAY" | redis-cli -x SET "$FEEDBACK_KEY")
+                redis-cli EXPIRE "$FEEDBACK_KEY" 86400 >/dev/null
+
+                # Always log feedback storage (not just in DEBUG mode)
+                if [ "$REDIS_RESULT" = "OK" ]; then
+                    echo "  [Feedback] Stored $ARRAY_LENGTH items in Redis (TTL: 24h)"
+                fi
+
+                if [ "$DEBUG" = "true" ]; then
+                    echo "[DEBUG] Stored feedback in $FEEDBACK_KEY (TTL: 24h)"
+                    echo "[DEBUG] Feedback: $FEEDBACK_ARRAY"
+                    echo "[DEBUG] Redis SET result: $REDIS_RESULT"
+                fi
+            fi
+        fi
+
         # Calculate priority score (lower score = higher priority, popped first)
         # Score = (100 - priority) * 1000000 + timestamp
         # This ensures higher priority messages are processed first, with FIFO for same priority
@@ -231,14 +265,16 @@ case "$COMMAND" in
 
         RESULT_KEY="swarm:${TASK_ID}:${AGENT_ID}:result"
 
-        # Build result message
+        # Build result message with optional feedback
         RESULT_MSG=$(jq -n \
             --arg confidence "$CONFIDENCE" \
             --arg iteration "${ITERATION:-0}" \
+            --arg feedback "${FEEDBACK:-}" \
             --arg ts "$(date +%s)" \
             '{
                 confidence: ($confidence | tonumber),
                 iteration: ($iteration | tonumber),
+                feedback: ($feedback | split(",") | map(select(length > 0))),
                 timestamp: ($ts | tonumber)
             }')
 
@@ -247,6 +283,9 @@ case "$COMMAND" in
         echo "[$AGENT_ID] ✅ Result reported"
         echo "  Confidence: $CONFIDENCE"
         [ -n "$ITERATION" ] && echo "  Iteration: $ITERATION"
+        if [ -n "$FEEDBACK" ]; then
+            echo "  Feedback items: $(echo "$FEEDBACK" | tr ',' '\n' | wc -l)"
+        fi
         ;;
 
     collect)
@@ -263,6 +302,7 @@ case "$COMMAND" in
 
         RESULTS=()
         CONFIDENCES=()
+        ALL_FEEDBACK=()
 
         for AGENT in "${AGENTS[@]}"; do
             RESULT_KEY="swarm:${TASK_ID}:${AGENT}:result"
@@ -271,12 +311,22 @@ case "$COMMAND" in
             RESULT=$(redis-cli LPOP "$RESULT_KEY")
 
             if [ -n "$RESULT" ] && [ "$RESULT" != "(nil)" ]; then
-                echo "  [$AGENT] $(echo "$RESULT" | jq -r '.confidence')"
-                RESULTS+=("$RESULT")
-
-                # Extract confidence for consensus calculation
                 CONF=$(echo "$RESULT" | jq -r '.confidence')
+                echo "  [$AGENT] Confidence: $CONF"
+                RESULTS+=("$RESULT")
                 CONFIDENCES+=("$CONF")
+
+                # Check if result includes feedback array
+                FEEDBACK=$(echo "$RESULT" | jq -r '.feedback // empty | .[]?' 2>/dev/null)
+                if [ -n "$FEEDBACK" ]; then
+                    echo "  [$AGENT] Feedback provided:"
+                    echo "$RESULT" | jq -r '.feedback[]' | sed 's/^/    - /'
+
+                    # Collect all feedback items
+                    while IFS= read -r ITEM; do
+                        ALL_FEEDBACK+=("$ITEM")
+                    done < <(echo "$RESULT" | jq -r '.feedback[]')
+                fi
             else
                 echo "  [$AGENT] ⚠️  No result found"
             fi
@@ -293,6 +343,13 @@ case "$COMMAND" in
 
             echo ""
             echo "[Coordinator] Consensus: $CONSENSUS"
+
+            # Print aggregated feedback if available
+            if [ ${#ALL_FEEDBACK[@]} -gt 0 ]; then
+                echo "[Coordinator] Aggregated Feedback (${#ALL_FEEDBACK[@]} items):"
+                printf '%s\n' "${ALL_FEEDBACK[@]}" | sort -u | sed 's/^/  - /'
+            fi
+
             echo "$CONSENSUS"
         else
             echo ""

package/.claude/skills/redis-coordination/orchestrate-cfn-loop.sh

@@ -389,7 +389,11 @@ function check_heartbeats_loop() {
         if [[ " ${LOOP3_AGENTS} " =~ " ${AGENT} " ]]; then
           REMAINING=$((${#LOOP3_COMPLETED_AGENTS[@]}))
           REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP3" "$LOOP3_TOTAL")
-        elif [[ " ${LOOP2_AGENTS} " =~ " ${LOOP2_AGENTS} " ]]; then
+        elif [[ " ${LOOP2_AGENTS} " =~ " ${AGENT} " ]]; then
+          # Safety check: LOOP2_COMPLETED_AGENTS may not be initialized during Loop 3
+          if [ -z "${LOOP2_COMPLETED_AGENTS+x}" ]; then
+            continue
+          fi
           REMAINING=$((${#LOOP2_COMPLETED_AGENTS[@]}))
           REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP2" "$LOOP2_TOTAL")
         else
@@ -787,12 +791,22 @@ for ITERATION in $(seq 1 $MAX_ITERATIONS); do
   fi
   echo ""
 
-  # Step 4: Collect Loop 2 consensus scores (only from completed agents)
+  # Step 4: Collect Loop 2 consensus scores and feedback (only from completed agents)
   echo "[Loop 2] Collecting consensus scores from ${#LOOP2_COMPLETED_AGENTS[@]} agents..."
   LOOP2_COMPLETED_IDS=$(IFS=','; echo "${LOOP2_COMPLETED_AGENTS[*]}")
-  LOOP2_CONSENSUS=$(./.claude/skills/redis-coordination/invoke-waiting-mode.sh collect \
+
+  # Capture full output to extract both consensus and feedback
+  COLLECT_OUTPUT=$(./.claude/skills/redis-coordination/invoke-waiting-mode.sh collect \
     --task-id "$TASK_ID" \
-    --agent-ids "$LOOP2_COMPLETED_IDS" | tail -1)
+    --agent-ids "$LOOP2_COMPLETED_IDS")
+
+  LOOP2_CONSENSUS=$(echo "$COLLECT_OUTPUT" | tail -1)
+
+  # Extract aggregated feedback from collect output
+  LOOP2_FEEDBACK=""
+  if echo "$COLLECT_OUTPUT" | grep -q "Aggregated Feedback"; then
+    LOOP2_FEEDBACK=$(echo "$COLLECT_OUTPUT" | sed -n '/Aggregated Feedback/,/Consensus:/p' | grep '^\s*-' | sed 's/^\s*-\s*//' | paste -sd ',' -)
+  fi
 
   echo "[Loop 2] Average consensus: $LOOP2_CONSENSUS (from ${#LOOP2_COMPLETED_AGENTS[@]}/${LOOP2_TOTAL} agents)"
 
@@ -803,6 +817,44 @@ for ITERATION in $(seq 1 $MAX_ITERATIONS); do
     '{consensus: ($consensus | tonumber), iteration: ($iteration | tonumber)}')
   echo "$LOOP2_METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:loop2_consensus" >/dev/null
 
+  # SPRINT 3 - Phase 2: Store iteration results for all agents
+  echo "[Coordinator] Storing iteration results for history..."
+  IFS=',' read -ra ALL_AGENTS_ARRAY <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
+  for AGENT in "${ALL_AGENTS_ARRAY[@]}"; do
+    # Get agent's confidence score
+    AGENT_CONFIDENCE=$(redis-cli get "swarm:${TASK_ID}:${AGENT}:confidence:iteration-${ITERATION}" || echo "0")
+    if [ "$AGENT_CONFIDENCE" = "(nil)" ]; then
+      AGENT_CONFIDENCE="0"
+    fi
+
+    # Get agent's result/output (try multiple possible keys)
+    AGENT_RESULT=$(redis-cli get "swarm:${TASK_ID}:${AGENT}:output" || echo "")
+    if [ "$AGENT_RESULT" = "(nil)" ] || [ -z "$AGENT_RESULT" ]; then
+      AGENT_RESULT="Completed iteration $ITERATION"
+    fi
+
+    # Store result with metadata
+    RESULT_DATA=$(jq -nc \
+      --arg result "$AGENT_RESULT" \
+      --arg confidence "$AGENT_CONFIDENCE" \
+      --arg iteration "$ITERATION" \
+      --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+      '{result: $result, confidence: ($confidence | tonumber), iteration: ($iteration | tonumber), timestamp: $timestamp}')
+
+    echo "$RESULT_DATA" | redis-cli -x setex "swarm:${TASK_ID}:${AGENT}:result:iteration-${ITERATION}" 86400 >/dev/null
+
+    # Store feedback if available (from Loop 2 validators)
+    if [ -n "$LOOP2_FEEDBACK" ]; then
+      FEEDBACK_DATA=$(jq -nc \
+        --arg feedback "$LOOP2_FEEDBACK" \
+        --arg iteration "$ITERATION" \
+        --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{feedback: $feedback, iteration: ($iteration | tonumber), timestamp: $timestamp}')
+      echo "$FEEDBACK_DATA" | redis-cli -x setex "swarm:${TASK_ID}:${AGENT}:feedback:iteration-${ITERATION}" 86400 >/dev/null
+    fi
+  done
+  echo "[Coordinator] Iteration results stored for ${#ALL_AGENTS_ARRAY[@]} agents"
+
   # Consensus check
   if (( $(echo "$LOOP2_CONSENSUS >= $CONSENSUS" | bc -l) )); then
     echo "✅ CONSENSUS REACHED ($LOOP2_CONSENSUS >= $CONSENSUS)"
@@ -899,8 +951,16 @@ for ITERATION in $(seq 1 $MAX_ITERATIONS); do
     exit 1
   fi
 
-  # Wake agents for next iteration with role-based priorities
-  echo "[Coordinator] Waking agents for iteration $((ITERATION + 1)) with priorities..."
+  # Wake agents for next iteration with role-based priorities and specific feedback
+  echo "[Coordinator] Waking agents for iteration $((ITERATION + 1)) with priorities and feedback..."
+
+  # Build feedback message for Loop 3 implementers
+  LOOP3_FEEDBACK="Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
+  if [ -n "$LOOP2_FEEDBACK" ]; then
+    # Include specific validator feedback
+    LOOP3_FEEDBACK="$LOOP3_FEEDBACK,$LOOP2_FEEDBACK"
+    echo "[Coordinator] Passing validator feedback to Loop 3: $(echo "$LOOP2_FEEDBACK" | tr ',' '\n' | wc -l) items"
+  fi
 
   # Wake Loop 3 implementers with MEDIUM priority (priority=30)
   IFS=',' read -ra LOOP3_ARRAY <<< "$LOOP3_AGENTS"
@@ -911,7 +971,7 @@ for ITERATION in $(seq 1 $MAX_ITERATIONS); do
       --priority 30 \
       --reason "cfn_loop_iteration" \
       --iteration $((ITERATION + 1)) \
-      --feedback "Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
+      --feedback "$LOOP3_FEEDBACK"
   done
 
   # Wake Loop 2 validators with HIGH priority (priority=10)
@@ -923,7 +983,7 @@ for ITERATION in $(seq 1 $MAX_ITERATIONS); do
       --priority 10 \
       --reason "cfn_loop_iteration" \
       --iteration $((ITERATION + 1)) \
-      --feedback "Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
+      --feedback "Re-validate iteration $((ITERATION + 1)) work against threshold >=$CONSENSUS"
   done
 
   echo ""