claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-task-intelligence/lib/integration/SKILL.md

@@ -0,0 +1,339 @@
+#!/bin/bash
+
+# cfn-task-intelligence.sh
+# Task Intelligence Integration Layer for CFN Loop Orchestration
+
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DB_PATH="${SCRIPT_DIR}/../cfn-memory-persistence/task_intelligence.db"
+LOG_FILE="${SCRIPT_DIR}/task_intelligence.log"
+
+# Initialize database
+init_database() {
+    mkdir -p "$(dirname "$DB_PATH")"
+    sqlite3 "$DB_PATH" <<EOF
+CREATE TABLE IF NOT EXISTS task_classifications (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_hash TEXT UNIQUE,
+    description TEXT,
+    category TEXT,
+    subcategories TEXT,
+    recommended_agents TEXT,
+    confidence REAL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS complexity_estimates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_hash TEXT,
+    estimated_iterations INTEGER,
+    confidence REAL,
+    factors TEXT,
+    mode TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (task_hash) REFERENCES task_classifications(task_hash)
+);
+
+CREATE TABLE IF NOT EXISTS specialist_recommendations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    loop3_agents TEXT,
+    feedback_themes TEXT,
+    recurring_count INTEGER,
+    recommended_specialist TEXT,
+    reasoning TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS execution_outcomes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_hash TEXT,
+    actual_iterations INTEGER,
+    success BOOLEAN,
+    agents_used TEXT,
+    specialists_added TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (task_hash) REFERENCES task_classifications(task_hash)
+);
+EOF
+}
+
+# Logging function
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
+}
+
+# Generate task hash
+generate_task_hash() {
+    local description="$1"
+    echo -n "$description" | sha256sum | cut -d' ' -f1
+}
+
+# Classify task
+classify_task() {
+    local description="$1"
+    local task_hash
+    task_hash=$(generate_task_hash "$description")
+    
+    # Check cache first
+    local cached_result
+    cached_result=$(sqlite3 "$DB_PATH" "SELECT category, subcategories, recommended_agents, confidence FROM task_classifications WHERE task_hash='$task_hash'" 2>/dev/null || echo "")
+    
+    if [[ -n "$cached_result" ]]; then
+        IFS='|' read -r category subcategories agents confidence <<< "$cached_result"
+        echo "{\"category\":\"$category\",\"subcategories\":[$subcategories],\"recommended_agents\":[$agents],\"confidence\":$confidence}"
+        return
+    fi
+    
+    # Classification logic
+    local category="general"
+    local subcategories="[]"
+    local agents="[]"
+    local confidence=0.5
+    
+    if [[ "$description" =~ (frontend|ui|ux|interface|component) ]]; then
+        category="frontend"
+        subcategories='["ui","state-management"]'
+        agents='["frontend-developer","ui-ux-designer"]'
+        confidence=0.85
+    elif [[ "$description" =~ (backend|api|server|database|service) ]]; then
+        category="backend"
+        subcategories='["api","data-layer"]'
+        agents='["backend-developer","database-administrator"]'
+        confidence=0.82
+    elif [[ "$description" =~ (security|auth|authentication|authorization|encryption) ]]; then
+        category="security"
+        subcategories='["authentication","authorization"]'
+        agents='["security-specialist","backend-developer"]'
+        confidence=0.88
+    elif [[ "$description" =~ (performance|optimization|speed|latency|cache) ]]; then
+        category="performance"
+        subcategories='["optimization","monitoring"]'
+        agents='["performance-engineer","backend-developer"]'
+        confidence=0.80
+    elif [[ "$description" =~ (test|testing|quality|assurance|qa) ]]; then
+        category="testing"
+        subcategories='["unit-testing","integration-testing"]'
+        agents='["qa-engineer","test-automation-specialist"]'
+        confidence=0.83
+    fi
+    
+    # Cache result
+    sqlite3 "$DB_PATH" "INSERT OR REPLACE INTO task_classifications (task_hash, description, category, subcategories, recommended_agents, confidence) VALUES ('$task_hash', '$(echo "$description" | sed "s/'/''/g")', '$category', '$subcategories', '$agents', $confidence)"
+    
+    echo "{\"category\":\"$category\",\"subcategories\":$subcategories,\"recommended_agents\":$agents,\"confidence\":$confidence}"
+}
+
+# Estimate complexity
+estimate_complexity() {
+    local description="$1"
+    local task_hash
+    task_hash=$(generate_task_hash "$description")
+    
+    # Check cache
+    local cached_result
+    cached_result=$(sqlite3 "$DB_PATH" "SELECT estimated_iterations, confidence, factors, mode FROM complexity_estimates WHERE task_hash='$task_hash'" 2>/dev/null || echo "")
+    
+    if [[ -n "$cached_result" ]]; then
+        IFS='|' read -r iterations confidence factors mode <<< "$cached_result"
+        echo "{\"estimated_iterations\":$iterations,\"confidence\":$confidence,\"factors\":[$factors],\"mode\":\"$mode\"}"
+        return
+    fi
+    
+    # Complexity estimation logic
+    local iterations=3
+    local confidence=0.7
+    local factors="[]"
+    local mode="standard"
+    
+    # Analyze factors
+    local factor_list=()
+    
+    if [[ "$description" =~ (new|novel|first-time|initial) ]]; then
+        ((iterations += 2))
+        factor_list+=('"new-feature"')
+        confidence=$(echo "$confidence - 0.1" | bc)
+    fi
+    
+    if [[ "$description" =~ (cross|multiple|several|different) ]]; then
+        ((iterations += 1))
+        factor_list+=('"cross-component"')
+        confidence=$(echo "$confidence - 0.05" | bc)
+    fi
+    
+    if [[ "$description" =~ (test|testing|validate|verify) ]]; then
+        ((iterations += 1))
+        factor_list+=('"testing-required"')
+    fi
+    
+    if [[ "$description" =~ (complex|difficult|challenging|advanced) ]]; then
+        ((iterations += 2))
+        factor_list+=('"high-complexity"')
+        confidence=$(echo "$confidence - 0.1" | bc)
+    fi
+    
+    if [[ "$description" =~ (urgent|critical|immediate) ]]; then
+        mode="fast-track"
+        iterations=$((iterations / 2 + 1))
+    fi
+    
+    # Ensure minimum iterations
+    if [[ $iterations -lt 2 ]]; then
+        iterations=2
+    fi
+    
+    # Ensure maximum iterations
+    if [[ $iterations -gt 10 ]]; then
+        iterations=10
+    fi
+    
+    # Format factors
+    if [[ ${#factor_list[@]} -gt 0 ]]; then
+        factors=$(IFS=,; echo "${factor_list[*]}")
+    fi
+    
+    # Cache result
+    sqlite3 "$DB_PATH" "INSERT OR REPLACE INTO complexity_estimates (task_hash, estimated_iterations, confidence, factors, mode) VALUES ('$task_hash', $iterations, $confidence, '[$factors]', '$mode')"
+    
+    echo "{\"estimated_iterations\":$iterations,\"confidence\":$confidence,\"factors\":[$factors],\"mode\":\"$mode\"}"
+}
+
+# Recommend specialist
+recommend_specialist() {
+    local current_loop3="$1"
+    local feedback_themes="$2"
+    local recurring_count="$3"
+    
+    local specialist=""
+    local reasoning=""
+    local new_agents="$current_loop3"
+    
+    # Analyze feedback themes
+    if [[ "$feedback_themes" =~ (security|auth|authentication|authorization) ]] && [[ $recurring_count -ge 3 ]]; then
+        specialist="security-specialist"
+        reasoning="Recurring feedback themes: security, authentication. Added as number of occurrences reached required threshold."
+        if [[ ! "$current_loop3" =~ security-specialist ]]; then
+            new_agents="$current_loop3,security-specialist"
+        fi
+    elif [[ "$feedback_themes" =~ (performance|optimization|speed|latency) ]] && [[ $recurring_count -ge 3 ]]; then
+        specialist="performance-engineer"
+        reasoning="Recurring feedback themes: performance, optimization. Added as number of occurrences reached required threshold."
+        if [[ ! "$current_loop3" =~ performance-engineer ]]; then
+            new_agents="$current_loop3,performance-engineer"
+        fi
+    elif [[ "$feedback_themes" =~ (test|testing|quality|assurance) ]] && [[ $recurring_count -ge 3 ]]; then
+        specialist="qa-engineer"
+        reasoning="Recurring feedback themes: testing, quality assurance. Added as number of occurrences reached required threshold."
+        if [[ ! "$current_loop3" =~ qa-engineer ]]; then
+            new_agents="$current_loop3,qa-engineer"
+        fi
+    elif [[ "$feedback_themes" =~ (ui|ux|design|interface) ]] && [[ $recurring_count -ge 3 ]]; then
+        specialist="ui-ux-designer"
+        reasoning="Recurring feedback themes: UI/UX, design. Added as number of occurrences reached required threshold."
+        if [[ ! "$current_loop3" =~ ui-ux-designer ]]; then
+            new_agents="$current_loop3,ui-ux-designer"
+        fi
+    fi
+    
+    # Store recommendation
+    sqlite3 "$DB_PATH" "INSERT INTO specialist_recommendations (loop3_agents, feedback_themes, recurring_count, recommended_specialist, reasoning) VALUES ('$current_loop3', '$feedback_themes', $recurring_count, '$specialist', '$(echo "$reasoning" | sed "s/'/''/g")')"
+    
+    # Format new agents as array
+    local agents_array="[\"$(echo "$new_agents" | sed 's/,/","/g')\"]"
+    
+    echo "{\"add_specialist\":\"$specialist\",\"reasoning\":\"$reasoning\",\"new_loop3_agents\":$agents_array}"
+}
+
+# Full analysis
+full_analysis() {
+    local description="$1"
+    
+    local classification
+    classification=$(classify_task "$description")
+    
+    local complexity
+    complexity=$(estimate_complexity "$description")
+    
+    echo "{\"classification\":$classification,\"complexity\":$complexity}"
+}
+
+# Main execution
+main() {
+    init_database
+    
+    local mode=""
+    local task_description=""
+    local current_loop3=""
+    local feedback_themes=""
+    local recurring_count=0
+    
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --mode)
+                mode="$2"
+                shift 2
+                ;;
+            --task-description)
+                task_description="$2"
+                shift 2
+                ;;
+            --current-loop3)
+                current_loop3="$2"
+                shift 2
+                ;;
+            --feedback-themes)
+                feedback_themes="$2"
+                shift 2
+                ;;
+            --recurring-count)
+                recurring_count="$2"
+                shift 2
+                ;;
+            *)
+                log "Unknown option: $1"
+                exit 1
+                ;;
+        esac
+    done
+    
+    # Execute based on mode
+    case "$mode" in
+        classify)
+            if [[ -z "$task_description" ]]; then
+                log "Error: --task-description required for classify mode"
+                exit 1
+            fi
+            classify_task "$task_description"
+            ;;
+        complexity)
+            if [[ -z "$task_description" ]]; then
+                log "Error: --task-description required for complexity mode"
+                exit 1
+            fi
+            estimate_complexity "$task_description"
+            ;;
+        specialist)
+            if [[ -z "$current_loop3" || -z "$feedback_themes" ]]; then
+                log "Error: --current-loop3 and --feedback-themes required for specialist mode"
+                exit 1
+            fi
+            recommend_specialist "$current_loop3" "$feedback_themes" "$recurring_count"
+            ;;
+        all)
+            if [[ -z "$task_description" ]]; then
+                log "Error: --task-description required for all mode"
+                exit 1
+            fi
+            full_analysis "$task_description"
+            ;;
+        *)
+            log "Error: Invalid mode. Use classify, complexity, specialist, or all"
+            exit 1
+            ;;
+    esac
+}
+
+# Execute main function
+main "$@"

