claude-flow-novice 2.14.9 → 2.14.10

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

@@ -707,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"
 
@@ -764,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"

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

@@ -707,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"
 
@@ -764,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"

package/claude-assets/skills/cfn-task-decomposition/task-decomposer.sh

@@ -0,0 +1,279 @@
+#!/bin/bash
+# Task Decomposition for Complex Operations
+# Breaks down complex tasks into smaller, tool-budget-efficient subtasks
+
+set -euo pipefail
+
+# Configuration
+TASK_ID="${1}"
+TASK_DESCRIPTION="${2}"
+TOOL_BUDGET="${3:-10}"  # Default 10 tool budget per agent
+COMPLEXITY_THRESHOLD="${4:-medium}"  # low, medium, high
+
+# 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}🔧 CFN Loop Task Decomposition${NC}"
+echo "Task ID: $TASK_ID"
+echo "Tool Budget: $TOOL_BUDGET per agent"
+echo "Complexity: $COMPLEXITY_THRESHOLD"
+echo ""
+
+# Function to analyze task complexity
+analyze_task_complexity() {
+    local description="$1"
+    local complexity_score=0
+
+    # File operation indicators
+    if echo "$description" | grep -qiE "(fix|create|modify|update|delete|write).*file"; then
+        ((complexity_score += 3))
+    fi
+
+    # Directory exploration indicators
+    if echo "$description" | grep -qiE "(explore|find|search|scan|directory|folder)"; then
+        ((complexity_score += 2))
+    fi
+
+    # Multiple component indicators
+    if echo "$description" | grep -qiE "(multiple|batch|all|every|comprehensive)"; then
+        ((complexity_score += 4))
+    fi
+
+    # TypeScript/Complex file indicators
+    if echo "$description" | grep -qiE "(typescript|tsx|interface|type|complex)"; then
+        ((complexity_score += 2))
+    fi
+
+    # Dependency analysis indicators
+    if echo "$description" | grep -qiE "(dependency|import|require|module)"; then
+        ((complexity_score += 2))
+    fi
+
+    echo "$complexity_score"
+}
+
+# Function to decompose TypeScript error fixing tasks
+decompose_typescript_task() {
+    local task_id="$1"
+    local description="$2"
+    local output_file=".claude/skills/cfn-task-decomposition/${task_id}-subtasks.json"
+
+    echo -e "${YELLOW}Decomposing TypeScript task...${NC}"
+
+    # Create subtasks
+    cat > "$output_file" << EOF
+{
+  "task_id": "$task_id",
+  "original_task": "$description",
+  "decomposition_strategy": "typescript-error-fixing",
+  "subtasks": [
+    {
+      "subtask_id": "${task_id}-recon",
+      "title": "Directory Reconnaissance",
+      "description": "Explore project structure and identify TypeScript files needing fixes",
+      "agent_type": "researcher",
+      "tool_budget": 5,
+      "expected_tools": ["find", "grep", "Read", "Glob"],
+      "deliverables": ["file-list.txt", "error-classification.json"],
+      "estimated_duration": "5-10 minutes"
+    },
+    {
+      "subtask_id": "${task_id}-pattern",
+      "title": "Error Pattern Analysis",
+      "description": "Analyze TypeScript errors and identify common patterns",
+      "agent_type": "analyst",
+      "tool_budget": 8,
+      "expected_tools": ["Read", "Grep", "Bash"],
+      "deliverables": ["error-patterns.json", "fix-strategy.md"],
+      "estimated_duration": "10-15 minutes"
+    },
+    {
+      "subtask_id": "${task_id}-fix",
+      "title": "File-by-File Fixes",
+      "description": "Fix TypeScript errors in identified files using patterns",
+      "agent_type": "backend-developer",
+      "tool_budget": 15,
+      "expected_tools": ["Read", "Edit", "Write", "Bash"],
+      "deliverables": ["fixed-files/", "fix-summary.json"],
+      "estimated_duration": "20-30 minutes",
+      "batch_processing": {
+        "max_files_per_batch": 3,
+        "batches_total": 5
+      }
+    },
+    {
+      "subtask_id": "${task_id}-validate",
+      "title": "Validation and Testing",
+      "description": "Validate fixes and run TypeScript compilation",
+      "agent_type": "tester",
+      "tool_budget": 10,
+      "expected_tools": ["Bash", "Read", "Write"],
+      "deliverables": ["validation-report.json", "compilation-results.txt"],
+      "estimated_duration": "10-15 minutes"
+    }
+  ],
+  "coordination": {
+    "dependency_order": ["recon", "pattern", "fix", "validate"],
+    "redis_context_keys": {
+      "recon": "${task_id}:recon:results",
+      "pattern": "${task_id}:pattern:results",
+      "fix": "${task_id}:fix:results",
+      "validate": "${task_id}:validate:results"
+    }
+  }
+}
+EOF
+
+    echo -e "${GREEN}✓ Task decomposition created: $output_file${NC}"
+    echo "$output_file"
+}
+
+# Function to decompose file exploration tasks
+decompose_exploration_task() {
+    local task_id="$1"
+    local description="$2"
+    local output_file=".claude/skills/cfn-task-decomposition/${task_id}-subtasks.json"
+
+    echo -e "${YELLOW}Decomposing exploration task...${NC}"
+
+    cat > "$output_file" << EOF
+{
+  "task_id": "$task_id",
+  "original_task": "$description",
+  "decomposition_strategy": "directory-exploration",
+  "subtasks": [
+    {
+      "subtask_id": "${task_id}-scan",
+      "title": "Targeted Directory Scan",
+      "description": "Scan specific directories for target files using ripgrep",
+      "agent_type": "researcher",
+      "tool_budget": 6,
+      "expected_tools": ["Bash", "rg", "Glob", "Read"],
+      "deliverables": ["target-files.txt", "directory-map.json"],
+      "estimated_duration": "5-8 minutes"
+    },
+    {
+      "subtask_id": "${task_id}-analyze",
+      "title": "File Content Analysis",
+      "description": "Analyze found files to understand structure and patterns",
+      "agent_type": "analyst",
+      "tool_budget": 8,
+      "expected_tools": ["Read", "Grep", "Write"],
+      "deliverables": ["file-analysis.json", "content-summary.md"],
+      "estimated_duration": "8-12 minutes"
+    }
+  ]
+}
+EOF
+
+    echo -e "${GREEN}✓ Task decomposition created: $output_file${NC}"
+    echo "$output_file"
+}
+
+# Function to create task-specific agent prompts
+create_agent_prompts() {
+    local subtasks_file="$1"
+    local prompts_dir=".claude/skills/cfn-task-decomposition/prompts"
+
+    mkdir -p "$prompts_dir"
+
+    # Extract subtask information
+    local task_id=$(jq -r '.task_id' "$subtasks_file")
+    local strategy=$(jq -r '.decomposition_strategy' "$subtasks_file")
+
+    # Generate prompts for each subtask
+    jq -r '.subtasks[] | @base64' "$subtasks_file" | while read -r subtask_b64; do
+        local subtask=$(echo "$subtask_b64" | base64 -d)
+        local subtask_id=$(echo "$subtask" | jq -r '.subtask_id')
+        local title=$(echo "$subtask" | jq -r '.title')
+        local description=$(echo "$subtask" | jq -r '.description')
+        local tool_budget=$(echo "$subtask" | jq -r '.tool_budget')
+        local deliverables=$(echo "$subtask" | jq -r '.deliverables[]')
+
+        cat > "$prompts_dir/${subtask_id}-prompt.md" << EOF
+# Task: $title
+
+## Context
+You are working on subtask "${subtask_id}" of the larger task "${task_id}".
+
+## Your Mission
+$description
+
+## Tool Budget Optimization
+You have **$tool_budget tool uses** available. Use them efficiently:
+
+### Recommended Tool Sequence:
+1. **Exploration tools** (Read, Glob, Bash) - 2-3 uses
+2. **Analysis tools** (Grep, Read) - 2-3 uses
+3. **Implementation tools** (Edit, Write) - 3-5 uses
+4. **Validation tools** (Bash, Read) - 1-2 uses
+
+### Efficiency Tips:
+- **Batch operations**: Read multiple files in one tool use when possible
+- **Targeted searches**: Use specific patterns instead of broad scans
+- **Early validation**: Check results after each major step
+- **Combine tool uses**: Use compound commands to reduce tool count
+
+## Expected Deliverables
+$deliverables
+
+## Success Criteria
+- All deliverables created with high quality
+- Tool budget not exceeded
+- Results passed to next subtask via Redis
+
+## Redis Context
+- Store results in: \`${task_id}:${subtask_id}:results\`
+- Use confidence scoring based on deliverable completion
+- Signal completion via Redis LPUSH to \`${task_id}:${subtask_id}:done\`
+EOF
+
+        echo -e "${GREEN}✓ Created prompt for $subtask_id${NC}"
+    done
+}
+
+# Main execution
+main() {
+    local complexity_score=$(analyze_task_complexity "$TASK_DESCRIPTION")
+    echo -e "${YELLOW}Task Complexity Score: $complexity_score${NC}"
+
+    local decomposition_file=""
+
+    # Determine decomposition strategy based on task type
+    if echo "$TASK_DESCRIPTION" | grep -qiE "(typescript|tsx|ts27|ts23|error|fix)"; then
+        decomposition_file=$(decompose_typescript_task "$TASK_ID" "$TASK_DESCRIPTION")
+    elif echo "$TASK_DESCRIPTION" | grep -qiE "(explore|find|search|scan)"; then
+        decomposition_file=$(decompose_exploration_task "$TASK_ID" "$TASK_DESCRIPTION")
+    else
+        echo -e "${YELLOW}Using general task decomposition...${NC}"
+        decomposition_file=$(decompose_typescript_task "$TASK_ID" "$TASK_DESCRIPTION")
+    fi
+
+    # Create agent prompts
+    if [ -n "$decomposition_file" ] && [ -f "$decomposition_file" ]; then
+        create_agent_prompts "$decomposition_file"
+
+        echo -e "\n${GREEN}=== Task Decomposition Complete ===${NC}"
+        echo -e "📄 ${BLUE}Decomposition file:${NC} $decomposition_file"
+        echo -e "🤖 ${BLUE}Agent prompts:${NC} .claude/skills/cfn-task-decomposition/prompts/"
+        echo -e "💡 ${BLUE}Strategy:${NC} Break complex task into tool-budget-efficient subtasks"
+
+        # Store decomposition info in Redis for coordinator
+        if command -v redis-cli >/dev/null 2>&1; then
+            redis-cli set "${TASK_ID}:decomposition" "$(cat "$decomposition_file")" >/dev/null
+            echo -e "📦 ${BLUE}Redis context stored:${NC} ${TASK_ID}:decomposition"
+        fi
+
+        return 0
+    else
+        echo -e "${RED}❌ Task decomposition failed${NC}"
+        return 1
+    fi
+}
+
+# Execute main function
+main "$@"

package/dist/agents/agent-loader.js

@@ -1,12 +1,145 @@
+"use strict";
 /**
  * Dynamic Agent Loader - Reads agent definitions from .claude/agents/ directory
  * Single source of truth for agent types in the system
- */ import { readFileSync, existsSync } from 'node:fs';
-import { glob } from 'glob';
-import { resolve, dirname } from 'node:path';
-import { parse as parseYaml } from 'yaml';
+ */ var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = this && this.__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+    if (pack || arguments.length === 2) for(var i = 0, l = from.length, ar; i < l; i++){
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.refreshAgents = exports.getAgentsByCategory = exports.isValidAgentType = exports.searchAgents = exports.getAgentCategories = exports.getAllAgents = exports.getAgent = exports.getAvailableAgentTypes = exports.agentLoader = exports.AgentLoader = void 0;
+exports.resolveLegacyAgentType = resolveLegacyAgentType;
+var node_fs_1 = require("node:fs");
+var glob_1 = require("glob");
+var node_path_1 = require("node:path");
+var yaml_1 = require("yaml");
 // Legacy agent type mapping for backward compatibility
-const LEGACY_AGENT_MAPPING = {
+var LEGACY_AGENT_MAPPING = {
     analyst: 'code-analyzer',
     coordinator: 'hierarchical-coordinator',
     optimizer: 'perf-analyzer',
@@ -17,38 +150,40 @@ const LEGACY_AGENT_MAPPING = {
 };
 /**
  * Resolve legacy agent types to current equivalents
- */ export function resolveLegacyAgentType(legacyType) {
+ */ function resolveLegacyAgentType(legacyType) {
     return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
 }
-export class AgentLoader {
-    agentCache = new Map();
-    categoriesCache = [];
-    lastLoadTime = 0;
-    CACHE_EXPIRY = 60_000;
-    getAgentsDirectory() {
-        let currentDir = process.cwd();
+var AgentLoader = /** @class */ function() {
+    function AgentLoader() {
+        this.agentCache = new Map();
+        this.categoriesCache = [];
+        this.lastLoadTime = 0;
+        this.CACHE_EXPIRY = 60000; // 1 minute cache
+    }
+    AgentLoader.prototype.getAgentsDirectory = function() {
+        var currentDir = process.cwd();
         while(currentDir !== '/'){
-            const claudeAgentsPath = resolve(currentDir, '.claude', 'agents');
-            if (existsSync(claudeAgentsPath)) {
+            var claudeAgentsPath = (0, node_path_1.resolve)(currentDir, '.claude', 'agents');
+            if ((0, node_fs_1.existsSync)(claudeAgentsPath)) {
                 return claudeAgentsPath;
             }
-            currentDir = dirname(currentDir);
+            currentDir = (0, node_path_1.dirname)(currentDir);
         }
-        return resolve(process.cwd(), '.claude', 'agents');
-    }
-    parseAgentFile(filePath) {
+        return (0, node_path_1.resolve)(process.cwd(), '.claude', 'agents');
+    };
+    AgentLoader.prototype.parseAgentFile = function(filePath) {
         try {
-            const content = readFileSync(filePath, 'utf-8');
-            const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+            var content = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+            var frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
             if (!frontmatterMatch) {
-                console.warn(`No frontmatter found in ${filePath}`);
+                console.warn("No frontmatter found in ".concat(filePath));
                 return null;
             }
-            const [, yamlContent, markdownContent] = frontmatterMatch;
-            const frontmatter = parseYaml(yamlContent);
-            const description = frontmatter.description;
+            var yamlContent = frontmatterMatch[1], markdownContent = frontmatterMatch[2];
+            var frontmatter = (0, yaml_1.parse)(yamlContent);
+            var description = frontmatter.description;
             if (!frontmatter.name || !description) {
-                console.warn(`Missing required fields (name, description) in ${filePath}`);
+                console.warn("Missing required fields (name, description) in ".concat(filePath));
                 return null;
             }
             return {
@@ -69,129 +204,13 @@ export class AgentLoader {
                 content: markdownContent.trim()
             };
         } catch (error) {
-            console.error(`Error parsing agent file ${filePath}:`, error);
+            console.error("Error parsing agent file ".concat(filePath, ":"), error);
             return null;
         }
-    }
-    parseTools(frontmatter) {
-        const extractTools = (input)=>{
+    };
+    AgentLoader.prototype.parseTools = function(frontmatter) {
+        var extractTools = function(input) {
             if (Array.isArray(input)) return input.map(String);
-            if (typeof input === 'string') {
-                return input.split(/[,\s]+/).map((t)=>t.trim()).filter((t)=>t.length > 0);
-            }
-            return [];
-        };
-        // Safely handle tools and capabilities.tools
-        const toolsFromFrontmatter = frontmatter.tools ? extractTools(frontmatter.tools) : [];
-        const toolsFromCapabilities = frontmatter.capabilities && typeof frontmatter.capabilities === 'object' ? extractTools(Object(frontmatter.capabilities).tools) : [];
-        return [
-            ...toolsFromFrontmatter,
-            ...toolsFromCapabilities
-        ];
-    }
-    async loadAgents() {
-        const agentsDir = this.getAgentsDirectory();
-        if (!existsSync(agentsDir)) {
-            console.warn(`Agents directory not found: ${agentsDir}`);
-            return;
-        }
-        const agentFiles = await new Promise((resolve, reject)=>{
-            glob('**/*.md', {
-                cwd: agentsDir,
-                ignore: [
-                    '**/README.md',
-                    '**/MIGRATION_SUMMARY.md'
-                ],
-                absolute: true
-            }, (err, matches)=>{
-                if (err) reject(err);
-                else resolve(matches);
-            });
-        });
-        this.agentCache.clear();
-        this.categoriesCache = [];
-        const categoryMap = new Map();
-        for (const filePath of agentFiles){
-            const agent = this.parseAgentFile(filePath);
-            if (agent) {
-                this.agentCache.set(agent.name, agent);
-                const relativePath = filePath.replace(agentsDir, '');
-                const pathParts = relativePath.split('/');
-                const category = pathParts[1] || 'uncategorized';
-                if (!categoryMap.has(category)) {
-                    categoryMap.set(category, []);
-                }
-                categoryMap.get(category).push(agent);
-            }
-        }
-        this.categoriesCache = Array.from(categoryMap.entries()).map(([name, agents])=>({
-                name,
-                agents: agents.sort((a, b)=>a.name.localeCompare(b.name))
-            }));
-        this.lastLoadTime = Date.now();
-    }
-    // Rest of the methods remain similar to the original implementation
-    needsRefresh() {
-        return Date.now() - this.lastLoadTime > this.CACHE_EXPIRY;
-    }
-    async ensureLoaded() {
-        if (this.agentCache.size === 0 || this.needsRefresh()) {
-            await this.loadAgents();
-        }
-    }
-    async getAvailableAgentTypes() {
-        await this.ensureLoaded();
-        const currentTypes = Array.from(this.agentCache.keys());
-        const legacyTypes = Object.keys(LEGACY_AGENT_MAPPING);
-        return Array.from(new Set([
-            ...currentTypes,
-            ...legacyTypes
-        ])).sort();
-    }
-    async getAgent(name) {
-        await this.ensureLoaded();
-        return this.agentCache.get(name) || this.agentCache.get(resolveLegacyAgentType(name)) || null;
-    }
-    async getAllAgents() {
-        await this.ensureLoaded();
-        return Array.from(this.agentCache.values()).sort((a, b)=>a.name.localeCompare(b.name));
-    }
-    async getAgentCategories() {
-        await this.ensureLoaded();
-        return this.categoriesCache;
-    }
-    async searchAgents(query) {
-        await this.ensureLoaded();
-        const lowerQuery = query.toLowerCase();
-        return Array.from(this.agentCache.values()).filter((agent)=>agent.name.toLowerCase().includes(lowerQuery) || agent.description.toLowerCase().includes(lowerQuery) || agent.capabilities?.some((cap)=>cap.toLowerCase().includes(lowerQuery)));
-    }
-    async isValidAgentType(name) {
-        await this.ensureLoaded();
-        return this.agentCache.has(name) || this.agentCache.has(resolveLegacyAgentType(name));
-    }
-    async getAgentsByCategory(category) {
-        const categories = await this.getAgentCategories();
-        const found = categories.find((cat)=>cat.name === category);
-        return found?.agents || [];
-    }
-    async refresh() {
-        this.lastLoadTime = 0;
-        await this.loadAgents();
-    }
-}
-// Singleton instance
-export const agentLoader = new AgentLoader();
-// Convenience exports for use in other modules
-export const getAvailableAgentTypes = ()=>agentLoader.getAvailableAgentTypes();
-export const getAgent = (name)=>agentLoader.getAgent(name);
-export const getAllAgents = ()=>agentLoader.getAllAgents();
-export const getAgentCategories = ()=>agentLoader.getAgentCategories();
-export const searchAgents = (query)=>agentLoader.searchAgents(query);
-export const isValidAgentType = (name)=>agentLoader.isValidAgentType(name);
-export const getAgentsByCategory = (category)=>agentLoader.getAgentsByCategory(category);
-export const refreshAgents = ()=>agentLoader.refresh();
-
-//# sourceMappingURL=agent-loader.js.map.isArray(input)) return input.map(String);
             if (typeof input === 'string') {
                 return input.split(/[,\s]+/).map(function(t) {
                     return t.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.14.9",
+  "version": "2.14.10",
   "description": "AI agent orchestration framework with namespace-isolated skills, agents, and CFN Loop validation. Safe installation with ~0.01% collision risk.",
   "main": "dist/index.js",
   "type": "module",