claude-flow-novice 2.14.8 → 2.14.10

package/claude-assets/skills/cfn-agent-selector/SKILL.md.backup_before_replace

@@ -0,0 +1,91 @@
+# Agent Selector Skill
+
+**Version:** 1.0.0
+**Purpose:** Select optimal agents for CFN Loop v3 based on task type and requirements
+
+## Overview
+
+Recommends Loop 3 (producers) and Loop 2 (evaluators) agents based on:
+- Task type (from task-classifier)
+- Task description keywords
+- Complexity requirements
+
+## Usage
+
+```bash
+AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
+  --task-type "software-development" \
+  --description "Implement JWT authentication with refresh tokens")
+
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
+echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
+```
+
+## Output Format
+
+```json
+{
+  "loop3": ["agent1", "agent2", "agent3"],
+  "loop2": ["validator1", "validator2", "validator3"],
+  "loop4": "product-owner",
+  "reasoning": "Explanation of agent selection"
+}
+```
+
+## Agent Selection Rules
+
+### Software Development
+**Base Loop 3:** backend-dev, coder
+**Add if keywords:**
+- "security", "authentication", "JWT" → security-specialist
+- "database", "SQL", "schema" → database-engineer (if exists)
+- "deploy", "CI/CD", "infrastructure" → devops-engineer
+- "frontend", "React", "UI" → react-frontend-engineer
+
+**Loop 2:** reviewer, tester, security-auditor
+
+### Content Creation
+**Base Loop 3:** copywriter, content-strategist
+**Add if keywords:**
+- "SEO", "search", "keywords" → seo-specialist
+- "technical", "documentation" → technical-writer (if exists)
+
+**Loop 2:** editor, brand-reviewer, compliance-checker
+
+### Research
+**Base Loop 3:** researcher, data-analyst
+**Add if keywords:**
+- "statistics", "data analysis" → statistician (if exists)
+- "domain-specific" → domain-expert
+
+**Loop 2:** fact-checker, methodology-reviewer, statistician
+
+### Design
+**Base Loop 3:** ui-designer, ux-researcher
+**Add if keywords:**
+- "visual", "branding" → visual-designer
+- "accessibility" → accessibility-advocate
+
+**Loop 2:** accessibility-advocate, design-critic, user-tester
+
+### Infrastructure
+**Base Loop 3:** devops-engineer, terraform-engineer
+**Add if keywords:**
+- "Kubernetes", "k8s", "container" → kubernetes-architect
+- "network", "security" → network-engineer (if exists)
+
+**Loop 2:** security-auditor, cost-optimizer, compliance-checker
+
+### Data Engineering
+**Base Loop 3:** data-engineer, pipeline-builder
+**Add if keywords:**
+- "ETL", "transformation" → etl-specialist
+- "streaming", "real-time" → streaming-specialist (if exists)
+
+**Loop 2:** data-quality-validator, schema-reviewer, performance-tester
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Agent selection
+- `.claude/skills/cfn-agent-selector/select-agents.sh` - Primary selection script

package/claude-assets/skills/cfn-cli-setup/validate-cli-environment.sh

