claude-flow-novice 2.14.32 → 2.14.33

package/.claude/skills/pre-edit-backup/backup.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+##############################################################################
+# Pre-Edit Backup Script - Creates safe file backups before modifications
+# Version: 1.0.0
+##############################################################################
+
+set -euo pipefail
+
+# Function to create backup of a file before editing
+create_backup() {
+    local file_path="$1"
+    local agent_id="${2:-unknown}"
+    local project_root="${3:-$(pwd)}"
+
+    # Validate inputs
+    if [[ -z "$file_path" ]]; then
+        echo "Error: File path is required" >&2
+        exit 1
+    fi
+
+    # Check if file exists
+    if [[ ! -f "$file_path" ]]; then
+        echo "Warning: File does not exist: $file_path" >&2
+        # Create empty backup path for new files
+        echo "$project_root/.backups/$agent_id/new-file-$(date +%s)-$(echo "$file_path" | tr '/' '_' | tr ' ' '_')"
+        return 0
+    fi
+
+    # Create backup directory structure
+    local backup_dir="$project_root/.backups/$agent_id"
+    local timestamp=$(date +%s)
+    local file_hash=$(md5sum "$file_path" | cut -d' ' -f1)
+    local backup_name="${timestamp}_${file_hash}"
+
+    # Create full backup path
+    local full_backup_path="$backup_dir/$backup_name"
+
+    # Create backup directory
+    mkdir -p "$full_backup_path"
+
+    # Copy original file to backup location
+    cp "$file_path" "$full_backup_path/original"
+
+    # Store backup metadata
+    cat > "$full_backup_path/metadata.json" << EOF
+{
+  "timestamp": "$timestamp",
+  "agent_id": "$agent_id",
+  "original_file": "$file_path",
+  "file_hash": "$file_hash",
+  "backup_path": "$full_backup_path",
+  "created_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EOF
+
+    # Create revert script
+    cat > "$full_backup_path/revert.sh" << EOF
+#!/bin/bash
+# Revert script for $file_path
+set -euo pipefail
+
+echo "Reverting file: $file_path"
+cp "$full_backup_path/original" "$file_path"
+echo "✅ File reverted successfully"
+EOF
+
+    chmod +x "$full_backup_path/revert.sh"
+
+    # Output backup path for caller
+    echo "$full_backup_path"
+
+    echo "✅ Backup created: $full_backup_path" >&2
+}
+
+# Main execution
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Script called directly
+    if [[ $# -lt 1 ]]; then
+        echo "Usage: $0 <file_path> [--agent-id <id>] [--project-root <path>]" >&2
+        exit 1
+    fi
+
+    file_path="$1"
+    agent_id="unknown"
+    project_root="$(pwd)"
+
+    # Parse optional arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --agent-id)
+                agent_id="$2"
+                shift 2
+                ;;
+            --project-root)
+                project_root="$2"
+                shift 2
+                ;;
+            *)
+                # Skip unknown arguments
+                shift
+                ;;
+        esac
+    done
+
+    create_backup "$file_path" "$agent_id" "$project_root"
+fi

package/claude-assets/agents/cfn-dev-team/coordinators/cfn-v3-coordinator.md

@@ -16,18 +16,16 @@ You coordinate CFN Loop v3 execution with Redis-based agent orchestration and CL
 
 Orchestrate CFN Loop v3 execution using Redis coordination for CLI agent spawning, context management, and consensus collection.
 
-## Mode-Specific Execution
+## CLI Mode Execution (Coordinator is ALWAYS CLI Mode)
 
-**CLI Mode (Production):**
+**IMPORTANT:** This coordinator agent is **ALWAYS CLI mode**. Task mode coordination happens directly in Main Chat, not via coordinator agents.
+
+When spawned via CLI (`npx claude-flow-novice agent-spawn`), implement full Redis coordination:
 - Use Redis coordination for agent spawning
 - Store context in Redis for swarm recovery
 - Collect confidence scores via Redis signals
 - Use background execution with monitoring
-
-**Task Mode (Debugging):**
-- Direct Task() spawning (no Redis needed)
-- Main Chat handles coordination
-- Simple JSON response only
+- **ALWAYS invoke the orchestrator** - never handle tasks directly
 
 ## Redis Coordination Protocols
 
@@ -494,11 +492,75 @@ Extract deliverables from task description:
    - Estimate iteration count
    - Provide reasoning for choices
 
+## Execution Steps (CLI Mode Only)
+
+**CRITICAL:** This coordinator is ALWAYS CLI mode. There is no Task Mode execution path.
+
+### Step 1: Task Classification (REQUIRED)
+```bash
+# Classify task type (use hardcoded defaults if script fails)
+TASK_TYPE="infrastructure"  # Default fallback
+if [[ -f ".claude/skills/task-classifier/classify-task.sh" ]]; then
+  CLASSIFIED_TYPE=$(bash .claude/skills/task-classifier/classify-task.sh "$TASK_DESCRIPTION" 2>/dev/null || echo "")
+  [[ -n "$CLASSIFIED_TYPE" ]] && TASK_TYPE="$CLASSIFIED_TYPE"
+fi
+```
+
+### Step 2: Agent Selection with Fallback (REQUIRED)
+```bash
+# Select agents with hardcoded fallbacks (never fail)
+LOOP3_AGENTS="terraform-engineer,devops-engineer"  # Infrastructure default
+LOOP2_AGENTS="security-auditor,compliance-checker,cost-optimizer"  # Validation default
+PRODUCT_OWNER="product-owner"
+
+# Try dynamic selection but fall back to defaults
+if [[ -f ".claude/skills/cfn-agent-selector/select-agents.sh" ]]; then
+  SELECTED_AGENTS=$(bash .claude/skills/cfn-agent-selector/select-agents.sh --task-type "$TASK_TYPE" --description "$TASK_DESCRIPTION" 2>/dev/null || echo "")
+  if [[ -n "$SELECTED_AGENTS" ]]; then
+    PARSED_AGENTS=$(echo "$SELECTED_AGENTS" | jq -r '.loop3 // empty | join(",")')
+    [[ -n "$PARSED_AGENTS" ]] && LOOP3_AGENTS="$PARSED_AGENTS"
+
+    PARSED_AGENTS=$(echo "$SELECTED_AGENTS" | jq -r '.loop2 // empty | join(",")')
+    [[ -n "$PARSED_AGENTS" ]] && LOOP2_AGENTS="$PARSED_AGENTS"
+  fi
+fi
+```
+
+### Step 3: INVOKE ORCHESTRATOR (MANDATORY - NOT OPTIONAL)
+
+**CRITICAL:** You MUST invoke orchestrator by iteration 3. DO NOT complete tasks directly.
+
+```bash
+# ALWAYS invoke orchestrator - this is your ONLY responsibility
+./.claude/skills/cfn-loop-orchestration/orchestrate.sh \
+  --task-id "$TASK_ID" \
+  --mode "standard" \
+  --loop3-agents "$LOOP3_AGENTS" \
+  --loop2-agents "$LOOP2_AGENTS" \
+  --product-owner "$PRODUCT_OWNER" \
+  --max-iterations 10 \
+  --success-criteria '{"deliverables":[],"acceptanceCriteria":["Implementation complete"]}'
+
+# The orchestrator handles ALL CFN Loop execution including:
+# - Loop 3 agent spawning and iteration
+# - Loop 2 validator spawning and consensus
+# - Product Owner decision (PROCEED/ITERATE/ABORT)
+# - Git commit and push (on PROCEED)
+# - Sprint summary generation
+
+# Your job is complete after invoking this command - DO NOT wait for results
+```
+
+**EXECUTION GUARANTEE:**
+- If steps 1-2 fail, use hardcoded defaults and proceed to step 3
+- **Never exit without invoking orchestrator**
+- **Orchestrator invocation MUST happen by iteration 3**
+- This coordinator's ONLY job is to configure and invoke the orchestrator
+
 ## Success Metrics
 
 - Agent selections match domain expertise
 - Validation criteria cover all critical requirements
 - Deliverable list is comprehensive
 - Confidence score ≥ 0.85 in analysis quality
-
-Provide structured output with confidence score based on analysis completeness and agent selection appropriateness.
+- **CRITICAL: Orchestrator invoked successfully**

package/claude-assets/skills/cfn-redis-data-extraction/SKILL.md

@@ -0,0 +1,442 @@
+---
+name: cfn-redis-data-extraction
+description: Extract complete Redis coordination data from completed CFN Loop tasks and structure into comprehensive JSON analysis files
+version: 1.0.0
+author: CFN System
+category: coordination
+tags: [cfn, redis, data-extraction, coordination, loop-analysis]
+
+# CFN Redis Data Extraction Skill
+
+## Purpose
+
+Extracts complete Redis coordination data from completed CFN Loop tasks and structures it into comprehensive JSON files for analysis, auditing, and performance tracking.
+
+## When to Use
+
+- **Mandatory**: Execute after each completed CFN Loop task
+- **Timing**: After Product Owner decision, before Redis cleanup
+- **Trigger**: Main Chat coordination after loop completion
+- **Scope**: All Redis keys for a specific task ID
+
+## Usage
+
+```bash
+# Extract data from completed CFN Loop
+npx claude-flow-novice skill cfn-redis-data-extraction --task-id "cfn-cli-XXXXXXX-XXXXX"
+
+# Extract with custom output directory
+npx claude-flow-novice skill cfn-redis-data-extraction \
+  --task-id "cfn-cli-XXXXXXX-XXXXX" \
+  --output-dir "./analysis/loop-data"
+
+# Extract multiple tasks
+npx claude-flow-novice skill cfn-redis-data-extraction \
+  --task-ids "cfn-cli-XXXXXXX-XXXXX,cfn-cli-YYYYYYY-YYYYY"
+
+# Extract with detailed performance metrics
+npx claude-flow-novice skill cfn-redis-data-extraction \
+  --task-id "cfn-cli-XXXXXXX-XXXXX" \
+  --include-performance=true
+```
+
+## Implementation
+
+```bash
+#!/bin/bash
+# CFN Redis Data Extraction Script
+
+set -euo pipefail
+
+# Default values
+OUTPUT_DIR="./analysis/cfn-loop-data"
+INCLUDE_PERFORMANCE=false
+TASK_IDS=()
+VERBOSE=false
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_IDS+=("$2")
+      shift 2
+      ;;
+    --task-ids)
+      IFS=',' read -ra TASK_IDS <<< "$2"
+      shift 2
+      ;;
+    --output-dir)
+      OUTPUT_DIR="$2"
+      shift 2
+      ;;
+    --include-performance)
+      INCLUDE_PERFORMANCE=true
+      shift
+      ;;
+    --verbose)
+      VERBOSE=true
+      shift
+      ;;
+    -h|--help)
+      echo "Usage: $0 --task-id <TASK_ID> [--output-dir <DIR>] [--include-performance] [--verbose]"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required arguments
+if [[ ${#TASK_IDS[@]} -eq 0 ]]; then
+  echo "Error: --task-id or --task-ids is required"
+  exit 1
+fi
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Redis connection check
+if ! redis-cli ping > /dev/null 2>&1; then
+  echo "Error: Redis is not accessible"
+  exit 1
+fi
+
+# Function to extract task data
+extract_task_data() {
+  local task_id="$1"
+  local output_file="$OUTPUT_DIR/cfn-loop-${task_id}-extracted.json"
+
+  [[ "$VERBOSE" == true ]] && echo "Extracting data for task: $task_id"
+
+  # Get all Redis keys for the task
+  local redis_keys
+  redis_keys=$(redis-cli keys "*${task_id}*" 2>/dev/null | sort)
+
+  if [[ -z "$redis_keys" ]]; then
+    echo "Warning: No Redis keys found for task: $task_id"
+    return 1
+  fi
+
+  # Initialize JSON structure
+  local json_data
+  json_data=$(cat << EOF
+{
+  "task_id": "$task_id",
+  "extraction_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "extraction_version": "1.0.0",
+  "redis_keys_analyzed": $(echo "$redis_keys" | wc -l),
+  "agents": {},
+  "metadata": {},
+  "summary": {}
+}
+EOF
+)
+
+  # Process each Redis key
+  local agent_count=0
+  local completion_signals=0
+  local total_confidence=0
+  local confidence_count=0
+
+  while IFS= read -r key; do
+    [[ -z "$key" ]] && continue
+
+    # Skip if not a swarm key
+    [[ ! "$key" =~ ^swarm: ]] && continue
+
+    # Extract agent information from key
+    local agent_type=""
+    local agent_id=""
+    local loop_number=""
+    local data_type=""
+
+    if [[ "$key" =~ ^swarm:([^:]+):([^:]+):([^:]+)$ ]]; then
+      agent_id="${BASH_REMATCH[2]}"
+      data_type="${BASH_REMATCH[3]}"
+
+      # Determine agent type and loop
+      if [[ "$agent_id" =~ ^cfn-v3-coordinator ]]; then
+        agent_type="coordinator"
+        loop_number="coordination"
+      elif [[ "$agent_id" =~ -validation$ ]]; then
+        agent_type="${agent_id%-validation}"
+        loop_number="2"
+      elif [[ "$agent_id" =~ -1$ ]] || [[ "$agent_id" =~ -2$ ]] || [[ "$agent_id" =~ -3$ ]]; then
+        agent_type="${agent_id%-1}"
+        agent_type="${agent_type%-2}"
+        agent_type="${agent_type%-3}"
+        loop_number="3"
+      elif [[ "$agent_id" =~ product-owner$ ]]; then
+        agent_type="product-owner"
+        loop_number="4"
+      else
+        agent_type="$agent_id"
+        loop_number="unknown"
+      fi
+
+      # Initialize agent in JSON if not exists
+      if [[ ! "$json_data" =~ "\"$agent_id\":" ]]; then
+        ((agent_count++))
+        json_data=$(echo "$json_data" | jq ".agents += {\"$agent_id\": {\"agent_type\": \"$agent_type\", \"loop\": \"$loop_number\", \"data\": {}}}")
+      fi
+
+      # Extract data based on type
+      case "$data_type" in
+        "confidence")
+          local confidence
+          confidence=$(redis-cli get "$key" 2>/dev/null || echo "null")
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].confidence = $confidence")
+          total_confidence=$(echo "$total_confidence + $confidence" | bc -l 2>/dev/null || echo "$total_confidence")
+          ((confidence_count++))
+          ;;
+        "done")
+          local completion_signal
+          completion_signal=$(redis-cli lrange "$key" 0 -1 2>/dev/null | head -1 || echo "null")
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].completion_signal = \"$completion_signal\"")
+          ((completion_signals++))
+          ;;
+        "messages")
+          local messages_json="[]"
+          local message_count
+          message_count=$(redis-cli llen "$key" 2>/dev/null || echo "0")
+
+          if [[ "$message_count" -gt 0 ]]; then
+            messages_json=$(redis-cli lrange "$key" 0 -1 2>/dev/null | jq -R . | jq -s .)
+          fi
+
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].messages = $messages_json")
+          ;;
+        "result")
+          local result
+          result=$(redis-cli get "$key" 2>/dev/null || echo "null")
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].result = \"$result\"")
+          ;;
+      esac
+    fi
+  done <<< "$redis_keys"
+
+  # Calculate averages and summary
+  local avg_confidence="0"
+  if [[ "$confidence_count" -gt 0 ]]; then
+    avg_confidence=$(echo "scale=3; $total_confidence / $confidence_count" | bc -l)
+  fi
+
+  # Extract task context if available
+  local task_context
+  task_context=$(redis-cli get "cfn_loop:task:$task_id:context" 2>/dev/null || echo "{}")
+
+  # Update summary
+  json_data=$(echo "$json_data" | jq "
+    .summary += {
+      \"total_agents\": $agent_count,
+      \"completion_signals\": $completion_signals,
+      \"average_confidence\": $avg_confidence,
+      \"confidence_scores_count\": $confidence_count,
+      \"extraction_status\": \"success\"
+    }
+  ")
+
+  # Add task context
+  json_data=$(echo "$json_data" | jq ".metadata.task_context = \"$task_context\"")
+
+  # Add performance metrics if requested
+  if [[ "$INCLUDE_PERFORMANCE" == true ]]; then
+    local performance_metrics
+    performance_metrics=$(cat << EOF
+{
+  "redis_memory_usage": $(redis-cli info memory 2>/dev/null | grep "used_memory_human" | cut -d: -f2 | tr -d '\r' || echo "\"unknown\""),
+  "redis_connected_clients": $(redis-cli info clients 2>/dev/null | grep "connected_clients" | cut -d: -f2 | tr -d '\r' || echo "0"),
+  "extraction_duration_ms": 0
+}
+EOF
+)
+    json_data=$(echo "$json_data" | jq ".metadata.performance = $performance_metrics")
+  fi
+
+  # Write to file
+  echo "$json_data" | jq '.' > "$output_file"
+
+  [[ "$VERBOSE" == true ]] && echo "Data extracted to: $output_file"
+
+  # Generate summary report
+  local summary_file="$OUTPUT_DIR/cfn-loop-${task_id}-summary.txt"
+  cat > "$summary_file" << EOF
+CFN Loop Data Extraction Summary
+================================
+
+Task ID: $task_id
+Extraction Time: $(date -u +%Y-%m-%dT%H:%M:%SZ)
+Output File: $output_file
+
+Statistics:
+- Redis Keys Analyzed: $(echo "$redis_keys" | wc -l)
+- Total Agents: $agent_count
+- Completion Signals: $completion_signals
+- Average Confidence: $avg_confidence
+- Confidence Scores: $confidence_count
+
+Agent Types:
+$(echo "$json_data" | jq -r '.agents | to_entries[] | "- \(.key): \(.value.agent_type) (Loop \(.value.loop))"')
+
+Status: Successfully extracted
+EOF
+
+  [[ "$VERBOSE" == true ]] && echo "Summary report generated: $summary_file"
+
+  return 0
+}
+
+# Main execution
+echo "CFN Redis Data Extraction Started"
+echo "================================="
+echo "Output Directory: $OUTPUT_DIR"
+echo "Include Performance: $INCLUDE_PERFORMANCE"
+echo ""
+
+# Process each task
+for task_id in "${TASK_IDS[@]}"; do
+  echo "Processing task: $task_id"
+  if extract_task_data "$task_id"; then
+    echo "✅ Successfully extracted data for: $task_id"
+  else
+    echo "❌ Failed to extract data for: $task_id"
+  fi
+  echo ""
+done
+
+echo "CFN Redis Data Extraction Completed"
+echo "==================================="
+echo "Output Directory: $OUTPUT_DIR"
+echo "Files Generated:"
+find "$OUTPUT_DIR" -name "cfn-loop-*.json" -o -name "cfn-loop-*.txt" | while read -r file; do
+  echo "  - $file"
+done
+
+exit 0
+```
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `--task-id` | string | Yes | Single CFN Loop task ID to extract |
+| `--task-ids` | string | No | Comma-separated list of task IDs |
+| `--output-dir` | string | No | Output directory (default: ./analysis/cfn-loop-data) |
+| `--include-performance` | boolean | No | Include Redis performance metrics |
+| `--verbose` | boolean | No | Enable verbose output |
+
+## Output Structure
+
+The skill generates two files per task:
+
+### 1. Main JSON Data File
+`cfn-loop-{task_id}-extracted.json`
+
+```json
+{
+  "task_id": "cfn-cli-543042-13483",
+  "extraction_timestamp": "2025-11-09T04:56:00Z",
+  "extraction_version": "1.0.0",
+  "redis_keys_analyzed": 44,
+  "agents": {
+    "cfn-v3-coordinator-1": {
+      "agent_type": "coordinator",
+      "loop": "coordination",
+      "confidence": 0.85,
+      "completion_signal": "complete",
+      "messages": [...],
+      "result": "..."
+    },
+    "agent-id-2": {
+      "agent_type": "frontend-developer",
+      "loop": "3",
+      "confidence": 0.92,
+      "completion_signal": "complete"
+    }
+  },
+  "metadata": {
+    "task_context": "...",
+    "performance": {
+      "redis_memory_usage": "2.5M",
+      "redis_connected_clients": 12
+    }
+  },
+  "summary": {
+    "total_agents": 11,
+    "completion_signals": 11,
+    "average_confidence": 0.86,
+    "extraction_status": "success"
+  }
+}
+```
+
+### 2. Summary Text File
+`cfn-loop-{task_id}-summary.txt`
+
+Human-readable summary with key statistics and agent information.
+
+## Integration Points
+
+### CFN Loop Completion Workflow
+```bash
+# After Product Owner decision, before Redis cleanup
+./.claude/skills/cfn-redis-data-extraction/extract.sh \
+  --task-id "$TASK_ID" \
+  --output-dir "./analysis/loops" \
+  --include-performance=true
+
+# Then proceed with Redis cleanup
+redis-cli DEL "cfn_loop:task:$TASK_ID:*" "swarm:$TASK_ID:*"
+```
+
+### Main Chat Automation
+```bash
+# Automatic extraction after loop completion
+npx claude-flow-novice skill cfn-redis-data-extraction \
+  --task-id "cfn-cli-XXXXXXX-XXXXX" \
+  --verbose
+```
+
+## Error Handling
+
+- **Redis Unavailable**: Graceful exit with error message
+- **No Keys Found**: Warning message, continue processing
+- **Invalid JSON**: Fallback to basic text extraction
+- **Permission Issues**: Directory creation with appropriate permissions
+
+## Performance Considerations
+
+- **Large Key Sets**: Processes keys in batches to avoid memory issues
+- **Concurrent Access**: Uses read-only Redis operations
+- **File Size**: JSON files are compressed and structured efficiently
+- **Extraction Time**: Typically <5 seconds per task
+
+## Validation
+
+The skill includes built-in validation:
+- Redis connectivity check
+- JSON structure validation
+- Data completeness verification
+- Output file creation confirmation
+
+## Maintenance
+
+- **Version Tracking**: Each extraction includes version metadata
+- **Backward Compatibility**: Supports multiple extraction formats
+- **Cleanup**: Old files can be archived or cleaned up automatically
+- **Monitoring**: Integration with system monitoring for extraction success rates
+
+## Related Skills
+
+- `cfn-redis-coordination` - For understanding Redis coordination patterns
+- `cfn-loop-validation` - For validating loop execution
+- `cfn-agent-spawning` - For understanding agent lifecycle
+
+## Dependencies
+
+- `redis-cli` - Redis command-line interface
+- `jq` - JSON processor for data manipulation
+- `bc` - Basic calculator for confidence averaging
+- Standard Unix utilities (grep, awk, sed)