claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/redis-coordination/examples/timeout-handling.sh

@@ -1,227 +0,0 @@
-#!/bin/bash
-# Timeout Handling: Comprehensive timeout patterns for Redis coordination
-# Demonstrates proper timeout handling, error reporting, and recovery strategies
-
-set -e
-
-TASK_ID="demo:timeout"
-SHORT_TIMEOUT=5    # 5 seconds (for demo of timeout failure)
-NORMAL_TIMEOUT=300 # 5 minutes (production default)
-
-echo "=== Timeout Handling Demo ==="
-echo ""
-
-# Cleanup previous demo data
-echo "Cleaning up previous demo data..."
-redis-cli del "${TASK_ID}:slow-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:fast-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:error" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true
-
-echo "--- Scenario 1: Timeout Failure (Agent Too Slow) ---"
-echo ""
-
-# Simulate slow agent that exceeds timeout (runs in background)
-(
-  echo "[Slow Agent] Starting work..."
-  sleep 10  # Takes 10s but timeout is 5s
-
-  RESULT='{"agent":"slow-agent","confidence":0.85,"status":"complete"}'
-  redis-cli lpush "${TASK_ID}:slow-agent:done" "$RESULT" > /dev/null
-  echo "[Slow Agent] Work complete (but too late...)"
-) &
-
-SLOW_AGENT_PID=$!
-
-# Coordinator waits with short timeout
-echo "[Coordinator] Waiting for slow-agent with ${SHORT_TIMEOUT}s timeout..."
-RESULT=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:slow-agent:done" 0 2>/dev/null || echo "")
-EXIT_CODE=$?
-
-if [ $EXIT_CODE -eq 124 ]; then
-  echo "[Coordinator] ❌ ERROR: Slow agent timeout after ${SHORT_TIMEOUT}s"
-
-  # Report error to coordinator error channel
-  ERROR_REPORT='{
-    "agent": "slow-agent",
-    "error": "timeout",
-    "timeout": '${SHORT_TIMEOUT}',
-    "timestamp": "'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'"
-  }'
-
-  redis-cli lpush "${TASK_ID}:coordinator:error" "$ERROR_REPORT" > /dev/null
-  echo "[Coordinator] Error reported to ${TASK_ID}:coordinator:error"
-
-  # Kill slow agent background process
-  kill $SLOW_AGENT_PID 2>/dev/null || true
-
-  echo "[Coordinator] Decision: Terminate slow agent and retry with different agent"
-else
-  echo "[Coordinator] ✓ Slow agent completed within timeout"
-fi
-
-echo ""
-echo "--- Scenario 2: Timeout Success (Agent Fast Enough) ---"
-echo ""
-
-# Simulate fast agent that completes within timeout (runs in background)
-(
-  echo "[Fast Agent] Starting work..."
-  sleep 2  # Takes 2s, well within 5s timeout
-
-  RESULT='{"agent":"fast-agent","confidence":0.90,"status":"complete"}'
-  redis-cli lpush "${TASK_ID}:fast-agent:done" "$RESULT" > /dev/null
-  echo "[Fast Agent] Work complete"
-) &
-
-# Coordinator waits with short timeout
-echo "[Coordinator] Waiting for fast-agent with ${SHORT_TIMEOUT}s timeout..."
-RESULT=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:fast-agent:done" 0 2>/dev/null || echo "")
-EXIT_CODE=$?
-
-if [ $EXIT_CODE -eq 124 ]; then
-  echo "[Coordinator] ❌ ERROR: Fast agent timeout after ${SHORT_TIMEOUT}s"
-else
-  echo "[Coordinator] ✓ Fast agent completed within timeout"
-  echo "[Coordinator] Result: ${RESULT:0:80}..."
-fi
-
-wait
-
-echo ""
-echo "--- Scenario 3: Multi-Agent Timeout with Recovery ---"
-echo ""
-
-# Cleanup
-redis-cli del "${TASK_ID}:agent-1:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-2:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-3:done" > /dev/null 2>&1 || true
-
-# Simulate 3 agents with varying completion times
-(
-  sleep 1
-  redis-cli lpush "${TASK_ID}:agent-1:done" '{"agent":"agent-1","confidence":0.85}' > /dev/null
-  echo "[Agent 1] Complete (1s)"
-) &
-
-(
-  sleep 2
-  redis-cli lpush "${TASK_ID}:agent-2:done" '{"agent":"agent-2","confidence":0.90}' > /dev/null
-  echo "[Agent 2] Complete (2s)"
-) &
-
-(
-  sleep 15  # Too slow - exceeds 5s timeout
-  redis-cli lpush "${TASK_ID}:agent-3:done" '{"agent":"agent-3","confidence":0.88}' > /dev/null
-  echo "[Agent 3] Complete (15s - too late)"
-) &
-
-AGENT_3_PID=$!
-
-echo "[Coordinator] Waiting for 3 agents with ${SHORT_TIMEOUT}s timeout each..."
-
-# Wait for agent 1
-RESULT_1=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-1:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_1" ]; then
-  echo "[Coordinator] ❌ Agent 1 timeout"
-  AGENT_1_FAILED=1
-else
-  echo "[Coordinator] ✓ Agent 1 complete"
-  AGENT_1_FAILED=0
-fi
-
-# Wait for agent 2
-RESULT_2=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-2:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_2" ]; then
-  echo "[Coordinator] ❌ Agent 2 timeout"
-  AGENT_2_FAILED=1
-else
-  echo "[Coordinator] ✓ Agent 2 complete"
-  AGENT_2_FAILED=0
-fi
-
-# Wait for agent 3
-RESULT_3=$(timeout $SHORT_TIMEOUT redis-cli --csv blpop "${TASK_ID}:agent-3:done" 0 2>/dev/null || echo "")
-if [ -z "$RESULT_3" ]; then
-  echo "[Coordinator] ❌ Agent 3 timeout"
-  AGENT_3_FAILED=1
-
-  # Kill agent 3 background process
-  kill $AGENT_3_PID 2>/dev/null || true
-else
-  echo "[Coordinator] ✓ Agent 3 complete"
-  AGENT_3_FAILED=0
-fi
-
-# Calculate success rate
-FAILED_COUNT=$((AGENT_1_FAILED + AGENT_2_FAILED + AGENT_3_FAILED))
-SUCCESS_COUNT=$((3 - FAILED_COUNT))
-
-echo ""
-echo "[Coordinator] Results: $SUCCESS_COUNT/3 agents completed within timeout"
-
-if [ $SUCCESS_COUNT -ge 2 ]; then
-  echo "[Coordinator] Decision: PROCEED with partial results (2/3 quorum met)"
-
-  STATUS='{"status":"partial_success","completed":'$SUCCESS_COUNT',"failed":'$FAILED_COUNT',"decision":"proceed"}'
-  redis-cli set "${TASK_ID}:coordinator:status" "$STATUS" > /dev/null
-else
-  echo "[Coordinator] Decision: RETRY all agents (quorum not met)"
-
-  STATUS='{"status":"insufficient_quorum","completed":'$SUCCESS_COUNT',"failed":'$FAILED_COUNT',"decision":"retry"}'
-  redis-cli set "${TASK_ID}:coordinator:status" "$STATUS" > /dev/null
-fi
-
-wait
-
-echo ""
-echo "--- Scenario 4: Timeout Best Practices ---"
-echo ""
-
-echo "✓ Timeout Guidelines:"
-echo "  - Normal operations: 300s (5 minutes)"
-echo "  - Research tasks: 600s (10 minutes)"
-echo "  - Complex builds: 900s (15 minutes)"
-echo "  - Testing: 600s (10 minutes)"
-echo ""
-
-echo "✓ Timeout Handling Pattern:"
-echo '  result=$(timeout 300 redis-cli --csv blpop "channel" 0 2>/dev/null || echo "")'
-echo '  if [ $? -eq 124 ]; then'
-echo '    echo "TIMEOUT"'
-echo '    redis-cli lpush "coordinator:error" '"'"'{"error":"timeout"}'"'"
-echo '  fi'
-echo ""
-
-echo "✓ Error Reporting:"
-echo "  - Always report timeout to coordinator:error channel"
-echo "  - Include agent ID, timeout duration, timestamp"
-echo "  - Coordinator decides: retry, skip, or escalate"
-echo ""
-
-echo "✓ Recovery Strategies:"
-echo "  - Single agent timeout: Retry once with extended timeout"
-echo "  - Multiple agent timeout: Check quorum (2/3 pass = proceed)"
-echo "  - Critical agent timeout: Escalate to main chat"
-echo "  - Repeated timeouts: Switch to different agent type"
-echo ""
-
-echo "=== Timeout Handling Demo Complete ==="
-echo ""
-echo "Key Takeaways:"
-echo "  1. ALWAYS use timeout command with BLPOP"
-echo "  2. Check exit code 124 for timeout detection"
-echo "  3. Report timeouts to coordinator:error channel"
-echo "  4. Implement recovery strategies (retry/skip/escalate)"
-echo "  5. Use appropriate timeout values for task type"
-echo "  6. Kill/cleanup timed-out background processes"
-echo ""
-
-# Cleanup
-redis-cli del "${TASK_ID}:slow-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:fast-agent:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-1:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-2:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:agent-3:done" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:error" > /dev/null 2>&1 || true
-redis-cli del "${TASK_ID}:coordinator:status" > /dev/null 2>&1 || true

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

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