@@ -0,0 +1,192 @@
+#!/bin/bash
+# CLI Environment Validation Script
+# Ensures required tools are available before agent deployment
+
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Required tools for CFN Loop CLI agents
+REQUIRED_TOOLS=(
+    "rg:ripgrep"
+    "git"
+    "node"
+    "npm"
+    "jq"
+    "redis-cli"
+    "find"
+    "grep"
+    "sed"
+    "awk"
+    "sort"
+    "uniq"
+    "head"
+    "tail"
+    "wc"
+    "xargs"
+)
+
+echo -e "${GREEN}🔧 CFN Loop CLI Environment Validation${NC}"
+
+# Function to check if a tool is available
+check_tool() {
+    local tool_name="$1"
+    local tool_description="$2"
+
+    if command -v "$tool_name" >/dev/null 2>&1; then
+        echo -e "  ${GREEN}✓${NC} $tool_name ($tool_description)"
+        return 0
+    else
+        echo -e "  ${RED}✗${NC} $tool_name ($tool_description) - ${YELLOW}MISSING${NC}"
+        return 1
+    fi
+}
+
+# Function to validate Node.js version
+validate_node_version() {
+    if command -v node >/dev/null 2>&1; then
+        local node_version=$(node --version 2>/dev/null | sed 's/v//')
+        local major_version=$(echo "$node_version" | cut -d. -f1)
+
+        if [ "$major_version" -ge 18 ]; then
+            echo -e "  ${GREEN}✓${NC} Node.js v$node_version (>= 18 required)"
+            return 0
+        else
+            echo -e "  ${RED}✗${NC} Node.js v$node_version (>= 18 required) - ${YELLOW}VERSION TOO OLD${NC}"
+            return 1
+        fi
+    else
+        echo -e "  ${RED}✗${NC} Node.js - ${YELLOW}NOT FOUND${NC}"
+        return 1
+    fi
+}
+
+# Function to check PATH for common development directories
+validate_path() {
+    echo -e "${YELLOW}Validating PATH...${NC}"
+
+    # Check for common development tool paths
+    local paths_to_check=(
+        "/usr/local/bin"
+        "/usr/bin"
+        "/bin"
+        "$HOME/.local/bin"
+        "$HOME/.cargo/bin"
+        "$HOME/.npm-global/bin"
+        "./node_modules/.bin"
+    )
+
+    local found_paths=0
+    for path in "${paths_to_check[@]}"; do
+        if [ -d "$path" ] && echo "$PATH" | grep -q "$path"; then
+            echo -e "  ${GREEN}✓${NC} $path in PATH"
+            ((found_paths++))
+        fi
+    done
+
+    if [ "$found_paths" -eq 0 ]; then
+        echo -e "  ${YELLOW}⚠${NC} Limited development directories in PATH"
+        return 1
+    fi
+
+    return 0
+}
+
+# Function to validate Redis connection
+validate_redis() {
+    echo -e "${YELLOW}Validating Redis connection...${NC}"
+
+    if redis-cli ping >/dev/null 2>&1; then
+        local redis_info=$(redis-cli info server 2>/dev/null | grep "redis_version" | cut -d: -f2 | tr -d '\r')
+        echo -e "  ${GREEN}✓${NC} Redis v$redis_info - Connected"
+        return 0
+    else
+        echo -e "  ${RED}✗${NC} Redis - ${YELLOW}NOT CONNECTED${NC}"
+        return 1
+    fi
+}
+
+# Function to validate working directory
+validate_working_directory() {
+    echo -e "${YELLOW}Validating working directory...${NC}"
+
+    # Check if we're in a git repository
+    if git rev-parse --git-dir >/dev/null 2>&1; then
+        echo -e "  ${GREEN}✓${NC} Git repository detected"
+    else
+        echo -e "  ${YELLOW}⚠${NC} Not in a git repository"
+    fi
+
+    # Check for claude-flow-novice installation
+    if [ -f "package.json" ] && grep -q "claude-flow-novice" package.json; then
+        echo -e "  ${GREEN}✓${NC} claude-flow-novice dependency found"
+    else
+        echo -e "  ${YELLOW}⚠${NC} claude-flow-novice not found in package.json"
+    fi
+
+    # Check for .claude directory
+    if [ -d ".claude" ]; then
+        echo -e "  ${GREEN}✓${NC} .claude directory found"
+    else
+        echo -e "  ${YELLOW}⚠${NC} .claude directory not found"
+    fi
+}
+
+# Function to install missing tools (suggestions)
+suggest_installations() {
+    echo -e "\n${YELLOW}Installation Suggestions:${NC}"
+    echo -e "  ${YELLOW}ripgrep:${NC} sudo apt-get install ripgrep  # Debian/Ubuntu"
+    echo -e "  ${YELLOW}ripgrep:${NC} brew install ripgrep              # macOS"
+    echo -e "  ${YELLOW}jq:${NC}      sudo apt-get install jq        # Debian/Ubuntu"
+    echo -e "  ${YELLOW}jq:${NC}      brew install jq                 # macOS"
+    echo -e "  ${YELLOW}Redis:${NC}   sudo systemctl start redis     # Linux"
+    echo -e "  ${YELLOW}Redis:${NC}   brew services start redis       # macOS"
+}
+
+# Main validation
+main() {
+    local failed=0
+
+    echo -e "${YELLOW}Checking required tools...${NC}"
+    for tool in "${REQUIRED_TOOLS[@]}"; do
+        local tool_name=$(echo "$tool" | cut -d: -f1)
+        local tool_description=$(echo "$tool" | cut -d: -f2)
+
+        if ! check_tool "$tool_name" "$tool_description"; then
+            ((failed++))
+        fi
+    done
+
+    echo -e "\n${YELLOW}Checking Node.js version...${NC}"
+    if ! validate_node_version; then
+        ((failed++))
+    fi
+
+    echo -e "\n${YELLOW}Checking environment configuration...${NC}"
+    if ! validate_path; then
+        ((failed++))
+    fi
+
+    if ! validate_redis; then
+        ((failed++))
+    fi
+
+    validate_working_directory
+
+    echo -e "\n${GREEN}=== Validation Summary ===${NC}"
+    if [ "$failed" -eq 0 ]; then
+        echo -e "${GREEN}✅ All validations passed! CLI environment is ready.${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ $failed validation(s) failed. CLI environment needs setup.${NC}"
+        suggest_installations
+        return 1
+    fi
+}
+
+# Run validation
+main "$@"