package/.claude/skills/cfn-task-intelligence/lib/integration/learning-loop.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# learning-loop.sh
+# Updates task intelligence models based on execution outcomes
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TASK_INTELLIGENCE_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Parse arguments
+TASK_ID=""
+FINAL_OUTCOME=""
+ACTUAL_ITERATIONS=""
+FINAL_CONFIDENCE=""
+CLASSIFICATION_PREDICTION=""
+COMPLEXITY_PREDICTION=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --task-id) TASK_ID="$2"; shift 2 ;;
+        --final-outcome) FINAL_OUTCOME="$2"; shift 2 ;;  # success, failure, partial
+        --actual-iterations) ACTUAL_ITERATIONS="$2"; shift 2 ;;
+        --final-confidence) FINAL_CONFIDENCE="$2"; shift 2 ;;
+        --classification-file) CLASSIFICATION_PREDICTION="$(cat "$2")"; shift 2 ;;
+        --complexity-file) COMPLEXITY_PREDICTION="$(cat "$2")"; shift 2 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+done
+
+# Validate inputs
+if [[ -z "$TASK_ID" || -z "$FINAL_OUTCOME" ]]; then
+    echo "Error: --task-id and --final-outcome are required" >&2
+    exit 1
+fi
+
+echo "Processing learning data for task $TASK_ID..." >&2
+
+# Calculate accuracy metrics
+classification_accuracy="unknown"
+complexity_accuracy="unknown"
+
+if [[ -n "${CLASSIFICATION_PREDICTION:-}" && -n "${COMPLEXITY_PREDICTION:-}" ]]; then
+    # Extract predicted values
+    predicted_category=$(echo "$CLASSIFICATION_PREDICTION" | jq -r '.category // "unknown"')
+    predicted_iterations=$(echo "$COMPLEXITY_PREDICTION" | jq -r '.estimated_iterations // 0')
+    predicted_confidence=$(echo "$COMPLEXITY_PREDICTION" | jq -r '.confidence // 0')
+    
+    # Calculate classification accuracy based on outcome
+    case "$FINAL_OUTCOME" in
+        "success")
+            classification_accuracy="correct"
+            ;;
+        "failure")
+            classification_accuracy="incorrect"
+            ;;
+        *)
+            classification_accuracy="partial"
+            ;;
+    esac
+    
+    # Calculate complexity accuracy
+    if [[ -n "${ACTUAL_ITERATIONS:-}" && "$ACTUAL_ITERATIONS" != "0" ]]; then
+        actual_iter=$(echo "$ACTUAL_ITERATIONS" | jq -r '. // 0')
+        predicted_iter=$(echo "$predicted_iterations" | jq -r '. // 0')
+        
+        # Calculate percentage error
+        if [[ "$predicted_iter" != "0" ]]; then
+            error_pct=$(echo "scale=2; ($actual_iter - $predicted_iter) / $predicted_iter * 100" | bc -l 2>/dev/null || echo "unknown")
+            complexity_accuracy=$(echo "$error_pct" | jq -R 'if . != "unknown" then (. | tonumber | if . < 20 then "accurate" elif . < 50 then "moderate" else "inaccurate" end) else "unknown" end')
+        fi
+    fi
+fi
+
+# Generate learning record
+learning_record=$(jq -n \
+    --arg task_id "$TASK_ID" \
+    --arg outcome "$FINAL_OUTCOME" \
+    --argjson actual_iterations "${ACTUAL_ITERATIONS:-0}" \
+    --argjson final_confidence "${FINAL_CONFIDENCE:-0}" \
+    --arg classification_accuracy "$classification_accuracy" \
+    --arg complexity_accuracy "$complexity_accuracy" \
+    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    '{
+        task_id: $task_id,
+        execution_outcome: $outcome,
+        actual_iterations: $actual_iterations,
+        final_confidence: $final_confidence,
+        accuracy_metrics: {
+            classification: $classification_accuracy,
+            complexity: $complexity_accuracy
+        },
+        timestamp: $timestamp
+    }')
+
+# Store learning data
+LEARNING_DIR="/tmp/cfn-task-intelligence/learning"
+mkdir -p "$LEARNING_DIR"
+
+# Append to learning log
+echo "$learning_record" >> "$LEARNING_DIR/learning_log.jsonl"
+
+# Also save individual record
+echo "$learning_record" > "$LEARNING_DIR/task_${TASK_ID}_learning.json"
+
+# Generate summary statistics (last 100 records)
+generate_summary() {
+    if [[ -f "$LEARNING_DIR/learning_log.jsonl" ]]; then
+        tail -n 100 "$LEARNING_DIR/learning_log.jsonl" | jq -s '
+            group_by(.accuracy_metrics.classification) | 
+            map({classification: .[0].accuracy_metrics.classification, count: length}) |
+            sort_by(.count) |
+            reverse
+        ' > "$LEARNING_DIR/classification_accuracy_summary.json"
+        
+        tail -n 100 "$LEARNING_DIR/learning_log.jsonl" | jq -s '
+            group_by(.accuracy_metrics.complexity) |
+            map({complexity: .[0].accuracy_metrics.complexity, count: length}) |
+            sort_by(.count) |
+            reverse
+        ' > "$LEARNING_DIR/complexity_accuracy_summary.json"
+    fi
+}
+
+generate_summary
+
+echo "Learning data processed for task $TASK_ID" >&2
+echo "$learning_record"

