claude-flow-novice 2.10.5 → 2.10.7

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

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

package/claude-assets/skills/cfn-redis-coordination/execute-product-owner-decision.sh

@@ -0,0 +1,258 @@
+#!/bin/bash
+##############################################################################
+# Product Owner Decision Execution Script
+#
+# Handles the complete Product Owner decision protocol:
+# 1. Query Loop 2 consensus from Redis
+# 2. Apply GOAP decision framework
+# 3. Push decision to Redis
+# 4. Signal completion
+# 5. Report confidence
+#
+# Usage:
+#   ./execute-product-owner-decision.sh --task-id <task> --agent-id <agent>
+##############################################################################
+
+set -euo pipefail
+
+# 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 option: $1"
+      echo "Usage: $0 --task-id <task> --agent-id <agent>"
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ]; then
+  echo "Error: --task-id and --agent-id are required"
+  exit 1
+fi
+
+echo "[Product Owner] Starting decision execution for task: $TASK_ID"
+echo ""
+
+# Step 1: Query Loop 2 consensus and context
+echo "[Step 1] Querying Loop 2 consensus and context from Redis..."
+CONSENSUS=$(redis-cli lindex "swarm:${TASK_ID}:metrics:loop2_consensus" 0 | jq -r '.consensus')
+ITERATION=$(redis-cli lindex "swarm:${TASK_ID}:metrics:loop2_consensus" 0 | jq -r '.iteration')
+
+# Get feedback from validators
+FEEDBACK_JSON=$(redis-cli lrange "swarm:${TASK_ID}:loop2:feedback" 0 -1 | jq -s '.')
+
+# Get acceptance criteria and scope
+ACCEPTANCE_CRITERIA=$(redis-cli get "swarm:${TASK_ID}:success-criteria" | jq -r '.acceptanceCriteria // []')
+EPIC_CONTEXT=$(redis-cli get "swarm:${TASK_ID}:epic-context")
+IN_SCOPE=$(echo "$EPIC_CONTEXT" | jq -r '.inScope // []')
+OUT_OF_SCOPE=$(echo "$EPIC_CONTEXT" | jq -r '.outOfScope // []')
+EPIC_GOAL=$(echo "$EPIC_CONTEXT" | jq -r '.epicGoal // ""')
+
+echo "  Loop 2 Consensus: $CONSENSUS"
+echo "  Iteration: $ITERATION"
+echo "  Validator Feedback Items: $(echo "$FEEDBACK_JSON" | jq 'length')"
+echo ""
+
+# Step 2: Apply scope categorization
+echo "[Step 2] Categorizing validator feedback by scope..."
+
+# Initialize arrays
+IN_SCOPE_ITEMS="[]"
+OUT_OF_SCOPE_ITEMS="[]"
+IN_SCOPE_CONSENSUS=0
+OUT_OF_SCOPE_CONSENSUS=0
+
+# Process feedback if available
+if [ "$FEEDBACK_JSON" != "null" ] && [ "$FEEDBACK_JSON" != "[]" ]; then
+  # Categorize each feedback item
+  for feedback_item in $(echo "$FEEDBACK_JSON" | jq -r '.[] | @base64'); do
+    _jq() {
+      echo "$feedback_item" | base64 --decode | jq -r "$1"
+    }
+
+    FEEDBACK_TEXT=$(_jq '.')
+    IS_IN_SCOPE="false"
+
+    # Check if feedback relates to acceptance criteria or inScope items
+    for criterion in $(echo "$ACCEPTANCE_CRITERIA" | jq -r '.[] | @base64'); do
+      CRITERION_TEXT=$(echo "$criterion" | base64 --decode)
+      if echo "$FEEDBACK_TEXT" | grep -iq "$(echo "$CRITERION_TEXT" | head -c 20)"; then
+        IS_IN_SCOPE="true"
+        break
+      fi
+    done
+
+    # Add to appropriate category
+    if [ "$IS_IN_SCOPE" = "true" ]; then
+      IN_SCOPE_ITEMS=$(echo "$IN_SCOPE_ITEMS" | jq --arg item "$FEEDBACK_TEXT" '. + [$item]')
+    else
+      OUT_OF_SCOPE_ITEMS=$(echo "$OUT_OF_SCOPE_ITEMS" | jq --arg item "$FEEDBACK_TEXT" '. + [$item]')
+    fi
+  done
+
+  # Calculate in-scope consensus (consensus weighted by in-scope ratio)
+  TOTAL_ITEMS=$(echo "$FEEDBACK_JSON" | jq 'length')
+  IN_SCOPE_COUNT=$(echo "$IN_SCOPE_ITEMS" | jq 'length')
+
+  if [ "$TOTAL_ITEMS" -gt 0 ]; then
+    # If there's feedback, weight consensus by in-scope ratio
+    IN_SCOPE_CONSENSUS=$(echo "scale=2; $CONSENSUS * $IN_SCOPE_COUNT / $TOTAL_ITEMS" | bc -l)
+  else
+    # No feedback means validators had no concerns - use full consensus
+    IN_SCOPE_CONSENSUS=$CONSENSUS
+  fi
+else
+  # No feedback at all - use full consensus as in-scope
+  IN_SCOPE_CONSENSUS=$CONSENSUS
+fi
+
+echo "  In-Scope Items: $(echo "$IN_SCOPE_ITEMS" | jq 'length')"
+echo "  Out-of-Scope Items: $(echo "$OUT_OF_SCOPE_ITEMS" | jq 'length')"
+echo "  In-Scope Consensus: $IN_SCOPE_CONSENSUS"
+echo ""
+
+# Step 3: Apply GOAP decision framework with scope enforcement
+echo "[Step 3] Applying GOAP decision framework with scope enforcement..."
+
+# Default threshold (standard mode)
+CONSENSUS_THRESHOLD=0.90
+MAX_ITERATIONS=10
+
+# Determine decision based on scope-aware consensus
+DECISION_TYPE=""
+DECISION_REASONING=""
+DECISION_CONFIDENCE=0
+BACKLOG_ITEMS="[]"
+
+if (( $(echo "$CONSENSUS >= $CONSENSUS_THRESHOLD" | bc -l) )); then
+  # High consensus - check if there are out-of-scope items
+  OUT_OF_SCOPE_COUNT=$(echo "$OUT_OF_SCOPE_ITEMS" | jq 'length')
+
+  if [ "$OUT_OF_SCOPE_COUNT" -gt 0 ]; then
+    DECISION_TYPE="DEFER_AND_PROCEED"
+    DECISION_REASONING="In-scope work complete (consensus $CONSENSUS >= $CONSENSUS_THRESHOLD). Deferring $OUT_OF_SCOPE_COUNT out-of-scope items to backlog."
+    DECISION_CONFIDENCE=0.92
+    BACKLOG_ITEMS="$OUT_OF_SCOPE_ITEMS"
+    echo "  Decision: DEFER_AND_PROCEED (moving out-of-scope items to backlog)"
+  else
+    DECISION_TYPE="PROCEED"
+    DECISION_REASONING="All work complete, consensus threshold met ($CONSENSUS >= $CONSENSUS_THRESHOLD)"
+    DECISION_CONFIDENCE=0.95
+    echo "  Decision: PROCEED (consensus exceeds threshold, no out-of-scope items)"
+  fi
+elif [ "$ITERATION" -lt "$MAX_ITERATIONS" ]; then
+  # Below consensus - check if in-scope consensus would meet threshold
+  if (( $(echo "$IN_SCOPE_CONSENSUS >= $CONSENSUS_THRESHOLD" | bc -l) )); then
+    # In-scope work is good, out-of-scope items preventing consensus
+    DECISION_TYPE="DEFER_AND_PROCEED"
+    DECISION_REASONING="In-scope consensus met ($IN_SCOPE_CONSENSUS >= $CONSENSUS_THRESHOLD). Out-of-scope items preventing overall consensus - deferring to backlog."
+    DECISION_CONFIDENCE=0.88
+    BACKLOG_ITEMS="$OUT_OF_SCOPE_ITEMS"
+    echo "  Decision: DEFER_AND_PROCEED (in-scope work complete, deferring out-of-scope blockers)"
+  else
+    # In-scope work needs improvement
+    DECISION_TYPE="ITERATE"
+    DECISION_REASONING="In-scope consensus below threshold ($IN_SCOPE_CONSENSUS < $CONSENSUS_THRESHOLD), targeted improvements needed"
+    DECISION_CONFIDENCE=0.90
+    BACKLOG_ITEMS="$OUT_OF_SCOPE_ITEMS"
+    echo "  Decision: ITERATE (in-scope work needs improvement, iteration $ITERATION/$MAX_ITERATIONS)"
+  fi
+else
+  DECISION_TYPE="ABORT"
+  DECISION_REASONING="Max iterations reached ($ITERATION >= $MAX_ITERATIONS) without meeting in-scope consensus threshold"
+  DECISION_CONFIDENCE=0.85
+  echo "  Decision: ABORT (max iterations reached)"
+fi
+
+echo ""
+
+# Build structured decision JSON with scope analysis
+DECISION=$(jq -n \
+  --arg decision "$DECISION_TYPE" \
+  --arg reasoning "$DECISION_REASONING" \
+  --arg confidence "$DECISION_CONFIDENCE" \
+  --argjson in_scope_items "$IN_SCOPE_ITEMS" \
+  --argjson out_of_scope_items "$OUT_OF_SCOPE_ITEMS" \
+  --arg in_scope_consensus "$IN_SCOPE_CONSENSUS" \
+  --argjson backlog_items "$BACKLOG_ITEMS" \
+  '{
+    decision: $decision,
+    reasoning: $reasoning,
+    confidence: ($confidence | tonumber),
+    scope_analysis: {
+      in_scope_consensus: ($in_scope_consensus | tonumber),
+      in_scope_items: $in_scope_items,
+      out_of_scope_items: $out_of_scope_items
+    },
+    backlog_items: $backlog_items
+  }')
+
+echo "[Step 4] Managing backlog items..."
+if [ "$(echo "$BACKLOG_ITEMS" | jq 'length')" -gt 0 ]; then
+  # Store backlog items in Redis
+  BACKLOG_KEY="swarm:${TASK_ID}:backlog"
+  echo "$BACKLOG_ITEMS" | redis-cli -x LPUSH "$BACKLOG_KEY" >/dev/null
+  echo "  ✓ Stored $(echo "$BACKLOG_ITEMS" | jq 'length') backlog items in Redis: $BACKLOG_KEY"
+
+  # Persist backlog to file for human review
+  BACKLOG_FILE=".claude/cfn-data/backlog/${TASK_ID}.json"
+  mkdir -p "$(dirname "$BACKLOG_FILE")"
+
+  BACKLOG_RECORD=$(jq -n \
+    --arg task_id "$TASK_ID" \
+    --arg timestamp "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" \
+    --arg epic_goal "$EPIC_GOAL" \
+    --argjson items "$BACKLOG_ITEMS" \
+    '{
+      task_id: $task_id,
+      timestamp: $timestamp,
+      epic_goal: $epic_goal,
+      deferred_items: $items,
+      status: "pending_review"
+    }')
+
+  echo "$BACKLOG_RECORD" > "$BACKLOG_FILE"
+  echo "  ✓ Backlog persisted to: $BACKLOG_FILE"
+else
+  echo "  No backlog items to store"
+fi
+echo ""
+
+echo "[Step 5] Pushing decision to Redis..."
+DECISION_KEY="swarm:${TASK_ID}:${AGENT_ID}:decision"
+echo "$DECISION" | redis-cli -x LPUSH "$DECISION_KEY" >/dev/null
+echo "  ✓ Decision pushed to: $DECISION_KEY"
+echo "  Content: $DECISION"
+echo ""
+
+# Step 6: Signal completion
+echo "[Step 6] Signaling completion..."
+DONE_KEY="swarm:${TASK_ID}:${AGENT_ID}:done"
+redis-cli LPUSH "$DONE_KEY" "complete" >/dev/null
+echo "  ✓ Completion signaled"
+echo ""
+
+# Step 7: Report confidence
+echo "[Step 7] Reporting confidence..."
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence "$DECISION_CONFIDENCE"
+
+echo ""
+echo "🎉 Product Owner decision execution complete!"
+echo "   Decision: $DECISION_TYPE"
+echo "   Consensus: $CONSENSUS"
+echo "   Iteration: $ITERATION"

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

@@ -0,0 +1,177 @@
+#!/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  # 60 minutes default
+
+# 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"