package/.claude/skills/redis-coordination/get-agent-timeout.sh

@@ -1,177 +0,0 @@
-#!/bin/bash
-# get-agent-timeout.sh - Get agent timeout from swarm metadata with intelligent fallback
-# Part of Redis Coordination Skill
-# Usage: ./get-agent-timeout.sh --task-id <id> --agent-id <id>
-#
-# Returns agent-specific timeout from swarm metadata with fallback order:
-# 1. agentTimeouts[agent-id] (exact match from swarm metadata)
-# 2. roleTimeouts[agent-role] (role-based from swarm metadata)
-# 3. agentTimeouts.default (fallback from swarm metadata)
-# 4. Role-based hardcoded defaults (researcher=7200, backend-dev=3600, etc.)
-# 5. 3600 (hardcoded default: 1 hour)
-#
-# Version: 1.1.0
-# Last Updated: 2025-10-19
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REDIS_HOST="${REDIS_HOST:-localhost}"
-REDIS_PORT="${REDIS_PORT:-6379}"
-DEFAULT_TIMEOUT=3600
-
-# Parse arguments
-TASK_ID=""
-AGENT_ID=""
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --agent-id)
-      AGENT_ID="$2"
-      shift 2
-      ;;
-    *)
-      echo "❌ Unknown argument: $1" >&2
-      echo "Usage: $0 --task-id <id> --agent-id <id>" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [[ -z "$TASK_ID" || -z "$AGENT_ID" ]]; then
-  echo "❌ Missing required arguments" >&2
-  echo "Usage: $0 --task-id <id> --agent-id <id>" >&2
-  exit 1
-fi
-
-# Function to extract role from agent-id
-extract_role_from_agent_id() {
-  local agent_id="$1"
-
-  # Extract role prefix (everything before last hyphen and number)
-  # Examples:
-  #   "researcher-1" -> "researcher"
-  #   "backend-dev-6" -> "backend-dev"
-  #   "reviewer" -> "reviewer"
-  if [[ "$agent_id" =~ ^(.+)-[0-9]+$ ]]; then
-    echo "${BASH_REMATCH[1]}"
-  else
-    echo "$agent_id"
-  fi
-}
-
-# Function to get role-based hardcoded timeout defaults (fallback layer 4)
-get_hardcoded_role_timeout() {
-  local role="$1"
-
-  case "$role" in
-    researcher)
-      echo "7200"  # 2 hours - research takes longer
-      ;;
-    backend-dev|coder|frontend-dev)
-      echo "3600"  # 1 hour - development work
-      ;;
-    reviewer|tester|security)
-      echo "1800"  # 30 minutes - validation/review
-      ;;
-    coordinator|orchestrator|product-owner)
-      echo "900"   # 15 minutes - coordination tasks
-      ;;
-    devops|architect)
-      echo "5400"  # 90 minutes - infrastructure/architecture
-      ;;
-    *)
-      echo "3600"  # 1 hour - default fallback
-      ;;
-  esac
-}
-
-# Function to extract timeout from JSON using jq or fallback parsing
-extract_timeout_from_json() {
-  local json="$1"
-  local key="$2"
-
-  if [[ -z "$json" || "$json" == "(nil)" ]]; then
-    echo ""
-    return
-  fi
-
-  # Use jq if available
-  if command -v jq &>/dev/null; then
-    local result
-    result=$(echo "$json" | jq -r --arg k "$key" '.[$k] // empty' 2>/dev/null || echo "")
-    echo "$result"
-  else
-    # Fallback: simple pattern matching for "key": value
-    echo "$json" | grep -oP "\"$key\"\s*:\s*\K\d+" 2>/dev/null || echo ""
-  fi
-}
-
-# Get swarm ID from task mapping
-SWARM_ID=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" \
-  GET "task:${TASK_ID}:swarm" 2>/dev/null || echo "")
-
-if [[ -z "$SWARM_ID" || "$SWARM_ID" == "(nil)" ]]; then
-  # Fallback: assume task-id is swarm-id for backwards compatibility
-  SWARM_ID="$TASK_ID"
-fi
-
-# Read swarm metadata from Redis
-METADATA=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" \
-  HGETALL "swarm:${SWARM_ID}:metadata" 2>/dev/null || echo "")
-
-# Extract role from agent ID
-ROLE=$(extract_role_from_agent_id "$AGENT_ID")
-
-# Parse metadata and extract timeout configurations
-TIMEOUT=""
-
-if [[ -n "$METADATA" && "$METADATA" != "(nil)" ]]; then
-  # Parse metadata into associative array
-  declare -A META
-  while IFS= read -r key && IFS= read -r value; do
-    META["$key"]="$value"
-  done <<< "$METADATA"
-
-  AGENT_TIMEOUTS_JSON="${META[agentTimeouts]:-}"
-  ROLE_TIMEOUTS_JSON="${META[roleTimeouts]:-}"
-
-  # Fallback order 1: agentTimeouts[agent-id] (exact match)
-  if [[ -n "$AGENT_TIMEOUTS_JSON" ]]; then
-    TIMEOUT=$(extract_timeout_from_json "$AGENT_TIMEOUTS_JSON" "$AGENT_ID")
-  fi
-
-  # Fallback order 2: roleTimeouts[agent-role] (role-based)
-  if [[ -z "$TIMEOUT" && -n "$ROLE_TIMEOUTS_JSON" ]]; then
-    TIMEOUT=$(extract_timeout_from_json "$ROLE_TIMEOUTS_JSON" "$ROLE")
-  fi
-
-  # Fallback order 3: agentTimeouts.default
-  if [[ -z "$TIMEOUT" && -n "$AGENT_TIMEOUTS_JSON" ]]; then
-    TIMEOUT=$(extract_timeout_from_json "$AGENT_TIMEOUTS_JSON" "default")
-  fi
-fi
-
-# Fallback order 4: Role-based hardcoded defaults
-if [[ -z "$TIMEOUT" ]]; then
-  TIMEOUT=$(get_hardcoded_role_timeout "$ROLE")
-fi
-
-# Fallback order 5: Hardcoded default (3600s)
-if [[ -z "$TIMEOUT" ]]; then
-  TIMEOUT="$DEFAULT_TIMEOUT"
-fi
-
-# Validate timeout is numeric
-if ! [[ "$TIMEOUT" =~ ^[0-9]+$ ]]; then
-  echo "⚠️  Invalid timeout value: $TIMEOUT, using default: ${DEFAULT_TIMEOUT}s" >&2
-  TIMEOUT="$DEFAULT_TIMEOUT"
-fi
-
-# Return timeout value
-echo "$TIMEOUT"