package/.claude/skills/cfn-task-intelligence/lib/integration/post-feedback-hook.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# post-feedback-hook.sh
+# Hook that runs after each iteration to analyze feedback and recommend specialists
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TASK_INTELLIGENCE_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Parse arguments
+TASK_ID=""
+CURRENT_AGENTS=""
+FEEDBACK_SUMMARY=""
+CONFIDENCE_HISTORY=""
+ITERATION_COUNT=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --task-id) TASK_ID="$2"; shift 2 ;;
+        --current-loop3) CURRENT_AGENTS="$2"; shift 2 ;;
+        --feedback-summary) FEEDBACK_SUMMARY="$2"; shift 2 ;;
+        --confidence-history) CONFIDENCE_HISTORY="$2"; shift 2 ;;
+        --iteration-count) ITERATION_COUNT="$2"; shift 2 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+done
+
+# Validate inputs
+if [[ -z "$TASK_ID" || -z "$CURRENT_AGENTS" || -z "$FEEDBACK_SUMMARY" ]]; then
+    echo "Error: --task-id, --current-loop3, and --feedback-summary are required" >&2
+    exit 1
+fi
+
+echo "Analyzing feedback for task $TASK_ID..." >&2
+
+# Extract feedback themes using simple keyword detection
+extract_feedback_themes() {
+    local summary="$1"
+    local themes=()
+    
+    if echo "$summary" | grep -qi -E "(security|auth|jwt|token|password|credential)"; then
+        themes+=("security")
+    fi
+    
+    if echo "$summary" | grep -qi -E "(performance|slow|fast|optimize|speed|memory|cpu)"; then
+        themes+=("performance")
+    fi
+    
+    if echo "$summary" | grep -qi -E "(test|coverage|unit|integration|e2e|spec)"; then
+        themes+=("testing")
+    fi
+    
+    if echo "$summary" | grep -qi -E "(architecture|design|pattern|structure|modular)"; then
+        themes+=("architecture")
+    fi
+    
+    if echo "$summary" | grep -qi -E "(ui|ux|frontend|interface|user|design)"; then
+        themes+=("ui-ux")
+    fi
+    
+    printf '%s\n' "${themes[@]}"
+}
+
+# Extract themes from feedback
+feedback_themes=($(extract_feedback_themes "$FEEDBACK_SUMMARY"))
+
+# Count recurring themes
+declare -A theme_counts
+for theme in "${feedback_themes[@]}"; do
+    theme_counts["$theme"]=$((${theme_counts["$theme"]:-0} + 1))
+done
+
+# Find themes that recur multiple times
+recurring_themes=()
+for theme in "${!theme_counts[@]}"; do
+    if [[ ${theme_counts["$theme"]} -ge 2 ]]; then
+        recurring_themes+=("$theme")
+    fi
+done
+
+# Generate output
+output=$(jq -n \
+    --arg task_id "$TASK_ID" \
+    --arg current_agents "$CURRENT_AGENTS" \
+    --arg feedback_summary "$FEEDBACK_SUMMARY" \
+    --argjson feedback_themes "$(printf '%s\n' "${feedback_themes[@]}" | jq -R . | jq -s '.')" \
+    --argjson recurring_themes "$(printf '%s\n' "${recurring_themes[@]}" | jq -R . | jq -s '.')" \
+    --argjson iteration_count "${ITERATION_COUNT:-0}" \
+    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    '{
+        task_id: $task_id,
+        timestamp: $timestamp,
+        feedback_analysis: {
+            summary: $feedback_summary,
+            detected_themes: $feedback_themes,
+            recurring_themes: $recurring_themes,
+            iteration_count: $iteration_count | tonumber
+        }
+    }')
+
+# If there are recurring themes, recommend specialists
+if [[ ${#recurring_themes[@]} -gt 0 ]]; then
+    echo "Recurring themes detected: ${recurring_themes[*]}" >&2
+    
+    # Get specialist recommendation
+    specialist_result=$("$TASK_INTELLIGENCE_DIR/cfn-task-intelligence.sh" \
+        --mode specialist \
+        --current-loop3 "$CURRENT_AGENTS" \
+        --feedback-themes "$(IFS=','; echo "${recurring_themes[*]}")" \
+        --recurring-count "3")
+    
+    # Combine with output
+    output=$(echo "$output" | jq \
+        --argjson specialist "$specialist_result" \
+        '. + {specialist_recommendation: $specialist}')
+fi
+
+# Output the result
+echo "$output"
+
+# Also save to file for audit trail
+OUTPUT_DIR="/tmp/cfn-task-intelligence"
+mkdir -p "$OUTPUT_DIR"
+echo "$output" > "$OUTPUT_DIR/feedback_analysis_${TASK_ID}_$(date +%s).json"

package/.claude/skills/cfn-task-intelligence/lib/integration/pre-execution-hook.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TASK_INTELLIGENCE_DIR="$(dirname "$SCRIPT_DIR")"
+
+TASK_DESCRIPTION=""
+TASK_ID=""
+OUTPUT_FILE=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --task-description) TASK_DESCRIPTION="$2"; shift 2 ;;
+        --task-id) TASK_ID="$2"; shift 2 ;;
+        --output-file) OUTPUT_FILE="$2"; shift 2 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+done
+
+if [[ -z "$TASK_DESCRIPTION" || -z "$TASK_ID" ]]; then
+    echo "Error: --task-description and --task-id are required" >&2
+    exit 1
+fi
+
+OUTPUT_FILE="${OUTPUT_FILE:-/tmp/task_intelligence_${TASK_ID}.json}"
+
+echo "Classifying task..." >&2
+classification_result=$("$TASK_INTELLIGENCE_DIR/cfn-task-intelligence.sh" \
+    --task-description "$TASK_DESCRIPTION" \
+    --mode classify)
+
+echo "Estimating complexity..." >&2
+complexity_result=$("$TASK_INTELLIGENCE_DIR/cfn-task-intelligence.sh" \
+    --task-description "$TASK_DESCRIPTION" \
+    --mode complexity)
+
+integrated_output=$(jq -n \
+    --arg task_id "$TASK_ID" \
+    --argjson classification "$(echo "$classification_result" | jq .)" \
+    --argjson complexity "$(echo "$complexity_result" | jq .)" \
+    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    '{
+        task_id: $task_id,
+        timestamp: $timestamp,
+        task_classification: $classification,
+        complexity_estimation: $complexity,
+        orchestration_recommendations: {
+            initial_agents: $classification.recommended_agents,
+            estimated_iterations: $complexity.estimated_iterations,
+            suggested_mode: $complexity.mode,
+            confidence_level: ($classification.confidence + $complexity.confidence) / 2
+        }
+    }')
+
+echo "$integrated_output" > "$OUTPUT_FILE"
+
+echo "$integrated_output"
+
+echo "Task intelligence analysis saved to: $OUTPUT_FILE" >&2

package/.claude/skills/cfn-task-intelligence/lib/specialist/SKILL.md

@@ -0,0 +1,41 @@
+# Specialist Injection Skill
+
+## Purpose
+Dynamically add specialist agents to existing Loop 3 team based on recurring feedback themes.
+
+## Injection Strategies
+- Preserve existing team composition
+- Add specialists without removing current agents
+- Match specialist to specific feedback themes
+
+## Specialist Types
+- Security Specialist
+- Performance Engineer
+- Testing Expert
+- Architecture Consultant
+- Domain-Specific Experts
+
+## Usage
+```bash
+./recommend-specialist.sh \
+  --current-loop3 "backend-dev,coder" \
+  --feedback-themes "security,authentication,jwt" \
+  --recurring-count 3
+```
+
+## Decision Criteria
+1. Recurring feedback theme
+2. Keyword matching
+3. Iteration context
+4. Existing team composition
+
+## Output Components
+- Specialist to add
+- Reasoning for injection
+- Updated agent list
+- Context modification recommendations
+
+## Best Practices
+- Non-destructive team modification
+- Transparent decision process
+- Actionable recommendations