package/claude-assets/skills/cfn-deliverable-validation/confidence-calculator.sh

@@ -0,0 +1,262 @@
+#!/bin/bash
+# Deliverable-Based Confidence Calculator
+# Calculates confidence scores based on actual deliverable completion
+
+set -euo pipefail
+
+# Arguments
+TASK_ID="$1"
+AGENT_ID="$2"
+EXPECTED_DELIVERABLES="$3"  # JSON array of expected files/deliverables
+WORKING_DIR="${4:-$(pwd)}"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}📊 Deliverable-Based Confidence Calculator${NC}"
+echo "Task ID: $TASK_ID"
+echo "Agent ID: $AGENT_ID"
+echo "Working Directory: $WORKING_DIR"
+echo ""
+
+# Function to check if deliverable exists and is valid
+validate_deliverable() {
+    local deliverable="$1"
+    local deliverable_path="$WORKING_DIR/$deliverable"
+
+    # Handle different deliverable types
+    case "$deliverable" in
+        *.md|*.txt|*.json|*.yaml|*.yml)
+            # Text files - check existence and content
+            if [ -f "$deliverable_path" ]; then
+                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
+                if [ "$size" -gt 0 ]; then
+                    echo "VALID:$size"
+                    return 0
+                fi
+            fi
+            ;;
+        *.sh|*.js|*.ts|*.tsx|*.py)
+            # Code files - check existence and basic syntax
+            if [ -f "$deliverable_path" ]; then
+                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
+                if [ "$size" -gt 100 ]; then
+                    echo "VALID:$size"
+                    return 0
+                fi
+            fi
+            ;;
+        */)
+            # Directories - check existence and contents
+            if [ -d "$deliverable_path" ]; then
+                local file_count=$(find "$deliverable_path" -type f | wc -l)
+                if [ "$file_count" -gt 0 ]; then
+                    echo "VALID:$file_count"
+                    return 0
+                fi
+            fi
+            ;;
+        *.json)
+            # JSON files - check validity
+            if [ -f "$deliverable_path" ]; then
+                if jq empty "$deliverable_path" 2>/dev/null; then
+                    local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
+                    echo "VALID:$size"
+                    return 0
+                fi
+            fi
+            ;;
+        *)
+            # Generic file check
+            if [ -f "$deliverable_path" ]; then
+                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
+                if [ "$size" -gt 0 ]; then
+                    echo "VALID:$size"
+                    return 0
+                fi
+            fi
+            ;;
+    esac
+
+    echo "INVALID"
+    return 1
+}
+
+# Function to calculate quality score based on deliverable characteristics
+calculate_quality_score() {
+    local deliverable="$1"
+    local deliverable_path="$WORKING_DIR/$deliverable"
+
+    local quality_score=0.5  # Base score for existing
+
+    # Size scoring (larger files with meaningful content)
+    if [ -f "$deliverable_path" ]; then
+        local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
+
+        if [ "$size" -gt 5000 ]; then
+            quality_score=0.9  # Substantial content
+        elif [ "$size" -gt 1000 ]; then
+            quality_score=0.8  # Good content
+        elif [ "$size" -gt 100 ]; then
+            quality_score=0.7  # Adequate content
+        else
+            quality_score=0.6  # Minimal content
+        fi
+    fi
+
+    # Content-specific scoring
+    case "$deliverable" in
+        *.md)
+            # Markdown files - check for structure
+            if grep -q "^#" "$deliverable_path" 2>/dev/null; then
+                quality_score=$((quality_score + 10))  # Has headers
+            fi
+            if grep -q "^```" "$deliverable_path" 2>/dev/null; then
+                quality_score=$((quality_score + 5))   # Has code blocks
+            fi
+            ;;
+        *.ts|*.tsx|*.js|*.jsx)
+            # Code files - check for functions/exports
+            if grep -q "function\|export\|class\|const.*=" "$deliverable_path" 2>/dev/null; then
+                quality_score=$((quality_score + 10))  # Has functions/exports
+            fi
+            ;;
+        *.json)
+            # JSON files - check for structure
+            if jq -e 'type == "object" and keys > 0' "$deliverable_path" >/dev/null 2>&1; then
+                quality_score=$((quality_score + 10))  # Has meaningful structure
+            fi
+            ;;
+    esac
+
+    # Cap at 1.0
+    if [ "$quality_score" -gt 100 ]; then
+        quality_score=100
+    fi
+
+    echo "$quality_score"
+}
+
+# Main confidence calculation
+main() {
+    echo -e "${YELLOW}Analyzing expected deliverables...${NC}"
+
+    # Parse expected deliverables from JSON
+    if ! echo "$EXPECTED_DELIVERABLES" | jq empty 2>/dev/null; then
+        echo -e "${RED}❌ Invalid JSON in expected deliverables${NC}"
+        echo "0.0"
+        return 1
+    fi
+
+    local total_deliverables=$(echo "$EXPECTED_DELIVERABLES" | jq 'length')
+    local valid_deliverables=0
+    local total_quality_score=0
+
+    echo "Expected deliverables: $total_deliverables"
+    echo ""
+
+    # Check each deliverable
+    for ((i=0; i<total_deliverables; i++)); do
+        local deliverable=$(echo "$EXPECTED_DELIVERABLES" | jq -r ".[$i]")
+
+        echo -n "  Checking: $deliverable ... "
+
+        local validation_result=$(validate_deliverable "$deliverable")
+
+        if [[ "$validation_result" == VALID* ]]; then
+            local quality_score=$(calculate_quality_score "$deliverable")
+            total_quality_score=$((total_quality_score + quality_score))
+            valid_deliverables=$((valid_deliverables + 1))
+
+            local size=$(echo "$validation_result" | cut -d: -f2)
+            echo -e "${GREEN}✓ VALID${NC} (size: $size, quality: $quality_score)"
+        else
+            echo -e "${RED}✗ MISSING/INVALID${NC}"
+        fi
+    done
+
+    echo ""
+    echo -e "${YELLOW}Summary:${NC}"
+    echo "  Valid deliverables: $valid_deliverables/$total_deliverables"
+
+    # Calculate completion score (0-1)
+    local completion_score=0
+    if [ "$total_deliverables" -gt 0 ]; then
+        completion_score=$(echo "scale=3; $valid_deliverables / $total_deliverables" | bc -l)
+    fi
+
+    # Calculate average quality score (0-1)
+    local avg_quality_score=0.5  # Default if no deliverables
+    if [ "$valid_deliverables" -gt 0 ]; then
+        avg_quality_score=$(echo "scale=3; $total_quality_score / ($valid_deliverables * 100)" | bc -l)
+    fi
+
+    # Calculate final confidence score
+    # Weight: 60% completion, 40% quality
+    local final_confidence=$(echo "scale=3; ($completion_score * 0.6) + ($avg_quality_score * 0.4)" | bc -l)
+
+    # Round to 2 decimal places
+    final_confidence=$(echo "$final_confidence" | sed 's/^\./0./' | sed 's/\.\([0-9]\{2\}\)[0-9]*$/.\1/')
+
+    echo "  Completion score: $completion_score"
+    echo "  Quality score: $avg_quality_score"
+    echo "  Final confidence: $final_confidence"
+
+    # Validation rules
+    if [ "$valid_deliverables" -eq 0 ]; then
+        echo -e "${RED}🚨 CRITICAL: No deliverables created - confidence should be 0.0${NC}"
+        echo "0.0"
+        return 1
+    elif (( $(echo "$final_confidence > 0.3" | bc -l) )); then
+        if [ "$valid_deliverables" -lt "$((total_deliverables / 2))" ]; then
+            echo -e "${YELLOW}⚠️  WARNING: Low deliverable completion (<50%) - confidence should be <= 0.3${NC}"
+        fi
+    fi
+
+    echo -e "${GREEN}✓ Calculated confidence: $final_confidence${NC}"
+    echo "$final_confidence"
+}
+
+# Store results in Redis if available
+store_confidence_result() {
+    local confidence="$1"
+
+    if command -v redis-cli >/dev/null 2>&1; then
+        # Store detailed breakdown
+        local breakdown=$(cat << EOF
+{
+  "task_id": "$TASK_ID",
+  "agent_id": "$AGENT_ID",
+  "calculated_confidence": $confidence,
+  "calculation_method": "deliverable-based",
+  "timestamp": "$(date -Iseconds)",
+  "working_directory": "$WORKING_DIR",
+  "expected_deliverables": $EXPECTED_DELIVERABLES
+}
+EOF
+        )
+
+        redis-cli set "${TASK_ID}:${AGENT_ID}:confidence-breakdown" "$breakdown" >/dev/null 2>&1 || true
+        redis-cli set "${TASK_ID}:${AGENT_ID}:confidence-score" "$confidence" >/dev/null 2>&1 || true
+
+        echo -e "📦 ${BLUE}Stored confidence breakdown in Redis:${NC} ${TASK_ID}:${AGENT_ID}:confidence-breakdown"
+    fi
+}
+
+# Execute main function
+if [ "$#" -lt 3 ]; then
+    echo "Usage: $0 <task_id> <agent_id> <expected_deliverables_json> [working_directory]"
+    echo "Example: $0 task-123 agent-1 '[\"file1.txt\", \"script.sh\", \"docs/\"]' /path/to/project"
+    exit 1
+fi
+
+final_confidence=$(main "$@")
+
+# Store results
+store_confidence_result "$final_confidence"
+
+echo "$final_confidence"

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

