claude-flow-novice 2.9.1 → 2.10.0

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

@@ -0,0 +1,1550 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Loop Orchestration v2.0.0
+# Manages multi-loop CFN execution with dependency tracking and consensus
+#
+# Usage:
+#   ./orchestrate-cfn-loop.sh --task-id <id> \
+#                             --mode <mvp|standard|enterprise> \
+#                             --loop3-agents <agent1,agent2,...> \
+#                             --loop2-agents <agent1,agent2,...> \
+#                             --product-owner <agent-id> \
+#                             [--max-iterations <n>] \
+#                             [--min-quorum-loop3 <n|n%|0.n>] \
+#                             [--min-quorum-loop2 <n|n%|0.n>] \
+#                             [--epic-context <json>] \
+#                             [--phase-context <json>] \
+#                             [--success-criteria <json>]
+#
+# CFN Loop Structure (CORRECTED):
+#   Loop 3 (Primary Swarm - Self Validation)
+#     ↓
+#   IF Loop 3 self-validation gate FAILS → RELAUNCH Loop 3 (skip Loop 2)
+#   IF Loop 3 self-validation gate PASSES → Proceed to Loop 2
+#     ↓
+#   Loop 2 (Consensus Validators)
+#     ↓
+#   Product Owner Decision
+#
+# Dependency Enforcement:
+#   - Loop 3 agents self-validate via confidence scores
+#   - Gate check determines if Loop 2 validators should be engaged
+#   - Loop 2 agents WAIT for gate pass signal before starting work
+#   - Product Owner BLOCKS until all Loop 2 agents signal completion
+#   - Uses Redis BLPOP for zero-token waiting
+#
+# Quorum Configuration:
+#   - Absolute: --min-quorum-loop3 3 (requires exactly 3 agents)
+#   - Percentage: --min-quorum-loop3 85% (requires 85% of agents)
+#   - Decimal: --min-quorum-loop3 0.66 (requires 66% of agents)
+#   - Default: 0.66 (2/3 majority) if not specified
+#
+# Agent Requirements:
+#   Loop 3 (Implementers):
+#     1. Complete work
+#     2. Signal done: redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+#     3. Report confidence: invoke-waiting-mode.sh report --confidence <0.0-1.0>
+#     4. Enter waiting: invoke-waiting-mode.sh enter (for potential iteration)
+#
+#   Loop 2 (Validators):
+#     1. WAIT for gate pass: redis-cli blpop "swarm:${TASK_ID}:gate-passed" 0
+#     2. Retrieve Loop 3 results for review
+#     3. Perform validation
+#     4. Signal done: redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+#     5. Report consensus: invoke-waiting-mode.sh report --confidence <0.0-1.0>
+#     6. Enter waiting: invoke-waiting-mode.sh enter (for potential iteration)
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+TASK_ID=""
+MODE="standard"
+LOOP3_AGENTS=""
+LOOP2_AGENTS=""
+PRODUCT_OWNER=""
+MAX_ITERATIONS=10
+TIMEOUT=3600  # 60 minute default timeout for agent completion
+RETRY_COUNT=3
+RETRY_DELAY=5000  # Base delay in milliseconds
+MIN_QUORUM_LOOP3=""  # Minimum agents required for Loop 3 (absolute or percentage)
+MIN_QUORUM_LOOP2=""  # Minimum agents required for Loop 2 (absolute or percentage)
+ORCHESTRATOR_PID=$$
+SHUTDOWN_MONITOR_PID=""
+SHUTDOWN_REQUESTED=0
+LOOP3_HEARTBEAT_MONITOR_PID=""
+LOOP2_HEARTBEAT_MONITOR_PID=""
+
+# Epic Context (optional - for agent system prompts)
+EPIC_CONTEXT=""
+PHASE_CONTEXT=""
+SUCCESS_CRITERIA=""
+EXPECTED_FILES=""  # BUG #12 FIX: Explicit file verification
+PHASE_ID=""  # BUG #16 FIX: Phase identifier for timeout configuration
+
+# Thresholds by mode
+declare -A GATE_THRESHOLD=(
+  [mvp]=0.70
+  [standard]=0.75
+  [enterprise]=0.75
+)
+
+declare -A CONSENSUS_THRESHOLD=(
+  [mvp]=0.80
+  [standard]=0.90
+  [enterprise]=0.95
+)
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
+    --loop3-agents)
+      LOOP3_AGENTS="$2"
+      shift 2
+      ;;
+    --loop2-agents)
+      LOOP2_AGENTS="$2"
+      shift 2
+      ;;
+    --product-owner)
+      PRODUCT_OWNER="$2"
+      shift 2
+      ;;
+    --max-iterations)
+      MAX_ITERATIONS="$2"
+      shift 2
+      ;;
+    --retry-count)
+      RETRY_COUNT="$2"
+      shift 2
+      ;;
+    --retry-delay)
+      RETRY_DELAY="$2"
+      shift 2
+      ;;
+    --timeout)
+      TIMEOUT="$2"
+      shift 2
+      ;;
+    --min-quorum-loop3)
+      MIN_QUORUM_LOOP3="$2"
+      shift 2
+      ;;
+    --min-quorum-loop2)
+      MIN_QUORUM_LOOP2="$2"
+      shift 2
+      ;;
+    --epic-context)
+      EPIC_CONTEXT="$2"
+      shift 2
+      ;;
+    --phase-context)
+      PHASE_CONTEXT="$2"
+      shift 2
+      ;;
+    --success-criteria)
+      SUCCESS_CRITERIA="$2"
+      shift 2
+      ;;
+    --expected-files)
+      EXPECTED_FILES="$2"
+      shift 2
+      ;;
+    --phase-id)
+      PHASE_ID="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ] || [ -z "$LOOP3_AGENTS" ] || [ -z "$LOOP2_AGENTS" ] || [ -z "$PRODUCT_OWNER" ]; then
+  echo "Error: Required parameters missing"
+  echo "Usage: $0 --task-id <id> --mode <mode> --loop3-agents <agents> --loop2-agents <agents> --product-owner <agent>"
+  exit 1
+fi
+
+GATE=${GATE_THRESHOLD[$MODE]}
+CONSENSUS=${CONSENSUS_THRESHOLD[$MODE]}
+
+# Set default quorum values if not specified (66% = 2/3 majority)
+MIN_QUORUM_LOOP3=${MIN_QUORUM_LOOP3:-0.66}
+MIN_QUORUM_LOOP2=${MIN_QUORUM_LOOP2:-0.66}
+
+##############################################################################
+# Shutdown Handling Functions
+##############################################################################
+function cleanup_and_exit() {
+  local exit_code="${1:-130}"
+  local reason="${2:-user_interrupt}"
+
+  # Set shutdown flag to stop any ongoing operations
+  SHUTDOWN_REQUESTED=1
+
+  echo ""
+  echo "=============================================="
+  echo "🛑 Orchestrator shutting down gracefully..."
+  echo "=============================================="
+  echo "Reason: $reason"
+  echo "Exit Code: $exit_code"
+
+  # Kill shutdown monitor if running
+  if [ -n "$SHUTDOWN_MONITOR_PID" ] && kill -0 "$SHUTDOWN_MONITOR_PID" 2>/dev/null; then
+    kill "$SHUTDOWN_MONITOR_PID" 2>/dev/null || true
+    wait "$SHUTDOWN_MONITOR_PID" 2>/dev/null || true
+  fi
+
+  # Stop heartbeat monitors if running
+  if [ -n "${LOOP3_HEARTBEAT_MONITOR_PID:-}" ]; then
+    echo "Stopping Loop 3 heartbeat monitor..."
+    stop_heartbeat_monitor "$TASK_ID" "loop3" "$LOOP3_HEARTBEAT_MONITOR_PID"
+  fi
+  if [ -n "${LOOP2_HEARTBEAT_MONITOR_PID:-}" ]; then
+    echo "Stopping Loop 2 heartbeat monitor..."
+    stop_heartbeat_monitor "$TASK_ID" "loop2" "$LOOP2_HEARTBEAT_MONITOR_PID"
+  fi
+
+  # Mark swarm as cancelled if initialized
+  if [ -n "$TASK_ID" ] && [ -n "${SWARM_ID:-}" ]; then
+    echo "Marking swarm as cancelled..."
+    ./.claude/skills/redis-coordination/complete-swarm.sh \
+      --swarm-id "$SWARM_ID" \
+      --final-metric "status=cancelled" \
+      --final-metric "shutdown_reason=$reason" 2>/dev/null || echo "  ⚠️ Failed to mark swarm as cancelled"
+  fi
+
+  # Clean up Redis keys
+  if [ -n "$TASK_ID" ]; then
+    echo "Cleaning up Redis keys..."
+    local keys_deleted=$(redis-cli --scan --pattern "swarm:${TASK_ID}:*" | xargs -r redis-cli DEL 2>/dev/null || echo "0")
+    echo "  Deleted $keys_deleted Redis keys"
+  fi
+
+  # Clean up heartbeat monitor marker files
+  rm -f /tmp/heartbeat-monitor-${TASK_ID}-*.active 2>/dev/null || true
+
+  echo "=============================================="
+  echo "Shutdown complete"
+  echo "=============================================="
+
+  exit "$exit_code"
+}
+
+# Trap SIGTERM and SIGINT for graceful shutdown
+trap 'echo "[TRAP] Caught SIGINT" >&2; cleanup_and_exit 130 "SIGINT_received"' SIGINT
+trap 'echo "[TRAP] Caught SIGTERM" >&2; cleanup_and_exit 143 "SIGTERM_received"' SIGTERM
+
+##############################################################################
+# Start Shutdown Monitor (Background Process)
+##############################################################################
+function start_shutdown_monitor() {
+  local task_id="$1"
+
+  (
+    # Block on shutdown channel (zero-token waiting)
+    SHUTDOWN_KEY="swarm:${task_id}:shutdown"
+    SHUTDOWN_RESULT=$(redis-cli BLPOP "$SHUTDOWN_KEY" 0 2>/dev/null || echo "")
+
+    if [ -n "$SHUTDOWN_RESULT" ]; then
+      # Extract shutdown payload (format: key value)
+      SHUTDOWN_PAYLOAD=$(echo "$SHUTDOWN_RESULT" | tail -1)
+      REASON=$(echo "$SHUTDOWN_PAYLOAD" | jq -r '.reason // "external_shutdown"' 2>/dev/null || echo "external_shutdown")
+
+      echo ""
+      echo "🛑 Shutdown signal received from Redis channel: $REASON"
+      echo "  Sending SIGTERM to orchestrator PID: $ORCHESTRATOR_PID"
+
+      # Send SIGTERM to main orchestrator process
+      if kill -TERM "$ORCHESTRATOR_PID" 2>/dev/null; then
+        echo "  ✅ SIGTERM sent successfully"
+      else
+        echo "  ❌ Failed to send SIGTERM (process may have already exited)"
+        exit 0
+      fi
+    fi
+  ) &
+
+  SHUTDOWN_MONITOR_PID=$!
+  echo "Shutdown monitor started (PID: $SHUTDOWN_MONITOR_PID)"
+}
+
+##############################################################################
+# Quorum Calculation Function
+##############################################################################
+function calculate_quorum() {
+  local quorum_spec="$1"
+  local total_agents="$2"
+
+  # If no quorum specified, require all agents
+  if [ -z "$quorum_spec" ]; then
+    echo "$total_agents"
+    return 0
+  fi
+
+  # Check if percentage format (e.g., "85%")
+  if [[ "$quorum_spec" =~ %$ ]]; then
+    # Extract percentage value (remove % suffix)
+    local pct="${quorum_spec%\%}"
+    # Calculate: ceil(total_agents * pct / 100)
+    echo "scale=0; ($total_agents * $pct + 50) / 100" | bc
+  # Check if decimal (0.0-1.0), treat as fraction
+  elif [[ "$quorum_spec" =~ ^0?\.[0-9]+$ ]]; then
+    # Calculate: ceil(total_agents * fraction)
+    echo "scale=0; ($quorum_spec * $total_agents + 0.5) / 1" | bc
+  else
+    # Absolute number - validate it doesn't exceed total
+    if [ "$quorum_spec" -gt "$total_agents" ]; then
+      echo "Error: Quorum ($quorum_spec) exceeds total agents ($total_agents)" >&2
+      return 1
+    fi
+    echo "$quorum_spec"
+  fi
+}
+
+##############################################################################
+# Dead Letter Queue (DLQ) Functions
+##############################################################################
+function write_to_dlq() {
+  local agent="$1"
+  local reason="$2"
+  local retry_count="$3"
+
+  DLQ_KEY="swarm:${TASK_ID}:dlq:${agent}"
+  DLQ_ENTRY=$(jq -n \
+    --arg reason "$reason" \
+    --arg retries "$retry_count" \
+    --arg ts "$(date +%s)" \
+    '{reason: $reason, retry_count: ($retries | tonumber), timestamp: ($ts | tonumber)}')
+
+  echo "$DLQ_ENTRY" | redis-cli -x LPUSH "$DLQ_KEY" >/dev/null
+  redis-cli EXPIRE "$DLQ_KEY" 604800 >/dev/null  # 7 days TTL
+
+  echo "  ❌ $agent → DLQ (reason: $reason, retries: $retry_count)"
+}
+
+##############################################################################
+# Exponential Backoff Retry Function
+##############################################################################
+function retry_with_backoff() {
+  local agent="$1"
+  local attempt="$2"
+  local max_retries="$3"
+  local base_delay="$4"
+
+  # Check for shutdown before sleeping
+  if [ "$SHUTDOWN_REQUESTED" -eq 1 ]; then
+    echo "  [SHUTDOWN] Skipping backoff delay for $agent" >&2
+    return 0
+  fi
+
+  # Exponential backoff: delay = base_delay * (2 ^ attempt)
+  local delay=$(echo "$base_delay * (2 ^ $attempt)" | bc)
+  local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+  echo "  [$timestamp] [Retry $attempt/$max_retries] Waiting ${delay}ms before retry for $agent..."
+
+  # Use interruptible sleep - sleep in small increments and check for shutdown
+  local delay_sec=$(echo "scale=3; $delay / 1000" | bc)
+  local elapsed=0
+  while (( $(echo "$elapsed < $delay_sec" | bc -l) )); do
+    # Sleep for 0.5s increments (or remaining time if less)
+    local remaining=$(echo "$delay_sec - $elapsed" | bc)
+    local sleep_time=$(echo "if ($remaining < 0.5) $remaining else 0.5" | bc)
+
+    sleep "$sleep_time" &
+    wait $! 2>/dev/null || return 0  # If wait is interrupted (SIGTERM), return immediately
+
+    elapsed=$(echo "$elapsed + $sleep_time" | bc)
+
+    # Check for shutdown after each sleep increment
+    if [ "$SHUTDOWN_REQUESTED" -eq 1 ]; then
+      echo "  [SHUTDOWN] Interrupted backoff delay for $agent" >&2
+      return 0
+    fi
+  done
+}
+
+##############################################################################
+# Heartbeat Monitoring Functions
+##############################################################################
+declare -A MISSED_HEARTBEATS  # Track missed heartbeats per agent
+
+function check_agent_heartbeat() {
+  local agent="$1"
+  local task_id="$2"
+  local iteration="$3"
+
+  # Agents create heartbeat as: swarm:${task_id}:agent:${agent_id} (HASH with heartbeat field)
+  # Agent ID includes iteration suffix: react-frontend-engineer-1
+  HB_KEY="swarm:${task_id}:agent:${agent}-${iteration}"
+  HB_DATA=$(redis-cli HGET "$HB_KEY" heartbeat 2>/dev/null || echo "")
+
+  if [ -z "$HB_DATA" ] || [ "$HB_DATA" = "(nil)" ]; then
+    return 1  # Dead
+  else
+    return 0  # Alive
+  fi
+}
+
+function check_heartbeats_loop() {
+  local task_id="$1"
+  local loop_name="$2"
+  local iteration="$3"
+  shift 3
+  local agents=("$@")
+
+  for AGENT in "${agents[@]}"; do
+    # Skip agents already marked as failed
+    if [[ " ${LOOP3_FAILED_AGENTS[@]} ${LOOP2_FAILED_AGENTS[@]} " =~ " ${AGENT} " ]]; then
+      continue
+    fi
+
+    if ! check_agent_heartbeat "$AGENT" "$task_id" "$iteration"; then
+      MISSED_HEARTBEATS["$AGENT"]=$((${MISSED_HEARTBEATS["$AGENT"]:-0} + 1))
+
+      if [ ${MISSED_HEARTBEATS["$AGENT"]} -ge 2 ]; then
+        local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+        echo "  [$timestamp] [$loop_name] ⚠️ $AGENT appears hung (no heartbeat for 60s)" >&2
+
+        # Determine which loop this agent belongs to and check quorum
+        if [[ " ${LOOP3_AGENTS} " =~ " ${AGENT} " ]]; then
+          REMAINING=$((${#LOOP3_COMPLETED_AGENTS[@]}))
+          REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP3" "$LOOP3_TOTAL")
+        elif [[ " ${LOOP2_AGENTS} " =~ " ${AGENT} " ]]; then
+          # Safety check: Skip if Loop 2 hasn't been initialized yet
+          if [ -z "${LOOP2_COMPLETED_AGENTS+x}" ]; then
+            continue
+          fi
+          REMAINING=$((${#LOOP2_COMPLETED_AGENTS[@]}))
+          REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP2" "$LOOP2_TOTAL")
+        else
+          continue
+        fi
+
+        if [ $REMAINING -ge $REQUIRED ]; then
+          echo "  [$timestamp] [$loop_name] ℹ️ Continuing with quorum (${REMAINING}/${REQUIRED} agents)" >&2
+        else
+          echo "  [$timestamp] [$loop_name] ⚠️ Cannot meet quorum without $AGENT (${REMAINING}/${REQUIRED})" >&2
+        fi
+      fi
+    else
+      MISSED_HEARTBEATS["$AGENT"]=0  # Reset counter
+    fi
+  done
+}
+
+function start_heartbeat_monitor() {
+  local task_id="$1"
+  local loop_name="$2"
+  local iteration="$3"
+  shift 3
+  local agents=("$@")
+
+  # Create marker file for this monitor
+  local monitor_marker="/tmp/heartbeat-monitor-${task_id}-${loop_name}.active"
+  touch "$monitor_marker"
+
+  # [BUG #7 FIX] Spawn background process and let caller capture $!
+  (
+    while [ -f "$monitor_marker" ]; do
+      # Check for shutdown
+      if [ "$SHUTDOWN_REQUESTED" -eq 1 ]; then
+        break
+      fi
+
+      check_heartbeats_loop "$task_id" "$loop_name" "$iteration" "${agents[@]}"
+      sleep 30
+    done
+  ) &
+
+  # No echo - caller will use $! to get PID
+}
+
+function stop_heartbeat_monitor() {
+  local task_id="$1"
+  local loop_name="$2"
+  local monitor_pid="$3"
+
+  # Remove marker file to stop the monitor loop
+  rm -f "/tmp/heartbeat-monitor-${task_id}-${loop_name}.active"
+
+  # Kill monitor process if still running
+  if [ -n "$monitor_pid" ] && kill -0 "$monitor_pid" 2>/dev/null; then
+    kill "$monitor_pid" 2>/dev/null || true
+    wait "$monitor_pid" 2>/dev/null || true
+  fi
+}
+
+##############################################################################
+# Get Agent-Specific Timeout
+##############################################################################
+function get_agent_timeout() {
+  local agent="$1"
+  local task_id="$2"
+
+  # Use get-agent-timeout.sh helper script
+  SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  AGENT_TIMEOUT=$("$SCRIPT_DIR/get-agent-timeout.sh" --task-id "$task_id" --agent-id "$agent" 2>/dev/null || echo "$TIMEOUT")
+
+  echo "$AGENT_TIMEOUT"
+}
+
+##############################################################################
+# Process-Based Completion Monitoring
+##############################################################################
+function monitor_agent_process() {
+  local agent_id="$1"
+  local agent_pid="$2"
+  local task_id="$3"
+  local done_key="$4"
+
+  # Monitor agent process in background
+  (
+    # Wait for process to exit
+    wait "$agent_pid" 2>/dev/null
+    EXIT_CODE=$?
+
+    # Check if done signal already sent (agent may have signaled normally)
+    DONE_COUNT=$(redis-cli LLEN "$done_key" 2>/dev/null || echo "0")
+    if [ "$DONE_COUNT" -gt 0 ]; then
+      # Agent signaled normally - nothing to do
+      exit 0
+    fi
+
+    # Process exited without signaling - auto-complete
+    if [ $EXIT_CODE -eq 0 ]; then
+      echo "  [Process Monitor] $agent_id exited successfully (code 0) - auto-signaling completion" >&2
+      redis-cli LPUSH "$done_key" "auto-completed-success" >/dev/null
+    else
+      echo "  [Process Monitor] $agent_id exited with error (code $EXIT_CODE) - auto-signaling failure" >&2
+      redis-cli LPUSH "$done_key" "auto-completed-error:$EXIT_CODE" >/dev/null
+
+      # METRICS: Increment error counter
+      redis-cli INCR "swarm:${task_id}:metrics:agent_errors" >/dev/null
+    fi
+  ) &
+}
+
+##############################################################################
+# BLPOP with Retry Logic + Process Monitoring
+##############################################################################
+function blpop_with_retry() {
+  local agent="$1"
+  local done_key="$2"
+  local timeout="$3"
+  local retry_count="$4"
+  local retry_delay="$5"
+  local agent_pid="${6:-}"  # Optional: PID for process monitoring
+
+  for ATTEMPT in $(seq 1 $retry_count); do
+    # Check for shutdown before attempting BLPOP
+    if [ "$SHUTDOWN_REQUESTED" -eq 1 ]; then
+      echo "  [SHUTDOWN] Aborting BLPOP for $agent" >&2
+      return 1
+    fi
+
+    # Use Redis's native BLPOP timeout instead of shell timeout command
+    # This allows SIGTERM to properly interrupt the process
+    RESULT=$(redis-cli blpop "$done_key" "$timeout" 2>/dev/null || echo "")
+
+    if [ -n "$RESULT" ]; then
+      echo "$RESULT"
+      return 0  # Success
+    fi
+
+    # BLPOP timeout - check if process is still alive
+    if [ -n "$agent_pid" ]; then
+      if ! kill -0 "$agent_pid" 2>/dev/null; then
+        echo "  [Process Check] Agent process $agent_pid no longer running" >&2
+
+        # Process exited - check if done signal was auto-generated
+        RESULT=$(redis-cli LPOP "$done_key" 2>/dev/null || echo "")
+        if [ -n "$RESULT" ]; then
+          echo "  [Auto-Complete] Retrieved: $RESULT" >&2
+          echo "$RESULT"
+          return 0
+        fi
+      fi
+    fi
+
+    # Check for shutdown after BLPOP timeout
+    if [ "$SHUTDOWN_REQUESTED" -eq 1 ]; then
+      echo "  [SHUTDOWN] Aborting retry for $agent" >&2
+      return 1
+    fi
+
+    # Check heartbeat status
+    HEARTBEAT_KEY="swarm:${TASK_ID}:${agent}:heartbeat"
+    HEARTBEAT_EXISTS=$(redis-cli EXISTS "$HEARTBEAT_KEY" 2>/dev/null || echo "0")
+
+    if [ "$HEARTBEAT_EXISTS" -eq 0 ]; then
+      echo "  ⚠️  No heartbeat from $agent - agent may be stuck or crashed" >&2
+
+      # If we have PID and process is stuck, kill it
+      if [ -n "$agent_pid" ] && kill -0 "$agent_pid" 2>/dev/null; then
+        echo "  [Timeout Kill] Terminating stuck process $agent_pid" >&2
+        kill "$agent_pid" 2>/dev/null || true
+        sleep 2
+
+        # Force kill if still alive
+        if kill -0 "$agent_pid" 2>/dev/null; then
+          kill -9 "$agent_pid" 2>/dev/null || true
+        fi
+
+        # METRICS: Increment timeout counter
+        redis-cli INCR "swarm:${TASK_ID}:metrics:agent_killed" >/dev/null
+      fi
+    fi
+
+    # Log retry attempt (to stderr so it's visible during command substitution)
+    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "  [$timestamp] ⚠️ BLPOP attempt $ATTEMPT/$retry_count failed for $agent" >&2
+
+    if [ $ATTEMPT -lt $retry_count ]; then
+      # METRICS: Increment retry counter
+      redis-cli INCR "swarm:${TASK_ID}:metrics:retry_count" >/dev/null
+
+      retry_with_backoff "$agent" "$ATTEMPT" "$retry_count" "$retry_delay" >&2
+    else
+      # Final failure - write to DLQ
+      echo "  [$timestamp] ❌ FINAL FAILURE: $agent after $retry_count attempts" >&2
+      write_to_dlq "$agent" "timeout_after_retries" "$retry_count"
+      return 1
+    fi
+  done
+
+  return 1
+}
+
+echo "=== CFN Loop Orchestration ==="
+echo "Task ID: $TASK_ID"
+echo "Mode: $MODE (Gate: $GATE, Consensus: $CONSENSUS)"
+echo "Max Iterations: $MAX_ITERATIONS"
+echo ""
+
+# Initialize swarm using general Redis coordination primitive
+SWARM_ID="swarm-${TASK_ID}"
+ALL_AGENTS="${LOOP3_AGENTS},${LOOP2_AGENTS},${PRODUCT_OWNER}"
+
+# LOG: Swarm initialization
+./.claude/skills/redis-coordination/log-event.sh \
+  --task-id "$TASK_ID" \
+  --event-type "swarm_init" \
+  --details "{\"mode\": \"$MODE\", \"loop3_agents\": \"$LOOP3_AGENTS\", \"loop2_agents\": \"$LOOP2_AGENTS\", \"product_owner\": \"$PRODUCT_OWNER\", \"max_iterations\": $MAX_ITERATIONS, \"gate_threshold\": $GATE, \"consensus_threshold\": $CONSENSUS}" \
+  --level "INFO" 2>/dev/null || true
+
+# Build CFN-specific metadata
+CFN_METADATA=$(cat <<EOF
+{
+  "mode": "$MODE",
+  "loop3_agents": "$LOOP3_AGENTS",
+  "loop2_agents": "$LOOP2_AGENTS",
+  "product_owner": "$PRODUCT_OWNER",
+  "workflow_type": "cfn_loop"
+}
+EOF
+)
+
+# Use general init-swarm primitive
+./.claude/skills/redis-coordination/init-swarm.sh \
+  --swarm-id "$SWARM_ID" \
+  --agents "$ALL_AGENTS" \
+  --task-id "$TASK_ID" \
+  --topology "hierarchical" \
+  --metadata "$CFN_METADATA" > /dev/null
+
+# Start shutdown monitor in background
+start_shutdown_monitor "$TASK_ID"
+
+# Store epic context in Redis (if provided)
+if [ -n "$EPIC_CONTEXT" ]; then
+  echo "📋 Storing epic context in Redis..."
+  # Escape single quotes for Redis
+  EPIC_ESCAPED="${EPIC_CONTEXT//\'/\'\\\'\'}"
+  redis-cli setex "swarm:${TASK_ID}:epic-context" 604800 "$EPIC_ESCAPED" >/dev/null
+  echo "  ✅ Epic context stored (TTL: 7 days)"
+fi
+
+if [ -n "$PHASE_CONTEXT" ]; then
+  echo "📋 Storing phase context in Redis..."
+  PHASE_ESCAPED="${PHASE_CONTEXT//\'/\'\\\'\'}"
+  redis-cli setex "swarm:${TASK_ID}:phase-context" 604800 "$PHASE_ESCAPED" >/dev/null
+  echo "  ✅ Phase context stored (TTL: 7 days)"
+fi
+
+if [ -n "$SUCCESS_CRITERIA" ]; then
+  echo "📋 Storing success criteria in Redis..."
+  CRITERIA_ESCAPED="${SUCCESS_CRITERIA//\'/\'\\\'\'}"
+  redis-cli setex "swarm:${TASK_ID}:success-criteria" 604800 "$CRITERIA_ESCAPED" >/dev/null
+  echo "  ✅ Success criteria stored (TTL: 7 days)"
+fi
+
+echo ""
+
+# [BUG #15 FIX] REMOVED: Early Product Owner spawn at iteration 0
+# Product Owner now only spawned after Loop 2 completes (see line 1283)
+# This prevents timeout issues with waiting mode initialization
+echo "[Product Owner] Will spawn after Loop 2 consensus (just-in-time pattern)"
+echo ""
+
+# Iteration loop
+for ITERATION in $(seq 1 $MAX_ITERATIONS); do
+  echo "=== Iteration $ITERATION/$MAX_ITERATIONS ==="
+
+  # METRICS: Iteration start timestamp
+  ITERATION_START=$(date +%s%N | cut -b1-13)  # milliseconds
+  redis-cli LPUSH "swarm:${TASK_ID}:metrics:iteration_start" "$ITERATION_START" >/dev/null
+
+  # Step 1: Build detailed agent context from Redis (BUG #20 FIX - Option 2)
+  echo "[Loop 3] Building agent context from Redis..."
+
+  # Retrieve stored context
+  EPIC_CTX=$(redis-cli get "swarm:${TASK_ID}:epic-context" 2>/dev/null || echo "{}")
+  PHASE_CTX=$(redis-cli get "swarm:${TASK_ID}:phase-context" 2>/dev/null || echo "{}")
+  SUCCESS_CTX=$(redis-cli get "swarm:${TASK_ID}:success-criteria" 2>/dev/null || echo "{}")
+
+  # Extract key fields with jq (safe parsing)
+  EPIC_GOAL=$(echo "$EPIC_CTX" | jq -r '.epicGoal // "No epic goal specified"')
+  IN_SCOPE=$(echo "$EPIC_CTX" | jq -r '.inScope[]? // empty' | sed 's/^/- /' || echo "- (not specified)")
+  OUT_SCOPE=$(echo "$EPIC_CTX" | jq -r '.outOfScope[]? // empty' | sed 's/^/- /' || echo "- (not specified)")
+  DELIVERABLES=$(echo "$PHASE_CTX" | jq -r '.deliverables[]? // empty' | sed 's/^/- /' || echo "- (not specified)")
+  DIRECTORY=$(echo "$PHASE_CTX" | jq -r '.directory // ""')
+  ACCEPTANCE=$(echo "$SUCCESS_CTX" | jq -r '.acceptanceCriteria[]? // empty' | sed 's/^/- /' || echo "- (not specified)")
+
+  # Build structured agent context
+  LOOP3_AGENT_CONTEXT="Loop 3 implementation for iteration $ITERATION
+
+Epic Goal: $EPIC_GOAL
+
+In Scope:
+$IN_SCOPE
+
+Out of Scope:
+$OUT_SCOPE
+
+Deliverables (CRITICAL - you MUST create these files):
+$DELIVERABLES
+$([ -n "$DIRECTORY" ] && echo "
+Target Directory: $DIRECTORY")
+
+Acceptance Criteria:
+$ACCEPTANCE
+
+IMPORTANT:
+- Use Write tool to create each deliverable file
+- Verify files created with 'ls -la \$DIRECTORY' after each Write
+- All deliverables must exist for validation to pass
+- Report confidence score based on actual file creation
+"
+
+  echo "  ✅ Agent context built ($(echo "$LOOP3_AGENT_CONTEXT" | wc -c) characters)"
+  echo ""
+
+  # Step 2: Spawn Loop 3 agents via CLI
+  echo "[Loop 3] Spawning implementers via CLI..."
+  IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
+
+  # Track instance counts to generate unique agent IDs for duplicate agent types
+  declare -A AGENT_INSTANCE_COUNTS
+  declare -A AGENT_IDS  # Map from array index to unique agent ID
+
+  # Pre-calculate unique agent IDs
+  for i in "${!AGENTS[@]}"; do
+    AGENT="${AGENTS[$i]}"
+
+    # Increment instance counter for this agent type
+    AGENT_INSTANCE_COUNTS["$AGENT"]=$((${AGENT_INSTANCE_COUNTS["$AGENT"]:-0} + 1))
+    INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$AGENT"]}"
+
+    # Generate unique agent ID: agent-type-iteration-instance
+    UNIQUE_AGENT_ID="${AGENT}-${ITERATION}-${INSTANCE_NUM}"
+    AGENT_IDS["$i"]="$UNIQUE_AGENT_ID"
+
+    echo "  [Instance Tracking] ${AGENT} #${INSTANCE_NUM} → ${UNIQUE_AGENT_ID}"
+  done
+
+  echo ""
+
+  # [PHASE 1 INTEGRATION] Loop 3 Skill-Based Output Processing (Parallel)
+  # Uses .claude/skills/loop3-output-processing/ for guaranteed confidence extraction
+  echo "[Loop 3] Using skill-based output processing (parallel execution)"
+
+  LOOP3_TOTAL=${#AGENTS[@]}
+  LOOP3_REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP3" "$LOOP3_TOTAL")
+  LOOP3_COMPLETED_AGENTS=()
+  LOOP3_FAILED_AGENTS=()
+
+  echo "[Loop 3] Quorum: $LOOP3_REQUIRED/$LOOP3_TOTAL agents required"
+  echo ""
+
+  # Step 2a: Spawn all agents in parallel (background processes)
+  declare -A AGENT_PIDS
+  declare -A AGENT_OUTPUT_FILES
+
+  for i in "${!AGENTS[@]}"; do
+    AGENT="${AGENTS[$i]}"
+    UNIQUE_AGENT_ID="${AGENT_IDS[$i]}"
+
+    # Get agent-specific timeout
+    AGENT_TIMEOUT=$(get_agent_timeout "$AGENT" "$TASK_ID")
+
+    # Create temp file for agent output
+    OUTPUT_FILE="/tmp/loop3-${TASK_ID}-${UNIQUE_AGENT_ID}.json"
+    AGENT_OUTPUT_FILES["$UNIQUE_AGENT_ID"]="$OUTPUT_FILE"
+
+    echo "  Spawning $AGENT (ID: $UNIQUE_AGENT_ID, timeout: ${AGENT_TIMEOUT}s)"
+
+    # LOG: Loop 3 agent spawn
+    ./.claude/skills/redis-coordination/log-event.sh \
+      --task-id "$TASK_ID" \
+      --event-type "agent_spawn" \
+      --loop "loop3" \
+      --agent-id "$UNIQUE_AGENT_ID" \
+      --iteration "$ITERATION" \
+      --details "{\"agent_type\": \"$AGENT\", \"timeout\": $AGENT_TIMEOUT}" \
+      --level "INFO" 2>/dev/null || true
+
+    # Execute agent via Loop 3 skill in background
+    (
+      # Record start time
+      START_TIME=$(date +%s%N | cut -b1-13)
+
+      # Execute skill (BUG #20 FIX - inject detailed context)
+      if SKILL_RESULT=$(./.claude/skills/loop3-output-processing/execute-and-extract.sh \
+        --agent-type "$AGENT" \
+        --task-id "$TASK_ID" \
+        --agent-id "$UNIQUE_AGENT_ID" \
+        --context "$LOOP3_AGENT_CONTEXT" \
+        --iteration "$ITERATION" \
+        --timeout "$AGENT_TIMEOUT" 2>&1); then
+
+        # Record end time
+        END_TIME=$(date +%s%N | cut -b1-13)
+        LATENCY=$((END_TIME - START_TIME))
+
+        # Add latency to result
+        RESULT_WITH_LATENCY=$(echo "$SKILL_RESULT" | jq --arg latency "$LATENCY" '. + {latency_ms: ($latency | tonumber)}')
+
+        # Save to temp file
+        echo "$RESULT_WITH_LATENCY" > "$OUTPUT_FILE"
+
+        # Store result in Redis
+        echo "$RESULT_WITH_LATENCY" | redis-cli -x LPUSH "swarm:${TASK_ID}:${UNIQUE_AGENT_ID}:result" >/dev/null
+        redis-cli LPUSH "swarm:${TASK_ID}:${UNIQUE_AGENT_ID}:done" "complete" >/dev/null
+
+        exit 0
+      else
+        # Skill failed - save error
+        echo "{\"error\": true, \"output\": \"$SKILL_RESULT\"}" > "$OUTPUT_FILE"
+        exit 1
+      fi
+    ) &
+
+    AGENT_PIDS["$UNIQUE_AGENT_ID"]=$!
+    echo "  ✅ Spawned $UNIQUE_AGENT_ID (PID: ${AGENT_PIDS[$UNIQUE_AGENT_ID]})"
+  done
+
+  echo ""
+  echo "[Loop 3] All agents spawned, waiting for completion..."
+  echo ""
+
+  # Step 2b: Wait for all agents to complete
+  for i in "${!AGENTS[@]}"; do
+    AGENT="${AGENTS[$i]}"
+    UNIQUE_AGENT_ID="${AGENT_IDS[$i]}"
+    AGENT_PID="${AGENT_PIDS[$UNIQUE_AGENT_ID]}"
+    OUTPUT_FILE="${AGENT_OUTPUT_FILES[$UNIQUE_AGENT_ID]}"
+
+    echo "  Waiting for $UNIQUE_AGENT_ID (PID: $AGENT_PID)..."
+
+    # Wait for specific agent process
+    if wait "$AGENT_PID" 2>/dev/null; then
+      # Success - read result from temp file
+      if [ -f "$OUTPUT_FILE" ]; then
+        SKILL_RESULT=$(cat "$OUTPUT_FILE")
+
+        # Check if result has error flag
+        HAS_ERROR=$(echo "$SKILL_RESULT" | jq -r '.error // false')
+
+        if [ "$HAS_ERROR" = "false" ]; then
+          # Extract metrics
+          CONFIDENCE=$(echo "$SKILL_RESULT" | jq -r '.confidence')
+          FILES_CHANGED=$(echo "$SKILL_RESULT" | jq -r '.files_changed')
+          CONFIDENCE_SOURCE=$(echo "$SKILL_RESULT" | jq -r '.confidence_source')
+          LATENCY=$(echo "$SKILL_RESULT" | jq -r '.latency_ms')
+
+          echo "  ✅ $UNIQUE_AGENT_ID complete (${LATENCY}ms, confidence: $CONFIDENCE [$CONFIDENCE_SOURCE], files: $FILES_CHANGED)"
+
+          # BUGFIX #21: Store confidence in Redis for consensus collection
+          # The skill script extracts confidence but doesn't store it where invoke-waiting-mode.sh collect expects
+          ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+            --task-id "$TASK_ID" \
+            --agent-id "$UNIQUE_AGENT_ID" \
+            --confidence "$CONFIDENCE" \
+            --iteration "$ITERATION" >/dev/null
+
+          # LOG: Loop 3 agent completion
+          ./.claude/skills/redis-coordination/log-event.sh \
+            --task-id "$TASK_ID" \
+            --event-type "agent_complete" \
+            --loop "loop3" \
+            --agent-id "$UNIQUE_AGENT_ID" \
+            --iteration "$ITERATION" \
+            --details "{\"confidence\": $CONFIDENCE, \"confidence_source\": \"$CONFIDENCE_SOURCE\", \"files_changed\": $FILES_CHANGED, \"latency_ms\": $LATENCY}" \
+            --level "INFO" 2>/dev/null || true
+
+          # Store latency metric
+          METRIC=$(jq -nc \
+            --arg agent "$UNIQUE_AGENT_ID" \
+            --arg latency "$LATENCY" \
+            --arg loop "loop3" \
+            --arg iteration "$ITERATION" \
+            '{agent: $agent, latency_ms: ($latency | tonumber), loop: $loop, iteration: ($iteration | tonumber)}')
+          echo "$METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:agent_latency" >/dev/null
+
+          LOOP3_COMPLETED_AGENTS+=("$UNIQUE_AGENT_ID")
+        else
+          ERROR_OUTPUT=$(echo "$SKILL_RESULT" | jq -r '.output')
+          echo "  ❌ $UNIQUE_AGENT_ID failed (skill execution error)"
+          echo "     Error: $ERROR_OUTPUT"
+
+          # LOG: Loop 3 agent failure
+          ./.claude/skills/redis-coordination/log-event.sh \
+            --task-id "$TASK_ID" \
+            --event-type "agent_failure" \
+            --loop "loop3" \
+            --agent-id "$UNIQUE_AGENT_ID" \
+            --iteration "$ITERATION" \
+            --details "{\"error\": \"skill_execution_error\", \"output\": \"$ERROR_OUTPUT\"}" \
+            --level "ERROR" 2>/dev/null || true
+
+          LOOP3_FAILED_AGENTS+=("$AGENT")
+          redis-cli INCR "swarm:${TASK_ID}:metrics:agent_failure_count" >/dev/null
+        fi
+
+        # Cleanup temp file
+        rm -f "$OUTPUT_FILE"
+      else
+        echo "  ❌ $UNIQUE_AGENT_ID failed (no output file)"
+        LOOP3_FAILED_AGENTS+=("$AGENT")
+        redis-cli INCR "swarm:${TASK_ID}:metrics:agent_failure_count" >/dev/null
+      fi
+    else
+      echo "  ❌ $UNIQUE_AGENT_ID failed (process error)"
+      LOOP3_FAILED_AGENTS+=("$AGENT")
+      redis-cli INCR "swarm:${TASK_ID}:metrics:agent_failure_count" >/dev/null
+      rm -f "$OUTPUT_FILE"
+    fi
+
+    echo ""
+  done
+
+  # Validate quorum
+  if [ ${#LOOP3_COMPLETED_AGENTS[@]} -ge "$LOOP3_REQUIRED" ]; then
+    echo "[Loop 3] ✅ Quorum met: ${#LOOP3_COMPLETED_AGENTS[@]}/$LOOP3_REQUIRED agents completed"
+    if [ ${#LOOP3_FAILED_AGENTS[@]} -gt 0 ]; then
+      echo "[Loop 3] ⚠️ Failed agents (continuing with quorum): ${LOOP3_FAILED_AGENTS[*]}"
+
+      # METRICS: Increment quorum fallback counter
+      redis-cli INCR "swarm:${TASK_ID}:metrics:quorum_fallback" >/dev/null
+    fi
+  else
+    echo "[Loop 3] ❌ Quorum FAILED: ${#LOOP3_COMPLETED_AGENTS[@]} < $LOOP3_REQUIRED"
+    echo "[Loop 3] Failed agents: ${LOOP3_FAILED_AGENTS[*]}"
+    exit 1
+  fi
+  echo ""
+
+  # Step 2: Collect Loop 3 confidence scores (only from completed agents)
+  echo "[Loop 3] Collecting confidence scores from ${#LOOP3_COMPLETED_AGENTS[@]} agents..."
+  LOOP3_COMPLETED_IDS=$(IFS=','; echo "${LOOP3_COMPLETED_AGENTS[*]}")
+  LOOP3_CONSENSUS=$(./.claude/skills/redis-coordination/invoke-waiting-mode.sh collect \
+    --task-id "$TASK_ID" \
+    --agent-ids "$LOOP3_COMPLETED_IDS" | tail -1)
+
+  echo "[Loop 3] Average confidence: $LOOP3_CONSENSUS (from ${#LOOP3_COMPLETED_AGENTS[@]}/${LOOP3_TOTAL} agents)"
+
+  # METRICS: Store Loop 3 consensus score
+  LOOP3_METRIC=$(jq -nc \
+    --arg consensus "$LOOP3_CONSENSUS" \
+    --arg iteration "$ITERATION" \
+    '{consensus: ($consensus | tonumber), iteration: ($iteration | tonumber)}')
+  echo "$LOOP3_METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:loop3_consensus" >/dev/null
+
+  # BUG #12 FIX: Deliverable Verification with explicit file checking
+  echo "[Deliverable Check] Verifying implementation artifacts..."
+
+  # Use enhanced validate-deliverables.sh skill
+  DELIVERABLE_ARGS="--task-id $TASK_ID"
+  if [ -n "$EXPECTED_FILES" ]; then
+    DELIVERABLE_ARGS="$DELIVERABLE_ARGS --expected-files $EXPECTED_FILES"
+    echo "  Expected files: $EXPECTED_FILES"
+  fi
+
+  DELIVERABLE_STATUS=$(./.claude/skills/product-owner-decision/validate-deliverables.sh $DELIVERABLE_ARGS)
+
+  if [ "$DELIVERABLE_STATUS" = "FAILED" ]; then
+    # Retrieve missing files from Redis (if available)
+    MISSING_FILES_JSON=$(redis-cli get "swarm:${TASK_ID}:missing-files" 2>/dev/null || echo "[]")
+    MISSING_FILES_LIST=$(echo "$MISSING_FILES_JSON" | jq -r '.[]' | tr '\n' ', ' | sed 's/,$//')
+
+    if [ -n "$MISSING_FILES_LIST" ]; then
+      echo "❌ DELIVERABLE VERIFICATION FAILED: Missing files"
+      echo "   Expected but not found: $MISSING_FILES_LIST"
+    else
+      echo "❌ DELIVERABLE VERIFICATION FAILED: No files created or modified"
+    fi
+
+    echo "   This prevents 'consensus on vapor' - validators approving nothing"
+    echo ""
+    echo "Decision: RELAUNCH iteration $((ITERATION + 1)) (skip Loop 2 validation)"
+    echo ""
+
+    # METRICS: Increment deliverable failure counter
+    redis-cli INCR "swarm:${TASK_ID}:metrics:deliverable_failures" >/dev/null
+
+    # Override all Loop 3 confidence scores to 0.0 (prevent gate pass)
+    for AGENT in "${LOOP3_COMPLETED_AGENTS[@]}"; do
+      redis-cli DEL "swarm:${TASK_ID}:${AGENT}:result" >/dev/null
+      redis-cli LPUSH "swarm:${TASK_ID}:${AGENT}:result" "0.0" >/dev/null
+      echo "  [Override] ${AGENT} confidence: 1.0 → 0.0 (no deliverables)"
+    done
+
+    # Recalculate consensus (should be 0.0 now)
+    LOOP3_CONSENSUS=$(./.claude/skills/redis-coordination/invoke-waiting-mode.sh collect \
+      --task-id "$TASK_ID" \
+      --agent-ids "$LOOP3_COMPLETED_IDS" | tail -1)
+
+    echo ""
+    echo "[Loop 3] Recalculated confidence after override: $LOOP3_CONSENSUS"
+    echo ""
+
+    # Build specific feedback with missing files
+    if [ -n "$MISSING_FILES_LIST" ]; then
+      FEEDBACK="CRITICAL: Create these missing files: $MISSING_FILES_LIST
+
+Use the Write tool for each file. Verify with 'ls -la' after each Write operation."
+    else
+      FEEDBACK="CRITICAL: You must create or modify files. No deliverables were produced in iteration $ITERATION."
+    fi
+
+    # BUGFIX #22: Store feedback in Redis for next iteration (agents will be re-spawned, not woken)
+    # Per P3 agent lifecycle: agents exit cleanly, orchestrator spawns fresh agents
+    FEEDBACK_KEY="swarm:${TASK_ID}:iteration:$((ITERATION + 1)):feedback"
+    echo "$FEEDBACK" | redis-cli -x SET "$FEEDBACK_KEY" EX 86400 >/dev/null
+    echo "[Coordinator] ✅ Feedback stored for iteration $((ITERATION + 1))"
+    echo "  Reason: no_deliverables"
+    echo "  Priority: 40 (HIGH)"
+
+    continue  # Next iteration (skip gate check and Loop 2)
+  fi
+
+  echo "[Deliverable Check] ✅ Deliverables verified - proceeding to gate check"
+  echo ""
+
+  # Gate check
+  if (( $(echo "$LOOP3_CONSENSUS < $GATE" | bc -l) )); then
+    echo "❌ Gate FAILED ($LOOP3_CONSENSUS < $GATE)"
+    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
+
+    # LOG: Gate check failure
+    ./.claude/skills/redis-coordination/log-event.sh \
+      --task-id "$TASK_ID" \
+      --event-type "gate_check" \
+      --iteration "$ITERATION" \
+      --details "{\"consensus\": $LOOP3_CONSENSUS, \"threshold\": $GATE, \"result\": \"FAIL\", \"decision\": \"RELAUNCH\"}" \
+      --level "WARN" 2>/dev/null || true
+
+    # METRICS: Increment gate failure counter
+    redis-cli INCR "swarm:${TASK_ID}:metrics:gate_failures" >/dev/null
+
+    # BUGFIX #22: Store feedback in Redis for next iteration (agents will be re-spawned, not woken)
+    # Per P3 agent lifecycle: agents exit cleanly, orchestrator spawns fresh agents
+    FEEDBACK_KEY="swarm:${TASK_ID}:iteration:$((ITERATION + 1)):feedback"
+    FEEDBACK_MSG="Improve confidence from $LOOP3_CONSENSUS to >$GATE"
+    echo "$FEEDBACK_MSG" | redis-cli -x SET "$FEEDBACK_KEY" EX 86400 >/dev/null
+    echo "[Coordinator] ✅ Feedback stored for iteration $((ITERATION + 1))"
+    echo "  Reason: gate_failed"
+    echo "  Priority: 30 (MEDIUM)"
+
+    continue  # Next iteration
+  fi
+
+  echo "✅ Gate PASSED ($LOOP3_CONSENSUS >= $GATE)"
+
+  # LOG: Gate check success
+  ./.claude/skills/redis-coordination/log-event.sh \
+    --task-id "$TASK_ID" \
+    --event-type "gate_check" \
+    --iteration "$ITERATION" \
+    --details "{\"consensus\": $LOOP3_CONSENSUS, \"threshold\": $GATE, \"result\": \"PASS\"}" \
+    --level "INFO" 2>/dev/null || true
+
+  echo ""
+
+  # Signal Loop 2 validators that gate has passed (they can start work)
+  GATE_PASS_KEY="swarm:${TASK_ID}:gate-passed"
+  redis-cli lpush "$GATE_PASS_KEY" "{\"iteration\": $ITERATION, \"loop3_confidence\": $LOOP3_CONSENSUS}" > /dev/null
+  echo "[Loop 3] Gate pass signal sent to Loop 2 validators"
+  echo ""
+
+  # Step 3: Build Loop 2 validator context (BUG #20 FIX - inject same deliverables)
+  LOOP2_VALIDATOR_CONTEXT="Loop 2 validation for iteration $ITERATION
+
+Review Loop 3 implementation against these requirements:
+
+Epic Goal: $EPIC_GOAL
+
+Expected Deliverables:
+$DELIVERABLES
+$([ -n "$DIRECTORY" ] && echo "
+Target Directory: $DIRECTORY")
+
+Acceptance Criteria:
+$ACCEPTANCE
+
+Your Validation Tasks:
+- Verify all deliverable files exist in correct directory
+- Check files contain actual implementation (not placeholders)
+- Validate against acceptance criteria
+- Provide structured feedback (critical/warnings/suggestions)
+- Report confidence score based on deliverable completeness
+"
+
+  echo "[Loop 2] Validator context built"
+  echo ""
+
+  # Step 4: Spawn Loop 2 validators using skill-based output processing (parallel execution)
+  echo "[Loop 2] Using skill-based output processing (parallel execution)"
+  IFS=',' read -ra VALIDATORS <<< "$LOOP2_AGENTS"
+
+  # Track instance counts to generate unique validator IDs for duplicate validator types
+  declare -A VALIDATOR_INSTANCE_COUNTS
+  declare -A VALIDATOR_IDS  # Map from array index to unique validator ID
+
+  # Pre-calculate unique validator IDs
+  for i in "${!VALIDATORS[@]}"; do
+    VALIDATOR="${VALIDATORS[$i]}"
+
+    # Increment instance counter for this validator type
+    VALIDATOR_INSTANCE_COUNTS["$VALIDATOR"]=$((${VALIDATOR_INSTANCE_COUNTS["$VALIDATOR"]:-0} + 1))
+    INSTANCE_NUM="${VALIDATOR_INSTANCE_COUNTS["$VALIDATOR"]}"
+
+    # Generate unique validator ID: validator-type-iteration-instance
+    UNIQUE_VALIDATOR_ID="${VALIDATOR}-${ITERATION}-${INSTANCE_NUM}"
+    VALIDATOR_IDS["$i"]="$UNIQUE_VALIDATOR_ID"
+
+    echo "  [Instance Tracking] ${VALIDATOR} #${INSTANCE_NUM} → ${UNIQUE_VALIDATOR_ID}"
+  done
+
+  echo ""
+
+  # Step 3a: Spawn all validators in parallel using skill
+  echo "[Loop 2] Spawning validators in parallel..."
+  declare -A VALIDATOR_PIDS  # Map from validator ID to background PID
+  declare -A VALIDATOR_OUTPUT_FILES  # Map from validator ID to temp output file
+
+  LOOP2_TOTAL=${#VALIDATORS[@]}
+  LOOP2_REQUIRED=$(calculate_quorum "$MIN_QUORUM_LOOP2" "$LOOP2_TOTAL")
+
+  echo "[Loop 2] Quorum: $LOOP2_REQUIRED/$LOOP2_TOTAL validators required"
+  echo ""
+
+  for i in "${!VALIDATORS[@]}"; do
+    VALIDATOR="${VALIDATORS[$i]}"
+    UNIQUE_VALIDATOR_ID="${VALIDATOR_IDS[$i]}"
+
+    # Get agent-specific timeout (use base validator type, not unique ID)
+    AGENT_TIMEOUT=$(get_agent_timeout "$VALIDATOR" "$TASK_ID")
+
+    # Create temp output file for this validator
+    OUTPUT_FILE="/tmp/loop2-${TASK_ID}-${UNIQUE_VALIDATOR_ID}.json"
+    VALIDATOR_OUTPUT_FILES["$UNIQUE_VALIDATOR_ID"]="$OUTPUT_FILE"
+
+    echo "  Spawning: $VALIDATOR (ID: $UNIQUE_VALIDATOR_ID, timeout: ${AGENT_TIMEOUT}s)"
+
+    # Execute skill in background - captures agent output and extracts structured data
+    (
+      # METRICS: Agent latency start
+      AGENT_START=$(date +%s%N | cut -b1-13)
+
+      # Execute skill to spawn validator and extract feedback (BUG #20 FIX - inject detailed context)
+      SKILL_RESULT=$(./.claude/skills/loop2-output-processing/execute-and-extract.sh \
+        --agent-type "$VALIDATOR" \
+        --task-id "$TASK_ID" \
+        --agent-id "$UNIQUE_VALIDATOR_ID" \
+        --context "$LOOP2_VALIDATOR_CONTEXT" \
+        --iteration "$ITERATION" \
+        --timeout "$AGENT_TIMEOUT" 2>&1)
+
+      # METRICS: Agent latency end
+      AGENT_END=$(date +%s%N | cut -b1-13)
+      LATENCY=$((AGENT_END - AGENT_START))
+
+      # Inject latency into result JSON
+      SKILL_RESULT_WITH_LATENCY=$(echo "$SKILL_RESULT" | jq --arg latency "$LATENCY" '. + {latency_ms: ($latency | tonumber)}')
+
+      # Write result to temp file
+      echo "$SKILL_RESULT_WITH_LATENCY" > "$OUTPUT_FILE"
+
+      # Also push to Redis for compatibility with existing tools
+      echo "$SKILL_RESULT_WITH_LATENCY" | redis-cli -x LPUSH "swarm:${TASK_ID}:${UNIQUE_VALIDATOR_ID}:result" >/dev/null
+
+      # Signal completion
+      redis-cli LPUSH "swarm:${TASK_ID}:${UNIQUE_VALIDATOR_ID}:done" "complete" >/dev/null
+    ) &
+
+    # Track background PID
+    VALIDATOR_PIDS["$UNIQUE_VALIDATOR_ID"]=$!
+    echo "  ✅ Spawned $UNIQUE_VALIDATOR_ID (PID: ${VALIDATOR_PIDS[$UNIQUE_VALIDATOR_ID]})"
+  done
+
+  echo ""
+  echo "[Loop 2] All validators spawned, waiting for completion..."
+  echo ""
+
+  # Step 3b: Wait for all validators to complete and collect results
+  LOOP2_COMPLETED_AGENTS=()
+  LOOP2_FAILED_AGENTS=()
+  declare -A LOOP2_CONFIDENCES  # Map from validator ID to confidence score
+
+  for i in "${!VALIDATORS[@]}"; do
+    VALIDATOR="${VALIDATORS[$i]}"
+    UNIQUE_VALIDATOR_ID="${VALIDATOR_IDS[$i]}"
+    VALIDATOR_PID="${VALIDATOR_PIDS[$UNIQUE_VALIDATOR_ID]}"
+    OUTPUT_FILE="${VALIDATOR_OUTPUT_FILES[$UNIQUE_VALIDATOR_ID]}"
+
+    echo "  Waiting for $UNIQUE_VALIDATOR_ID (PID: $VALIDATOR_PID)..."
+
+    # Wait for background process to complete
+    if wait "$VALIDATOR_PID" 2>/dev/null; then
+      # Process completed successfully, read result from temp file
+      if [ -f "$OUTPUT_FILE" ] && [ -s "$OUTPUT_FILE" ]; then
+        SKILL_RESULT=$(cat "$OUTPUT_FILE")
+
+        # Validate JSON structure
+        if echo "$SKILL_RESULT" | jq empty 2>/dev/null; then
+          # Extract confidence score
+          CONFIDENCE=$(echo "$SKILL_RESULT" | jq -r '.confidence // 0.0')
+          CONFIDENCE_SOURCE=$(echo "$SKILL_RESULT" | jq -r '.confidence_source // "unknown"')
+          FEEDBACK=$(echo "$SKILL_RESULT" | jq -r '.feedback // {}')
+          LATENCY=$(echo "$SKILL_RESULT" | jq -r '.latency_ms // 0')
+
+          # Store confidence for consensus calculation
+          LOOP2_CONFIDENCES["$UNIQUE_VALIDATOR_ID"]="$CONFIDENCE"
+
+          # Store latency metric
+          METRIC=$(jq -nc \
+            --arg agent "$UNIQUE_VALIDATOR_ID" \
+            --arg latency "$LATENCY" \
+            --arg loop "loop2" \
+            --arg iteration "$ITERATION" \
+            '{agent: $agent, latency_ms: ($latency | tonumber), loop: $loop, iteration: ($iteration | tonumber)}')
+          echo "$METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:agent_latency" >/dev/null
+
+          # Count feedback items
+          CRITICAL_COUNT=$(echo "$FEEDBACK" | jq -r '.critical | length')
+          WARNINGS_COUNT=$(echo "$FEEDBACK" | jq -r '.warnings | length')
+          SUGGESTIONS_COUNT=$(echo "$FEEDBACK" | jq -r '.suggestions | length')
+
+          echo "  ✅ $UNIQUE_VALIDATOR_ID complete (${LATENCY}ms, confidence: $CONFIDENCE [$CONFIDENCE_SOURCE], feedback: ${CRITICAL_COUNT}C/${WARNINGS_COUNT}W/${SUGGESTIONS_COUNT}S)"
+
+          LOOP2_COMPLETED_AGENTS+=("$UNIQUE_VALIDATOR_ID")
+        else
+          echo "  ⚠️  $UNIQUE_VALIDATOR_ID returned invalid JSON, treating as failed"
+          LOOP2_FAILED_AGENTS+=("$VALIDATOR")
+
+          # METRICS: Increment timeout counter
+          redis-cli INCR "swarm:${TASK_ID}:metrics:timeout_count" >/dev/null
+        fi
+      else
+        echo "  ⚠️  $UNIQUE_VALIDATOR_ID completed but no output file found"
+        LOOP2_FAILED_AGENTS+=("$VALIDATOR")
+
+        # METRICS: Increment timeout counter
+        redis-cli INCR "swarm:${TASK_ID}:metrics:timeout_count" >/dev/null
+      fi
+    else
+      echo "  ❌ $UNIQUE_VALIDATOR_ID failed (process exited with error)"
+      LOOP2_FAILED_AGENTS+=("$VALIDATOR")
+
+      # METRICS: Increment timeout counter
+      redis-cli INCR "swarm:${TASK_ID}:metrics:timeout_count" >/dev/null
+    fi
+
+    # Cleanup temp file
+    rm -f "$OUTPUT_FILE"
+  done
+
+  echo ""
+
+  # Validate quorum
+  if [ ${#LOOP2_COMPLETED_AGENTS[@]} -ge "$LOOP2_REQUIRED" ]; then
+    echo "[Loop 2] ✅ Quorum met: ${#LOOP2_COMPLETED_AGENTS[@]}/$LOOP2_REQUIRED validators completed"
+    if [ ${#LOOP2_FAILED_AGENTS[@]} -gt 0 ]; then
+      echo "[Loop 2] ⚠️ Failed validators (continuing with quorum): ${LOOP2_FAILED_AGENTS[*]}"
+
+      # METRICS: Increment quorum fallback counter
+      redis-cli INCR "swarm:${TASK_ID}:metrics:quorum_fallback" >/dev/null
+    fi
+  else
+    echo "[Loop 2] ❌ Quorum FAILED: ${#LOOP2_COMPLETED_AGENTS[@]} < $LOOP2_REQUIRED"
+    echo "[Loop 2] Failed validators: ${LOOP2_FAILED_AGENTS[*]}"
+    exit 1
+  fi
+  echo ""
+
+  # Step 3c: Calculate Loop 2 consensus from extracted confidence scores
+  echo "[Loop 2] Calculating consensus from ${#LOOP2_COMPLETED_AGENTS[@]} validators..."
+
+  # Calculate average confidence from completed validators
+  LOOP2_TOTAL_CONFIDENCE=0
+  LOOP2_CONFIDENCE_COUNT=0
+
+  for VALIDATOR_ID in "${LOOP2_COMPLETED_AGENTS[@]}"; do
+    CONFIDENCE="${LOOP2_CONFIDENCES[$VALIDATOR_ID]}"
+    if [ -n "$CONFIDENCE" ] && [ "$CONFIDENCE" != "null" ]; then
+      LOOP2_TOTAL_CONFIDENCE=$(echo "$LOOP2_TOTAL_CONFIDENCE + $CONFIDENCE" | bc -l)
+      LOOP2_CONFIDENCE_COUNT=$((LOOP2_CONFIDENCE_COUNT + 1))
+    fi
+  done
+
+  if [ "$LOOP2_CONFIDENCE_COUNT" -gt 0 ]; then
+    LOOP2_CONSENSUS=$(echo "scale=2; $LOOP2_TOTAL_CONFIDENCE / $LOOP2_CONFIDENCE_COUNT" | bc -l)
+  else
+    echo "⚠️  No valid confidence scores found, defaulting to 0.0"
+    LOOP2_CONSENSUS=0.0
+  fi
+
+  echo "[Loop 2] Average consensus: $LOOP2_CONSENSUS (from ${LOOP2_CONFIDENCE_COUNT} validators)"
+
+  # METRICS: Store Loop 2 consensus score
+  LOOP2_METRIC=$(jq -nc \
+    --arg consensus "$LOOP2_CONSENSUS" \
+    --arg iteration "$ITERATION" \
+    '{consensus: ($consensus | tonumber), iteration: ($iteration | tonumber)}')
+  echo "$LOOP2_METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:loop2_consensus" >/dev/null
+
+  # Display consensus status
+  echo ""
+  if (( $(echo "$LOOP2_CONSENSUS >= $CONSENSUS" | bc -l) )); then
+    echo "✅ CONSENSUS REACHED ($LOOP2_CONSENSUS >= $CONSENSUS)"
+  else
+    echo "⚠️ CONSENSUS NOT REACHED ($LOOP2_CONSENSUS < $CONSENSUS)"
+  fi
+  echo ""
+
+  # [BUG #11 FIX] Product Owner decision via output parsing (not Redis wait)
+  echo "[Product Owner] Spawning Product Owner for strategic decision..."
+
+  # BUG #19 FIX: Define PO_UNIQUE_ID BEFORE building context string
+  PO_UNIQUE_ID="${PRODUCT_OWNER}-${ITERATION}-decision"
+
+  # Build Product Owner context
+  PO_CONTEXT="CFN Loop iteration $ITERATION complete.
+
+Loop 2 Consensus: $LOOP2_CONSENSUS (threshold: $CONSENSUS)
+Task ID: $TASK_ID
+Agent ID: $PO_UNIQUE_ID
+
+Make your strategic decision: PROCEED, ITERATE, or ABORT
+
+Decision Framework:
+- PROCEED: Consensus >= $CONSENSUS AND deliverables verified
+- ITERATE: Consensus < $CONSENSUS AND iteration < $MAX_ITERATIONS
+- ABORT: Max iterations reached without consensus
+
+Output your decision clearly with reasoning."
+
+  # Spawn Product Owner and capture output
+  PO_TIMEOUT=$(get_agent_timeout "$PRODUCT_OWNER" "$TASK_ID")
+  echo "[Product Owner] Spawning with timeout: ${PO_TIMEOUT}s"
+
+  PO_OUTPUT=$(timeout "$PO_TIMEOUT" npx claude-flow-novice agent "$PRODUCT_OWNER" \
+    --task-id "$TASK_ID" \
+    --agent-id "$PO_UNIQUE_ID" \
+    --context "$PO_CONTEXT" 2>&1 || true)
+
+  # Parse structured decision JSON from Redis (created by execute-product-owner-decision.sh)
+  echo "[Product Owner] Retrieving structured decision from Redis..."
+  DECISION=$(redis-cli lindex "swarm:${TASK_ID}:${PO_UNIQUE_ID}:decision" 0)
+
+  if [ -z "$DECISION" ] || [ "$DECISION" = "(nil)" ]; then
+    echo "❌ ERROR: Could not retrieve Product Owner decision from Redis"
+    echo "Expected key: swarm:${TASK_ID}:${PO_UNIQUE_ID}:decision"
+    echo "Product Owner output:"
+    echo "$PO_OUTPUT"
+    exit 1
+  fi
+
+  # Extract fields from structured JSON
+  DECISION_TYPE=$(echo "$DECISION" | jq -r '.decision')
+  DECISION_REASONING=$(echo "$DECISION" | jq -r '.reasoning')
+  DECISION_CONFIDENCE=$(echo "$DECISION" | jq -r '.confidence')
+  IN_SCOPE_CONSENSUS=$(echo "$DECISION" | jq -r '.scope_analysis.in_scope_consensus // 0')
+  BACKLOG_COUNT=$(echo "$DECISION" | jq -r '.backlog_items | length')
+
+  if [ -z "$DECISION_TYPE" ] || [ "$DECISION_TYPE" = "null" ]; then
+    echo "❌ ERROR: Invalid Product Owner decision JSON"
+    echo "Received: $DECISION"
+    exit 1
+  fi
+
+  echo "  Decision Type: $DECISION_TYPE"
+  echo "  Confidence: $DECISION_CONFIDENCE"
+  echo "  In-Scope Consensus: $IN_SCOPE_CONSENSUS"
+  echo "  Backlog Items: $BACKLOG_COUNT"
+  echo ""
+
+  # LOG: Product Owner decision
+  ./.claude/skills/redis-coordination/log-event.sh \
+    --task-id "$TASK_ID" \
+    --event-type "po_decision" \
+    --agent-id "$PO_UNIQUE_ID" \
+    --iteration "$ITERATION" \
+    --details "$DECISION" \
+    --level "INFO" 2>/dev/null || true
+
+  echo "[Product Owner] Decision: $DECISION_TYPE"
+  echo ""
+
+  # Handle Product Owner decision
+  if [ "$DECISION_TYPE" = "PROCEED" ] || [ "$DECISION_TYPE" = "DEFER_AND_PROCEED" ]; then
+    # Handle backlog items if DEFER_AND_PROCEED
+    if [ "$DECISION_TYPE" = "DEFER_AND_PROCEED" ]; then
+      echo "📋 Product Owner Decision: DEFER_AND_PROCEED"
+      echo "   In-scope work complete (consensus: $IN_SCOPE_CONSENSUS)"
+      echo "   Deferred $BACKLOG_COUNT out-of-scope items to backlog"
+      echo ""
+    fi
+
+    # DELIVERABLE VERIFICATION (Sprint 8 - prevent "consensus on vapor")
+    echo "[Deliverable Verification] Checking success criteria..."
+
+    SUCCESS_CRITERIA_RAW=$(redis-cli GET "swarm:${TASK_ID}:success-criteria" 2>/dev/null)
+    if [ -n "$SUCCESS_CRITERIA_RAW" ]; then
+      # Check if task description includes file/deliverable keywords
+      TASK_DESC=$(redis-cli GET "swarm:${TASK_ID}:task" 2>/dev/null)
+
+      if echo "$TASK_DESC" | grep -qiE "create|build|implement|generate|file|component|module|test"; then
+        echo "[Deliverable Verification] Task involves implementation - checking for file changes..."
+
+        # Count modified/created files since orchestrator started
+        FILES_CREATED=$(git status --short 2>/dev/null | grep -E "^(A|M|\\?\\?)" | wc -l)
+
+        if [ "$FILES_CREATED" -eq 0 ]; then
+          echo "⚠️ DELIVERABLE VERIFICATION FAILED"
+          echo "   Task requires implementation but no files were created/modified"
+          echo "   Consensus reached on plans without actual deliverables"
+          echo ""
+          echo "   Options:"
+          echo "   1. Force ITERATE to create actual implementation"
+          echo "   2. Override verification (--skip-deliverable-check flag)"
+          echo "   3. Manual intervention to verify work was done"
+          echo ""
+          echo "   Recommendation: Force ITERATE with explicit deliverable requirement"
+
+          # Store verification failure
+          redis-cli SET "swarm:${TASK_ID}:deliverable_verification" "failed" EX 86400 >/dev/null
+
+          # Optional: Force ITERATE (commented for now - requires flag)
+          # echo "[Forced Override] Changing PROCEED → ITERATE due to missing deliverables"
+          # DECISION_TYPE="ITERATE"
+          # DECISION_REASONING="No deliverables created despite implementation task"
+        else
+          echo "✅ Deliverable verification passed ($FILES_CREATED files created/modified)"
+          redis-cli SET "swarm:${TASK_ID}:deliverable_verification" "passed:$FILES_CREATED" EX 86400 >/dev/null
+        fi
+      else
+        echo "[Deliverable Verification] Task is analysis/planning - skipping file check"
+      fi
+    fi
+
+    echo "🎉 CFN Loop Complete (Product Owner: PROCEED)"
+    echo "Final Consensus: $LOOP2_CONSENSUS (Iteration $ITERATION)"
+
+    # METRICS: Iteration end timestamp and duration
+    ITERATION_END=$(date +%s%N | cut -b1-13)
+    ITERATION_DURATION=$((ITERATION_END - ITERATION_START))
+
+    # Store final iteration duration metric
+    DURATION_METRIC=$(jq -nc \
+      --arg duration "$ITERATION_DURATION" \
+      --arg iteration "$ITERATION" \
+      '{duration_ms: ($duration | tonumber), iteration: ($iteration | tonumber)}')
+    echo "$DURATION_METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:iteration_duration" >/dev/null
+
+    # BUGFIX #22: Agents have already exited (P3 clean-exit pattern), no wake needed
+    # The task is complete, agents were already cleaned up when they reported confidence
+    echo "[Coordinator] Task complete (PROCEED decision)"
+    echo "  All agents have already exited cleanly per P3 lifecycle"
+
+    # Use general complete-swarm primitive
+    ./.claude/skills/redis-coordination/complete-swarm.sh \
+      --swarm-id "$SWARM_ID" \
+      --final-metric "final_consensus=$LOOP2_CONSENSUS" \
+      --final-metric "total_iterations=$ITERATION" > /dev/null
+
+    exit 0
+
+  elif [ "$DECISION_TYPE" = "ITERATE" ]; then
+    echo "⚠️ Product Owner Decision: ITERATE (improve quality)"
+
+    # METRICS: Iteration end timestamp and duration
+    ITERATION_END=$(date +%s%N | cut -b1-13)
+    ITERATION_DURATION=$((ITERATION_END - ITERATION_START))
+
+    # Store iteration duration metric
+    DURATION_METRIC=$(jq -nc \
+      --arg duration "$ITERATION_DURATION" \
+      --arg iteration "$ITERATION" \
+      '{duration_ms: ($duration | tonumber), iteration: ($iteration | tonumber)}')
+    echo "$DURATION_METRIC" | redis-cli -x LPUSH "swarm:${TASK_ID}:metrics:iteration_duration" >/dev/null
+
+    # Check max iterations
+    if [ $ITERATION -eq $MAX_ITERATIONS ]; then
+      echo "❌ Maximum iterations ($MAX_ITERATIONS) reached - cannot iterate further"
+      echo "   Product Owner wanted ITERATE but max iterations exhausted"
+      exit 1
+    fi
+
+    # BUGFIX #22: Store feedback in Redis for next iteration (agents will be re-spawned, not woken)
+    # Per P3 agent lifecycle: agents exit cleanly, orchestrator spawns fresh agents for next iteration
+    echo "[Coordinator] Storing feedback for iteration $((ITERATION + 1))..."
+
+    FEEDBACK_KEY="swarm:${TASK_ID}:iteration:$((ITERATION + 1)):feedback"
+    FEEDBACK_MSG="Product Owner decision: ITERATE - Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
+    echo "$FEEDBACK_MSG" | redis-cli -x SET "$FEEDBACK_KEY" EX 86400 >/dev/null
+
+    echo "  ✅ Feedback stored for iteration $((ITERATION + 1))"
+    echo "  Reason: cfn_loop_iteration (Product Owner ITERATE decision)"
+    echo "  Priority: 30 (MEDIUM - Loop 3), 10 (HIGH - Loop 2)"
+    echo ""
+
+  elif [ "$DECISION_TYPE" = "ABORT" ]; then
+    echo "❌ Product Owner Decision: ABORT (scope too large or out of scope)"
+    echo "   Consensus: $LOOP2_CONSENSUS, Iteration: $ITERATION"
+    exit 1
+
+  else
+    echo "❌ ERROR: Unknown Product Owner decision: $DECISION_TYPE"
+    echo "   Expected: PROCEED, DEFER_AND_PROCEED, ITERATE, or ABORT"
+    exit 1
+  fi
+done
+
+echo "❌ CFN Loop failed after $MAX_ITERATIONS iterations"
+exit 1