claude-flow-novice 2.8.1 → 2.9.1

package/.claude/skills/cfn-loop-orchestration/orchestrate.sh

@@ -1,840 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Orchestration - Main Coordinator
-# Version: 1.1.0 (Security Enhanced)
-#
-# Orchestrates the Complete Fail Never (CFN) Loop workflow using modular
-# helper scripts, Redis Coordination primitives, and enhanced security.
-#
-# Usage:
-#   ./orchestrate.sh --task-id <id> \
-#                    --mode <mvp|standard|enterprise> \
-#                    --loop3-agents <agent1,agent2,...> \
-#                    --loop2-agents <agent1,agent2,...> \
-#                    --product-owner <agent-id> \
-#                    [--max-iterations <n>] \
-#                    [--epic-context <json>] \
-#                    [--phase-context <json>] \
-#                    [--success-criteria <json>]
-##############################################################################
-
-set -euo pipefail
-
-# Load security utilities
-# shellcheck source=./security_utils.sh
-source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/security_utils.sh"
-
-# Determine script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HELPERS_DIR="$SCRIPT_DIR/helpers"
-REDIS_COORD_SKILL="$(cd "$SCRIPT_DIR/../redis-coordination" && pwd)"
-
-# Configuration
-TASK_ID=""
-MODE="standard"
-LOOP3_AGENTS=""
-LOOP2_AGENTS=""
-PRODUCT_OWNER=""
-MAX_ITERATIONS=10
-MIN_QUORUM_LOOP3="0.66"
-MIN_QUORUM_LOOP2="0.66"
-EPIC_CONTEXT=""
-PHASE_CONTEXT=""
-SUCCESS_CRITERIA=""
-EXPECTED_FILES=""
-PHASE_ID=""
-
-# Mode-specific thresholds
-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
-)
-
-# Execution tracking
-START_TIME=$(date +%s)
-ITERATIONS_COMPLETED=0
-FINAL_DECISION=""
-LOOP3_FINAL_CONFIDENCE=0.0
-LOOP2_FINAL_CONSENSUS=0.0
-DELIVERABLES_VERIFIED=false
-
-##############################################################################
-# Argument Parsing
-##############################################################################
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --task-id requires a value"
-        exit 1
-      fi
-      TASK_ID=$(sanitize_input "$2") || { echo "Invalid task ID"; exit 1; }
-      shift 2
-      ;;
-    --mode)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --mode requires a value"
-        exit 1
-      fi
-      MODE="$2"
-      # Whitelist allowed modes
-      if [[ ! "$MODE" =~ ^(mvp|standard|enterprise)$ ]]; then
-        echo "Invalid mode. Must be mvp, standard, or enterprise."
-        exit 1
-      fi
-      shift 2
-      ;;
-    --loop3-agents)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --loop3-agents requires a value"
-        exit 1
-      fi
-      validate_agent_list "$2" || { echo "Invalid Loop 3 agent list"; exit 1; }
-      LOOP3_AGENTS="$2"
-      shift 2
-      ;;
-    --loop2-agents)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --loop2-agents requires a value"
-        exit 1
-      fi
-      validate_agent_list "$2" || { echo "Invalid Loop 2 agent list"; exit 1; }
-      LOOP2_AGENTS="$2"
-      shift 2
-      ;;
-    --product-owner)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --product-owner requires a value"
-        exit 1
-      fi
-      PRODUCT_OWNER=$(sanitize_input "$2") || { echo "Invalid product owner"; exit 1; }
-      shift 2
-      ;;
-    --max-iterations)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --max-iterations requires a value"
-        exit 1
-      fi
-      # Validate max iterations is a positive integer
-      if [[ ! "$2" =~ ^[1-9][0-9]*$ ]]; then
-        echo "Max iterations must be a positive integer"
-        exit 1
-      fi
-      MAX_ITERATIONS="$2"
-      shift 2
-      ;;
-    --min-quorum-loop3)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --min-quorum-loop3 requires a value"
-        exit 1
-      fi
-      # Validate quorum is a valid decimal between 0 and 1
-      if [[ ! "$2" =~ ^0\.[0-9]+$ ]] || (( $(echo "$2 > 1" | bc -l) )); then
-        echo "Invalid Loop 3 quorum. Must be between 0 and 1."
-        exit 1
-      fi
-      MIN_QUORUM_LOOP3="$2"
-      shift 2
-      ;;
-    --min-quorum-loop2)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --min-quorum-loop2 requires a value"
-        exit 1
-      fi
-      # Validate quorum is a valid decimal between 0 and 1
-      if [[ ! "$2" =~ ^0\.[0-9]+$ ]] || (( $(echo "$2 > 1" | bc -l) )); then
-        echo "Invalid Loop 2 quorum. Must be between 0 and 1."
-        exit 1
-      fi
-      MIN_QUORUM_LOOP2="$2"
-      shift 2
-      ;;
-    --epic-context)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --epic-context requires a value"
-        exit 1
-      fi
-      validate_json_context "$2" || { echo "Invalid epic context JSON"; exit 1; }
-      EPIC_CONTEXT="$2"
-      shift 2
-      ;;
-    --phase-context)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --phase-context requires a value"
-        exit 1
-      fi
-      validate_json_context "$2" || { echo "Invalid phase context JSON"; exit 1; }
-      PHASE_CONTEXT="$2"
-      shift 2
-      ;;
-    --success-criteria)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --success-criteria requires a value"
-        exit 1
-      fi
-      validate_json_context "$2" || { echo "Invalid success criteria JSON"; exit 1; }
-      SUCCESS_CRITERIA="$2"
-      shift 2
-      ;;
-    --expected-files)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --expected-files requires a value"
-        exit 1
-      fi
-      # Optional: validate each expected file name if not empty
-      if [ -n "$2" ]; then
-        IFS=',' read -ra FILES <<< "$2"
-        for file in "${FILES[@]}"; do
-          sanitize_input "$file" 256 || { echo "Invalid expected filename: $file"; exit 1; }
-        done
-      fi
-      EXPECTED_FILES="$2"
-      shift 2
-      ;;
-    --phase-id)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --phase-id requires a value"
-        exit 1
-      fi
-      PHASE_ID=$(sanitize_input "$2") || { echo "Invalid phase ID"; exit 1; }
-      shift 2
-      ;;
-    *)
-      echo "Error: Unknown option: '$1'"
-      echo ""
-      echo "Usage: $0 [OPTIONS]"
-      echo ""
-      echo "Required options:"
-      echo "  --task-id <id>              Unique task identifier"
-      echo "  --loop3-agents <agents>     Comma-separated list of Loop 3 agents"
-      echo "  --loop2-agents <agents>     Comma-separated list of Loop 2 agents"
-      echo "  --product-owner <agent>     Product owner agent ID"
-      echo ""
-      echo "Optional options:"
-      echo "  --mode <mode>               CFN mode: mvp, standard, enterprise (default: standard)"
-      echo "  --max-iterations <n>        Maximum iterations (default: 10)"
-      echo "  --min-quorum-loop3 <n>      Loop 3 quorum threshold (default: 0.66)"
-      echo "  --min-quorum-loop2 <n>      Loop 2 quorum threshold (default: 0.66)"
-      echo "  --epic-context <json>       Epic context JSON"
-      echo "  --phase-context <json>      Phase context JSON"
-      echo "  --success-criteria <json>   Success criteria JSON"
-      echo "  --expected-files <files>    Comma-separated expected deliverables"
-      echo "  --phase-id <id>             Phase identifier for timeout calculation"
-      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
-
-# Get thresholds for mode
-# Add additional mode validation with safe fallback
-case "$MODE" in
-  mvp)
-    GATE=${GATE_THRESHOLD[mvp]:-0.70}
-    CONSENSUS=${CONSENSUS_THRESHOLD[mvp]:-0.80}
-    ;;
-  standard)
-    GATE=${GATE_THRESHOLD[standard]:-0.75}
-    CONSENSUS=${CONSENSUS_THRESHOLD[standard]:-0.90}
-    ;;
-  enterprise)
-    GATE=${GATE_THRESHOLD[enterprise]:-0.85}
-    CONSENSUS=${CONSENSUS_THRESHOLD[enterprise]:-0.95}
-    ;;
-  *)
-    echo "Invalid mode: $MODE"
-    exit 1
-    ;;
-esac
-
-# Calculate timeout
-TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "${PHASE_ID:-unknown}")
-
-echo "=============================================="
-echo "CFN Loop Orchestration v1.0.0"
-echo "=============================================="
-echo "Task ID: $TASK_ID"
-echo "Mode: $MODE"
-echo "Gate Threshold: $GATE"
-echo "Consensus Threshold: $CONSENSUS"
-echo "Max Iterations: $MAX_ITERATIONS"
-echo "Timeout: ${TIMEOUT}s"
-echo "=============================================="
-echo ""
-
-##############################################################################
-# Helper Functions
-##############################################################################
-
-function store_context() {
-  local task_id="$1"
-
-  # Store epic context if provided using Redis coordination primitive
-  if [ -n "$EPIC_CONTEXT" ]; then
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "epic-context" \
-      --value "$EPIC_CONTEXT" \
-      --namespace "swarm" >/dev/null
-    echo "Stored epic context"
-  fi
-
-  # Store phase context if provided using Redis coordination primitive
-  if [ -n "$PHASE_CONTEXT" ]; then
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "phase-context" \
-      --value "$PHASE_CONTEXT" \
-      --namespace "swarm" >/dev/null
-    echo "Stored phase context"
-  fi
-
-  # Store success criteria if provided using Redis coordination primitive
-  if [ -n "$SUCCESS_CRITERIA" ]; then
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "success-criteria" \
-      --value "$SUCCESS_CRITERIA" \
-      --namespace "swarm" >/dev/null
-    echo "Stored success criteria"
-  fi
-
-  echo ""
-}
-
-build_agent_context() {
-    local iteration="$1"
-    local agent_type="$2"
-    local feedback="$3"
-    local loop_type="${4:-}"  # NEW: loop3, loop2, or loop4 (optional)
-
-    # Extract from SUCCESS_CRITERIA JSON
-    local task_desc="CFN Loop implementation"
-    local deliverables=$(echo "$SUCCESS_CRITERIA" | jq -r '.deliverables // [] | join(", ")' 2>/dev/null || echo "")
-    local acceptance=$(echo "$SUCCESS_CRITERIA" | jq -r '.acceptanceCriteria // [] | join(", ")' 2>/dev/null || echo "")
-
-    # Build base context
-    local context="Task: $task_desc | Deliverables: $deliverables | Acceptance: $acceptance | Iteration: $iteration"
-
-    if [[ -n "$feedback" ]]; then
-        context="$context | Feedback: $feedback"
-    fi
-
-    # Inject CFN Loop context if injection script exists and loop_type provided
-    if [[ -n "$loop_type" ]] && [[ -x "$SCRIPT_DIR/inject-loop-context.sh" ]]; then
-        context=$("$SCRIPT_DIR/inject-loop-context.sh" "$loop_type" "$context" 2>/dev/null || echo "$context")
-    fi
-
-    echo "$context"
-}
-
-function spawn_loop3_agents() {
-  local task_id="$1"
-  local iteration="$2"
-  local agents="$3"
-
-  echo "[Loop 3] Spawning implementer agents (iteration $iteration)..."
-
-  # Convert comma-separated agents to array
-  IFS=',' read -ra AGENT_ARRAY <<< "$agents"
-
-  # Track agent instance counts for unique ID generation
-  declare -A AGENT_INSTANCE_COUNTS
-
-  # Spawn each agent via CLI
-  for agent_type in "${AGENT_ARRAY[@]}"; do
-    # Generate unique agent ID (agent-type-iteration-instance)
-    AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
-    INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
-    UNIQUE_AGENT_ID="${agent_type}-${iteration}-${INSTANCE_NUM}"
-
-    echo "  Spawning: $agent_type (ID: $UNIQUE_AGENT_ID)"
-
-    # Validate agent input
-    local safe_agent_type safe_task_id safe_agent_id
-    safe_agent_type=$(sanitize_input "$agent_type") || continue
-    safe_task_id=$(sanitize_input "$task_id") || continue
-    safe_agent_id=$(sanitize_input "$UNIQUE_AGENT_ID") || continue
-
-    # Spawn agent in background with explicit agent ID
-    npx claude-flow-novice agent "$safe_agent_type" \
-      --task-id "$safe_task_id" \
-      --agent-id "$safe_agent_id" \
-      --iteration "$iteration" \
-      --context "$(build_agent_context "$iteration" "$safe_agent_type" "" "loop3")" &
-
-    # Store PID for monitoring using unique agent ID
-    AGENT_PID=$!
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "${UNIQUE_AGENT_ID}:pid" \
-      --value "{\"pid\": $AGENT_PID}" \
-      --namespace "swarm" >/dev/null
-
-    # Store agent ID mapping for later retrieval using Redis SADD for set storage
-    redis-cli SADD "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" "$UNIQUE_AGENT_ID" >/dev/null
-  done
-
-  echo "[Loop 3] All agents spawned"
-  echo ""
-}
-
-function wait_for_agents() {
-  local task_id="$1"
-  local agents="$2"
-  local timeout="$3"
-  local iteration="${4:-1}"
-
-  echo "Waiting for agents to complete (timeout: ${timeout}s)..."
-
-  # Retrieve actual agent IDs from Redis (stored during spawn using SADD)
-  local stored_ids
-  stored_ids=$(redis-cli SMEMBERS "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
-
-  # If stored IDs exist, use them; otherwise fallback to generating from agent types
-  local -a AGENT_IDS
-  if [ -n "$stored_ids" ]; then
-    IFS=',' read -ra AGENT_IDS <<< "$stored_ids"
-    echo "  Retrieved ${#AGENT_IDS[@]} agent IDs from Redis"
-  else
-    # Fallback: Convert agent types to IDs (legacy compatibility)
-    echo "  Warning: No stored agent IDs, using agent types as fallback"
-    IFS=',' read -ra AGENT_TYPES <<< "$agents"
-
-    # Track instance counts to match spawn behavior
-    declare -A AGENT_INSTANCE_COUNTS
-    for agent_type in "${AGENT_TYPES[@]}"; do
-      AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
-      INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
-      AGENT_IDS+=("${agent_type}-${iteration}-${INSTANCE_NUM}")
-    done
-  fi
-
-  # Parallel BLPOP implementation with shared timeout
-  # Track start time for global timeout calculation
-  local start_time=$(date +%s)
-
-  # Spawn parallel BLPOP processes for each agent
-  local pids=()
-  local temp_files=()
-
-  for unique_agent_id in "${AGENT_IDS[@]}"; do
-    # Create temporary file for this agent's result
-    local temp_file="/tmp/cfn-wait-${task_id}-${unique_agent_id}-$$.tmp"
-    temp_files+=("$temp_file")
-
-    echo "  Waiting for: $unique_agent_id"
-
-    # Spawn BLPOP in background, write result to temp file
-    (
-      local result
-      if redis-cli blpop "swarm:${task_id}:${unique_agent_id}:done" "$timeout" >/dev/null 2>&1; then
-        echo "success" > "$temp_file"
-      else
-        echo "timeout" > "$temp_file"
-      fi
-      exit 0
-    ) &
-
-    pids+=($!)
-  done
-
-  # Wait for all parallel BLPOP processes to complete
-  # This ensures timeout is global (60s total), not per-agent (60s * N)
-  for pid in "${pids[@]}"; do
-    wait "$pid" 2>/dev/null || true
-  done
-
-  # Calculate actual elapsed time
-  local end_time=$(date +%s)
-  local elapsed=$((end_time - start_time))
-
-  # Check results and report status
-  local completed=0
-  local timed_out=0
-
-  for i in "${!AGENT_IDS[@]}"; do
-    local unique_agent_id="${AGENT_IDS[$i]}"
-    local temp_file="${temp_files[$i]}"
-
-    if [ -f "$temp_file" ]; then
-      local result=$(cat "$temp_file")
-      if [ "$result" = "success" ]; then
-        ((completed++))
-        echo "  ✅ $unique_agent_id completed"
-      else
-        ((timed_out++))
-        echo "  ⚠️  $unique_agent_id did not complete within timeout"
-      fi
-      rm -f "$temp_file"
-    else
-      ((timed_out++))
-      echo "  ❌ $unique_agent_id result file missing"
-    fi
-  done
-
-  echo "Agents completed: $completed/${#AGENT_IDS[@]} (elapsed: ${elapsed}s)"
-  echo ""
-}
-
-function wait_for_loop2_agents() {
-  local task_id="$1"
-  local agents="$2"
-  local timeout="$3"
-  local iteration="${4:-1}"
-
-  echo "Waiting for Loop 2 validators to complete (timeout: ${timeout}s)..."
-
-  # Retrieve actual agent IDs from Redis (stored during spawn using SADD)
-  local stored_ids
-  stored_ids=$(redis-cli SMEMBERS "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
-
-  # If stored IDs exist, use them; otherwise fallback to generating from agent types
-  local -a VALIDATOR_IDS
-  if [ -n "$stored_ids" ]; then
-    IFS=',' read -ra VALIDATOR_IDS <<< "$stored_ids"
-    echo "  Retrieved ${#VALIDATOR_IDS[@]} validator IDs from Redis"
-  else
-    # Fallback: Convert agent types to IDs (legacy compatibility)
-    echo "  Warning: No stored validator IDs, using agent types as fallback"
-    IFS=',' read -ra AGENT_TYPES <<< "$agents"
-
-    # Track instance counts to match spawn behavior
-    declare -A AGENT_INSTANCE_COUNTS
-    for agent_type in "${AGENT_TYPES[@]}"; do
-      AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
-      INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
-      VALIDATOR_IDS+=("${agent_type}-${iteration}-${INSTANCE_NUM}")
-    done
-  fi
-
-  # Parallel BLPOP implementation
-  local start_time=$(date +%s)
-  local pids=()
-  local temp_files=()
-
-  for unique_validator_id in "${VALIDATOR_IDS[@]}"; do
-    local temp_file="/tmp/cfn-wait-${task_id}-${unique_validator_id}-$$.tmp"
-    temp_files+=("$temp_file")
-
-    echo "  Waiting for: $unique_validator_id"
-
-    # Spawn BLPOP in background
-    (
-      if redis-cli blpop "swarm:${task_id}:${unique_validator_id}:done" "$timeout" >/dev/null 2>&1; then
-        echo "success" > "$temp_file"
-      else
-        echo "timeout" > "$temp_file"
-      fi
-      exit 0
-    ) &
-
-    pids+=($!)
-  done
-
-  # Wait for all processes
-  for pid in "${pids[@]}"; do
-    wait "$pid" 2>/dev/null || true
-  done
-
-  # Check results
-  local end_time=$(date +%s)
-  local elapsed=$((end_time - start_time))
-  local completed=0
-  local timed_out=0
-
-  for i in "${!VALIDATOR_IDS[@]}"; do
-    local unique_validator_id="${VALIDATOR_IDS[$i]}"
-    local temp_file="${temp_files[$i]}"
-
-    if [ -f "$temp_file" ]; then
-      local result=$(cat "$temp_file")
-      if [ "$result" = "success" ]; then
-        ((completed++))
-        echo "  ✅ $unique_validator_id completed"
-      else
-        ((timed_out++))
-        echo "  ⚠️  $unique_validator_id did not complete within timeout"
-      fi
-      rm -f "$temp_file"
-    else
-      ((timed_out++))
-      echo "  ❌ $unique_validator_id result file missing"
-    fi
-  done
-
-  echo "Validators completed: $completed/${#VALIDATOR_IDS[@]} (elapsed: ${elapsed}s)"
-  echo ""
-}
-
-function spawn_loop2_agents() {
-  local task_id="$1"
-  local iteration="$2"
-  local agents="$3"
-
-  echo "[Loop 2] Spawning validator agents (iteration $iteration)..."
-
-  # Convert comma-separated agents to array
-  IFS=',' read -ra AGENT_ARRAY <<< "$agents"
-
-  # Track agent instance counts for unique ID generation
-  declare -A AGENT_INSTANCE_COUNTS
-
-  # Spawn each agent via CLI
-  for agent_type in "${AGENT_ARRAY[@]}"; do
-    # Generate unique agent ID (agent-type-iteration-instance)
-    AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
-    INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
-    UNIQUE_VALIDATOR_ID="${agent_type}-${iteration}-${INSTANCE_NUM}"
-
-    echo "  Spawning: $agent_type (ID: $UNIQUE_VALIDATOR_ID)"
-
-    # Spawn agent in background with explicit agent ID
-    npx claude-flow-novice agent "$agent_type" \
-      --task-id "$task_id" \
-      --agent-id "$UNIQUE_VALIDATOR_ID" \
-      --iteration "$iteration" \
-      --context "$(build_agent_context "$iteration" "$agent_type" "" "loop2")" &
-
-    # Store PID for monitoring using unique agent ID
-    AGENT_PID=$!
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "${UNIQUE_VALIDATOR_ID}:pid" \
-      --value "{\"pid\": $AGENT_PID}" \
-      --namespace "swarm" >/dev/null
-
-    # Store agent ID mapping for later retrieval using Redis SADD for set storage
-    redis-cli SADD "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" "$UNIQUE_VALIDATOR_ID" >/dev/null
-  done
-
-  echo "[Loop 2] All agents spawned"
-  echo ""
-}
-
-function spawn_product_owner() {
-  local task_id="$1"
-  local iteration="$2"
-
-  echo "[Product Owner] Spawning decision agent..."
-
-  # BLOCKER #2 FIX: Match execute-decision.sh actual parameters
-  # Required: --task-id, --agent-id, --consensus, --threshold, --iteration, --max-iterations
-  local decision_output
-  decision_output=$("$SCRIPT_DIR/../product-owner-decision/execute-decision.sh" \
-    --task-id "$task_id" \
-    --agent-id "$PRODUCT_OWNER" \
-    --consensus "$LOOP2_FINAL_CONSENSUS" \
-    --threshold "$CONSENSUS" \
-    --iteration "$iteration" \
-    --max-iterations "$MAX_ITERATIONS")
-
-  # Parse decision from output
-  if echo "$decision_output" | grep -q "PROCEED"; then
-    FINAL_DECISION="PROCEED"
-  elif echo "$decision_output" | grep -q "ITERATE"; then
-    FINAL_DECISION="ITERATE"
-  elif echo "$decision_output" | grep -q "ABORT"; then
-    FINAL_DECISION="ABORT"
-  else
-    echo "Warning: Could not parse Product Owner decision, defaulting to ITERATE"
-    FINAL_DECISION="ITERATE"
-  fi
-
-  echo "[Product Owner] Decision: $FINAL_DECISION"
-  echo ""
-}
-
-function output_result() {
-  local status="$1"
-  local end_time=$(date +%s)
-  local execution_time=$((end_time - START_TIME))
-
-  echo "=============================================="
-  echo "CFN Loop Execution Complete"
-  echo "=============================================="
-  echo "Status: $status"
-  echo "Iterations: $ITERATIONS_COMPLETED"
-  echo "Final Decision: $FINAL_DECISION"
-  echo "Loop 3 Confidence: $LOOP3_FINAL_CONFIDENCE"
-  echo "Loop 2 Consensus: $LOOP2_FINAL_CONSENSUS"
-  echo "Deliverables Verified: $DELIVERABLES_VERIFIED"
-  echo "Execution Time: ${execution_time}s"
-  echo "=============================================="
-
-  # Output structured JSON result
-  cat <<EOF
-{
-  "status": "$status",
-  "iterations_completed": $ITERATIONS_COMPLETED,
-  "final_decision": "$FINAL_DECISION",
-  "loop3_confidence": $LOOP3_FINAL_CONFIDENCE,
-  "loop2_consensus": $LOOP2_FINAL_CONSENSUS,
-  "deliverables_verified": $DELIVERABLES_VERIFIED,
-  "execution_time_seconds": $execution_time
-}
-EOF
-}
-
-##############################################################################
-# Main CFN Loop
-##############################################################################
-
-# Store context in Redis
-store_context "$TASK_ID"
-
-# Iteration loop
-for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
-  echo ""
-  echo "=========================================="
-  echo "Iteration $ITERATION / $MAX_ITERATIONS"
-  echo "=========================================="
-  echo ""
-
-  ITERATIONS_COMPLETED=$ITERATION
-
-  # Step 1: Spawn Loop 3 agents (implementers)
-  spawn_loop3_agents "$TASK_ID" "$ITERATION" "$LOOP3_AGENTS"
-
-  # Step 2: Wait for Loop 3 completion
-  wait_for_agents "$TASK_ID" "$LOOP3_AGENTS" "$TIMEOUT" "$ITERATION"
-
-  # Step 3: Verify deliverables (prevent "consensus on vapor")
-  if [ -n "$EXPECTED_FILES" ] || [ -n "$EPIC_CONTEXT" ]; then
-    # Extract task type from epic context for keyword detection
-    TASK_TYPE=""
-    if [ -n "$EPIC_CONTEXT" ]; then
-      TASK_TYPE=$(echo "$EPIC_CONTEXT" | jq -r '.epicGoal // ""' 2>/dev/null || echo "")
-    fi
-
-    if "$HELPERS_DIR/deliverable-verifier.sh" \
-         --expected-files "${EXPECTED_FILES:-}" \
-         --task-type "${TASK_TYPE:-}"; then
-      DELIVERABLES_VERIFIED=true
-    else
-      echo "❌ Deliverable verification failed - forcing Loop 3 iteration"
-      # Use iteration manager to wake Loop 3 agents with explicit feedback
-      "$HELPERS_DIR/iteration-manager.sh" \
-        --task-id "$TASK_ID" \
-        --iteration "$((ITERATION + 1))" \
-        --agents "$LOOP3_AGENTS" \
-        --feedback-source "swarm:${TASK_ID}:feedback"
-      continue
-    fi
-  fi
-
-  # Step 4: Gate check (Loop 3 self-validation)
-  # Retrieve actual Loop 3 agent IDs for validation
-  LOOP3_IDS=$(redis-cli SMEMBERS "swarm:${TASK_ID}:loop3:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
-
-  if [ -z "$LOOP3_IDS" ]; then
-    echo "⚠️  WARNING: No Loop 3 agent IDs found in Redis, using agent types as fallback"
-    LOOP3_IDS="$LOOP3_AGENTS"
-  fi
-
-  if "$HELPERS_DIR/gate-check.sh" \
-       --task-id "$TASK_ID" \
-       --agents "$LOOP3_IDS" \
-       --threshold "$GATE" \
-       --min-quorum "$MIN_QUORUM_LOOP3"; then
-    # Gate passed - store confidence
-    LOOP3_FINAL_CONFIDENCE=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
-      --task-id "$TASK_ID" \
-      --agent-ids "$LOOP3_IDS" \
-      --min-quorum "$MIN_QUORUM_LOOP3")
-  else
-    # Gate failed - iterate Loop 3
-    echo "❌ Gate check failed - iterating Loop 3"
-    "$HELPERS_DIR/iteration-manager.sh" \
-      --task-id "$TASK_ID" \
-      --iteration "$((ITERATION + 1))" \
-      --agents "$LOOP3_AGENTS" \
-      --feedback-source "swarm:${TASK_ID}:feedback"
-    continue
-  fi
-
-  # Step 5: Spawn Loop 2 agents (validators)
-  spawn_loop2_agents "$TASK_ID" "$ITERATION" "$LOOP2_AGENTS"
-
-  # Step 6: Wait for Loop 2 completion
-  wait_for_loop2_agents "$TASK_ID" "$LOOP2_AGENTS" "$TIMEOUT" "$ITERATION"
-
-  # Step 7: Consensus check (Loop 2 validation)
-  # Retrieve actual Loop 2 agent IDs for validation
-  LOOP2_IDS=$(redis-cli SMEMBERS "swarm:${TASK_ID}:loop2:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
-
-  if [ -z "$LOOP2_IDS" ]; then
-    echo "⚠️  WARNING: No Loop 2 agent IDs found in Redis, using agent types as fallback"
-    LOOP2_IDS="$LOOP2_AGENTS"
-  fi
-
-  if "$HELPERS_DIR/consensus.sh" \
-       --task-id "$TASK_ID" \
-       --agents "$LOOP2_IDS" \
-       --threshold "$CONSENSUS" \
-       --min-quorum "$MIN_QUORUM_LOOP2"; then
-    # Consensus reached - store score
-    LOOP2_FINAL_CONSENSUS=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
-      --task-id "$TASK_ID" \
-      --agent-ids "$LOOP2_IDS" \
-      --min-quorum "$MIN_QUORUM_LOOP2")
-  else
-    # Consensus failed - iterate all agents
-    echo "❌ Consensus check failed - iterating all agents"
-    "$HELPERS_DIR/iteration-manager.sh" \
-      --task-id "$TASK_ID" \
-      --iteration "$((ITERATION + 1))" \
-      --agents "$LOOP3_AGENTS,$LOOP2_AGENTS" \
-      --feedback-source "swarm:${TASK_ID}:feedback"
-    continue
-  fi
-
-  # Step 8: Product Owner Decision
-  spawn_product_owner "$TASK_ID" "$ITERATION"
-
-  # Step 9: Execute decision
-  case "$FINAL_DECISION" in
-    PROCEED)
-      output_result "success"
-      exit 0
-      ;;
-    ABORT)
-      output_result "aborted"
-      exit 1
-      ;;
-    ITERATE)
-      if [ $ITERATION -ge $MAX_ITERATIONS ]; then
-        echo "❌ Max iterations reached"
-        output_result "failed"
-        exit 1
-      fi
-
-      echo "🔄 Product Owner requested iteration"
-      "$HELPERS_DIR/iteration-manager.sh" \
-        --task-id "$TASK_ID" \
-        --iteration "$((ITERATION + 1))" \
-        --agents "$LOOP3_AGENTS,$LOOP2_AGENTS" \
-        --feedback-source "swarm:${TASK_ID}:feedback"
-      continue
-      ;;
-  esac
-done
-
-# Max iterations reached without success
-echo "❌ Max iterations ($MAX_ITERATIONS) reached without PROCEED decision"
-output_result "failed"
-exit 1