@@ -66,6 +66,19 @@ LOOP3_FINAL_CONFIDENCE=0.0
 LOOP2_FINAL_CONSENSUS=0.0
 DELIVERABLES_VERIFIED=false
 
+# Cleanup Redis keys before exit
+cleanup_redis_keys() {
+  if [ -n "$TASK_ID" ]; then
+    echo "🧹 Cleaning up Redis keys for task $TASK_ID"
+    # Set TTL on remaining task keys (1 hour)
+    redis-cli keys "swarm:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+    redis-cli keys "cfn_loop:task:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+  fi
+}
+
+# Trap cleanup on script exit
+trap cleanup_redis_keys EXIT
+
 ##############################################################################
 # Argument Parsing
 ##############################################################################
@@ -694,6 +707,17 @@ EOF
 # Main CFN Loop
 ##############################################################################
 
+# Validate CLI environment before spawning agents
+echo "🔧 Validating CLI environment..."
+if [ -f "$PROJECT_ROOT/.claude/skills/cfn-cli-setup/validate-cli-environment.sh" ]; then
+  if ! bash "$PROJECT_ROOT/.claude/skills/cfn-cli-setup/validate-cli-environment.sh"; then
+    echo "❌ CLI environment validation failed. Agents may not have required tools."
+    echo "⚠️  Continuing anyway, but expect potential tool failures..."
+  fi
+else
+  echo "⚠️  CLI environment validation script not found. Skipping validation."
+fi
+
 # Store context in Redis
 store_context "$TASK_ID"
 
@@ -751,11 +775,41 @@ for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
        --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")
+    # Gate passed - validate confidence based on deliverables
+    echo "🔍 Validating agent confidence scores against deliverables..."
+
+    # Re-calculate confidence based on actual deliverables
+    if [ -n "$EXPECTED_FILES" ] && [ -f "$PROJECT_ROOT/.claude/skills/cfn-deliverable-validation/confidence-calculator.sh" ]; then
+      VALIDATED_CONFIDENCE=0
+
+      for agent_id in ${LOOP3_IDS//,/ }; do
+        # Get agent's reported confidence
+        agent_confidence=$(redis-cli get "swarm:${TASK_ID}:${agent_id}:confidence" 2>/dev/null || echo "0.5")
+
+        # Calculate deliverable-based confidence
+        deliverable_confidence=$("$PROJECT_ROOT/.claude/skills/cfn-deliverable-validation/confidence-calculator.sh" \
+          "$TASK_ID" "$agent_id" "$EXPECTED_FILES" "$PROJECT_ROOT")
+
+        echo "  Agent $agent_id: reported=$agent_confidence, deliverable-based=$deliverable_confidence"
+
+        # Use the lower of the two scores (inflation prevention)
+        if (( $(echo "$deliverable_confidence < $agent_confidence" | bc -l) )); then
+          echo "  ⚠️  Downgrading confidence for $agent_id (inflated score detected)"
+          VALIDATED_CONFIDENCE=$deliverable_confidence
+        else
+          VALIDATED_CONFIDENCE=$agent_confidence
+        fi
+      done
+
+      LOOP3_FINAL_CONFIDENCE=$VALIDATED_CONFIDENCE
+      echo "✅ Final validated Loop 3 confidence: $LOOP3_FINAL_CONFIDENCE"
+    else
+      # Store confidence (fallback method)
+      LOOP3_FINAL_CONFIDENCE=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
+        --task-id "$TASK_ID" \
+        --agent-ids "$LOOP3_IDS" \
+        --min-quorum "$MIN_QUORUM_LOOP3")
+    fi
   else
     # Gate failed - iterate Loop 3
     echo "❌ Gate check failed - iterating Loop 3"
@@ -878,6 +932,19 @@ EOF
   esac
 done
 
+# Cleanup Redis keys before exit
+cleanup_redis_keys() {
+  if [ -n "$TASK_ID" ]; then
+    echo "🧹 Cleaning up Redis keys for task $TASK_ID"
+    # Set TTL on remaining task keys (1 hour)
+    redis-cli keys "swarm:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+    redis-cli keys "cfn_loop:task:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+  fi
+}
+
+# Trap cleanup on script exit
+trap cleanup_redis_keys EXIT
+
 # Max iterations reached without success
 echo "❌ Max iterations ($MAX_ITERATIONS) reached without PROCEED decision"
 output_result "failed"