claude-flow-novice 2.14.11 → 2.14.13

package/.claude/skills/cfn-agent-selector/select-agents.sh

@@ -28,12 +28,57 @@ if [[ ! -f "$REGISTRY_PATH" ]]; then
     exit 1
 fi
 
+# Smart agent selection for React Router and specialized tasks
+smart_agent_selection() {
+    local description="$1"
+    local task_type="$2"
+
+    # React Router specialization - Zone A fix
+    if [[ "$description" =~ (React Router|react-router|TS2786|jsx.*component|route.*migration) ]]; then
+        echo '["react-frontend-engineer", "reviewer", "tester"]'
+        return 0
+    fi
+
+    # TypeScript/TSX specialization
+    if [[ "$description" =~ (TypeScript|tsx|TS[0-9]+|interface.*error) ]]; then
+        echo '["react-frontend-engineer", "reviewer", "tester"]'
+        return 0
+    fi
+
+    # Frontend UI specialization
+    if [[ "$description" =~ (frontend|ui|component|css|style|responsive) ]]; then
+        echo '["react-frontend-engineer", "reviewer", "accessibility-advocate-persona"]'
+        return 0
+    fi
+
+    # Authentication/Security specialization
+    if [[ "$description" =~ (auth|jwt|token|security|password|login|register) ]]; then
+        echo '["backend-developer", "security-specialist", "reviewer"]'
+        return 0
+    fi
+
+    # API/Backend specialization
+    if [[ "$description" =~ (api|endpoint|server|backend|database|orm|sql) ]]; then
+        echo '["backend-developer", "reviewer", "tester"]'
+        return 0
+    fi
+
+    return 1  # Fall back to registry-based selection
+}
+
 # Score agents function with improved flat namespace matching
 score_agents() {
     local registry_path="$1"
     local description="$2"
     local task_type="$3"
 
+    # Try smart selection first
+    local smart_result
+    if smart_result=$(smart_agent_selection "$description" "$task_type"); then
+        echo "$smart_result"
+        return 0
+    fi
+
     # Complex JQ query for flexible matching
     jq -r --arg desc "$description" --arg task_type "$task_type" '
         [

package/.claude/skills/cfn-loop-orchestration/helpers/context-injection.sh

@@ -116,16 +116,79 @@ inject_context_for_agent() {
   local task_id="$2"
   local iteration="${3:-1}"
 
-  # Retrieve task context from Redis
-  local task_context
+  # Retrieve structured task context from Redis
+  local task_context=""
+  local epic_context=""
+  local phase_context=""
+  local success_criteria=""
+  local expected_files=""
+
   if command -v redis-cli &> /dev/null; then
-    task_context=$(redis-cli HGET "cfn_loop:task:$task_id:context" "task_description" 2>/dev/null || echo "")
-  else
-    task_context=""
+    # Get all structured context fields
+    task_context=$(redis-cli HGET "swarm:$task_id:context" "task_description" 2>/dev/null || echo "")
+    epic_context=$(redis-cli HGET "swarm:$task_id:context" "epic-context" 2>/dev/null || echo "")
+    phase_context=$(redis-cli HGET "swarm:$task_id:context" "phase-context" 2>/dev/null || echo "")
+    success_criteria=$(redis-cli HGET "swarm:$task_id:context" "success-criteria" 2>/dev/null || echo "")
+    expected_files=$(redis-cli HGET "swarm:$task_id:context" "expected-files" 2>/dev/null || echo "")
   fi
 
+  # Build comprehensive task description from all available context
+  local comprehensive_context=""
+
+  # Start with task description if available
+  if [ -n "$task_context" ]; then
+    comprehensive_context="$task_context"
+  fi
+
+  # Add epic context
+  if [ -n "$epic_context" ]; then
+    if [ -n "$comprehensive_context" ]; then
+      comprehensive_context="$comprehensive_context
+
+Epic Context: $epic_context"
+    else
+      comprehensive_context="Epic Context: $epic_context"
+    fi
+  fi
+
+  # Add phase context
+  if [ -n "$phase_context" ]; then
+    if [ -n "$comprehensive_context" ]; then
+      comprehensive_context="$comprehensive_context
+
+Phase Context: $phase_context"
+    else
+      comprehensive_context="Phase Context: $phase_context"
+    fi
+  fi
+
+  # Add success criteria
+  if [ -n "$success_criteria" ]; then
+    if [ -n "$comprehensive_context" ]; then
+      comprehensive_context="$comprehensive_context
+
+Success Criteria: $success_criteria"
+    else
+      comprehensive_context="Success Criteria: $success_criteria"
+    fi
+  fi
+
+  # Add expected files
+  if [ -n "$expected_files" ]; then
+    if [ -n "$comprehensive_context" ]; then
+      comprehensive_context="$comprehensive_context
+
+Expected Files: $expected_files"
+    else
+      comprehensive_context="Expected Files: $expected_files"
+    fi
+  fi
+
+  # Use comprehensive context for further processing
+  task_context="$comprehensive_context"
+
   if [ -z "$task_context" ]; then
-    echo "# ACE Context (No Task Description)"
+    echo "# CFN Loop Context (No Task Description)"
     echo ""
     echo "_Task description not available for context injection._"
     return 1

package/.claude/skills/cfn-loop-orchestration/helpers/validate-task-context.sh

@@ -0,0 +1,241 @@
+#!/bin/bash
+# Task Context Validation Helper
+# Validates that CLI mode has complete task context (prevents "consensus on vapor")
+#
+# Usage: validate-task-context.sh --task-id <id> [--task-description <desc>] [--expected-files <files>] [--success-criteria <criteria>]
+
+set -euo pipefail
+
+# Initialize variables
+TASK_ID=""
+TASK_DESCRIPTION=""
+EXPECTED_FILES=""
+SUCCESS_CRITERIA=""
+NAMESPACE="swarm"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --task-description)
+      TASK_DESCRIPTION="$2"
+      shift 2
+      ;;
+    --expected-files)
+      EXPECTED_FILES="$2"
+      shift 2
+      ;;
+    --success-criteria)
+      SUCCESS_CRITERIA="$2"
+      shift 2
+      ;;
+    --namespace)
+      NAMESPACE="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown parameter: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required arguments
+if [[ -z "$TASK_ID" ]]; then
+  echo "Error: --task-id is required" >&2
+  echo "Usage: $0 --task-id <id> [--task-description <desc>] [--expected-files <files>] [--success-criteria <criteria>]" >&2
+  exit 1
+fi
+
+# Validation functions
+validate_task_description() {
+  local task_desc="$1"
+
+  if [[ -z "$task_desc" ]]; then
+    echo "❌ Task description is empty or missing"
+    return 1
+  fi
+
+  # Check minimum length (should be meaningful)
+  if [[ ${#task_desc} -lt 10 ]]; then
+    echo "❌ Task description too short (${#task_desc} chars, minimum 10)"
+    return 1
+  fi
+
+  # Check for actionable verbs
+  if [[ ! "$task_desc" =~ (create|build|implement|fix|migrate|update|add|remove|refactor|test|review|validate) ]]; then
+    echo "⚠️  Task description lacks clear action verb"
+  fi
+
+  # Check for specific deliverables (Zone A fix: prevent generic context)
+  if [[ "$task_desc" =~ (zone-d-round2|checkpoint|iteration [0-9]+) ]]; then
+    echo "❌ Task description contains generic identifier (Zone A issue)"
+    return 1
+  fi
+
+  echo "✅ Task description validation passed"
+  return 0
+}
+
+validate_expected_files() {
+  local files="$1"
+  local errors=0
+
+  if [[ -z "$files" ]]; then
+    echo "⚠️  No expected files specified (may be OK for analysis tasks)"
+    return 0
+  fi
+
+  # Split files by comma and validate each
+  IFS=',' read -ra file_array <<< "$files"
+  for file in "${file_array[@]}"; do
+    # Remove whitespace
+    file=$(echo "$file" | xargs)
+
+    if [[ -z "$file" ]]; then
+      continue
+    fi
+
+    # Check file path format
+    if [[ ! "$file" =~ ^[a-zA-Z0-9_/-]+\.[a-zA-Z]+$ && ! "$file" =~ ^[a-zA-Z0-9_/-]+/ ]]; then
+      echo "❌ Invalid file format: $file"
+      ((errors++))
+      continue
+    fi
+
+    # Check for generic placeholders
+    if [[ "$file" =~ (placeholder|example|template) ]]; then
+      echo "❌ Generic file placeholder: $file"
+      ((errors++))
+      continue
+    fi
+
+  done
+
+  if [[ $errors -eq 0 ]]; then
+    echo "✅ Expected files validation passed"
+    return 0
+  else
+    return 1
+  fi
+}
+
+validate_success_criteria() {
+  local criteria="$1"
+  local errors=0
+
+  if [[ -z "$criteria" ]]; then
+    echo "⚠️  No success criteria specified (may be OK for discovery tasks)"
+    return 0
+  fi
+
+  # Check criteria length
+  if [[ ${#criteria} -lt 5 ]]; then
+    echo "❌ Success criteria too short: $criteria"
+    ((errors++))
+  fi
+
+  # Check for measurable outcomes
+  if [[ ! "$criteria" =~ (test|pass|fail|error|success|complete|0.*errors|100%) ]]; then
+    echo "⚠️  Success criteria lacks measurable outcomes"
+  fi
+
+  # Check for generic statements
+  if [[ "$criteria" =~ (done|finished|complete|good) && ${#criteria} -lt 20 ]]; then
+    echo "❌ Success criteria too generic: $criteria"
+    ((errors++))
+  fi
+
+  if [[ $errors -eq 0 ]]; then
+    echo "✅ Success criteria validation passed"
+    return 0
+  else
+    return 1
+  fi
+}
+
+check_redis_context() {
+  local task_id="$1"
+  local redis_key="${NAMESPACE}:${task_id}:context"
+
+  # Check if context exists
+  if ! redis-cli EXISTS "$redis_key" >/dev/null 2>&1; then
+    echo "❌ No context found in Redis for task: $task_id"
+    return 1
+  fi
+
+  # Get all context fields
+  local context_fields
+  context_fields=$(redis-cli HGETALL "$redis_key" 2>/dev/null || echo "")
+
+  if [[ -z "$context_fields" ]]; then
+    echo "❌ Context exists but is empty for task: $task_id"
+    return 1
+  fi
+
+  # Count non-metadata fields
+  local field_count=0
+  while IFS= read -r field; do
+    # Skip metadata fields
+    if [[ ! "$field" =~ (updated_at|stored_at) ]]; then
+      ((field_count++))
+    fi
+  done <<< "$context_fields"
+
+  if [[ $field_count -eq 0 ]]; then
+    echo "❌ Context contains only metadata fields"
+    return 1
+  fi
+
+  echo "✅ Redis context validation passed ($field_count data fields)"
+  return 0
+}
+
+# Main validation
+validation_errors=0
+echo "🔍 Validating task context for: $TASK_ID"
+echo ""
+
+# Validate task description
+if [[ -n "$TASK_DESCRIPTION" ]]; then
+  if ! validate_task_description "$TASK_DESCRIPTION"; then
+    ((validation_errors++))
+  fi
+fi
+
+# Validate expected files
+if [[ -n "$EXPECTED_FILES" ]]; then
+  if ! validate_expected_files "$EXPECTED_FILES"; then
+    ((validation_errors++))
+  fi
+fi
+
+# Validate success criteria
+if [[ -n "$SUCCESS_CRITERIA" ]]; then
+  if ! validate_success_criteria "$SUCCESS_CRITERIA"; then
+    ((validation_errors++))
+  fi
+fi
+
+# Check Redis context
+if ! check_redis_context "$TASK_ID"; then
+  ((validation_errors++))
+fi
+
+echo ""
+
+# Final result
+if [[ $validation_errors -eq 0 ]]; then
+  echo "🎉 All context validations passed!"
+  echo "✅ CLI Mode has complete, structured task context"
+  echo "✅ Zone A 'consensus on vapor' issue prevented"
+  exit 0
+else
+  echo "❌ $validation_errors validation(s) failed"
+  echo "⚠️  Task context may be incomplete"
+  echo "⚠️  Risk of 'consensus on vapor' - please add missing context"
+  exit 1
+fi

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

@@ -66,19 +66,6 @@ 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
 ##############################################################################
@@ -707,20 +694,26 @@ 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"
 
+# Validate context completeness (Zone A fix: prevent "consensus on vapor")
+echo "Validating task context completeness..."
+if [[ -n "$SUCCESS_CRITERIA" || -n "$EXPECTED_FILES" ]]; then
+  validation_script="$HELPERS_DIR/validate-task-context.sh"
+  if [[ -f "$validation_script" ]]; then
+    if ! "$validation_script" \
+        --task-id "$TASK_ID" \
+        --success-criteria "$SUCCESS_CRITERIA" \
+        --expected-files "$EXPECTED_FILES"; then
+      echo "⚠️  WARNING: Task context validation failed"
+      echo "⚠️  This may result in 'consensus on vapor' (high confidence, zero deliverables)"
+      echo "⚠️  Consider adding more specific task context"
+      echo ""
+    fi
+  fi
+fi
+
 # Iteration loop
 for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
   echo ""
@@ -775,41 +768,11 @@ for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
        --agents "$LOOP3_IDS" \
        --threshold "$GATE" \
        --min-quorum "$MIN_QUORUM_LOOP3"; then
-    # 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
+    # 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")
   else
     # Gate failed - iterate Loop 3
     echo "❌ Gate check failed - iterating Loop 3"
@@ -932,19 +895,6 @@ 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"

package/.claude/skills/cfn-redis-coordination/get-context.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# Retrieve CFN Loop task context from Redis
+# Used by CLI-spawned agents to get structured context from orchestrator
+#
+# Usage:
+#   get-context.sh --task-id <id> [--namespace <ns>]
+#   get-context.sh --task-id <id> --key <key> [--namespace <ns>]
+#   get-context.sh <task_id> (legacy mode)
+
+set -euo pipefail
+
+# Initialize variables
+TASK_ID=""
+KEY=""
+NAMESPACE="swarm"
+FORMAT="json"  # json or raw
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --key)
+      KEY="$2"
+      shift 2
+      ;;
+    --namespace)
+      NAMESPACE="$2"
+      shift 2
+      ;;
+    --format)
+      FORMAT="$2"
+      shift 2
+      ;;
+    *)
+      # Legacy mode: positional argument
+      if [ -z "$TASK_ID" ]; then
+        TASK_ID="$1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+# Validate required arguments
+if [ -z "$TASK_ID" ]; then
+    echo "Error: --task-id or TASK_ID required" >&2
+    echo "Usage: $0 --task-id <id> [--key <key>] [--namespace <ns>] [--format <json|raw>]" >&2
+    echo "   or: $0 <task_id> (legacy)" >&2
+    exit 1
+fi
+
+REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
+
+# Check if context exists
+if ! redis-cli EXISTS "$REDIS_KEY" >/dev/null 2>&1; then
+    echo "⚠️  No context found for task: $TASK_ID" >&2
+    exit 1
+fi
+
+# Handle specific key retrieval
+if [ -n "$KEY" ]; then
+  VALUE=$(redis-cli HGET "$REDIS_KEY" "$KEY" 2>/dev/null || echo "")
+  if [ -z "$VALUE" ]; then
+    echo "⚠️  Key '$KEY' not found in context for task: $TASK_ID" >&2
+    exit 1
+  fi
+
+  if [ "$FORMAT" = "raw" ]; then
+    echo "$VALUE"
+  else
+    echo "{\"$KEY\":$VALUE}"
+  fi
+  exit 0
+fi
+
+# Handle full context retrieval
+ALL_FIELDS=$(redis-cli HGETALL "$REDIS_KEY" 2>/dev/null || echo "")
+
+if [ -z "$ALL_FIELDS" ]; then
+    echo "⚠️  Empty context for task: $TASK_ID" >&2
+    exit 1
+fi
+
+# Format as JSON
+if [ "$FORMAT" = "json" ]; then
+  echo "{"
+  first=true
+  while IFS= read -r field; do
+    if [ -z "$field" ]; then continue; fi
+    if [ "$first" = true ]; then
+      first=false
+    else
+      echo ","
+    fi
+    # Skip empty lines and properly format JSON values
+    if [[ $field =~ ^[0-9]+$ ]]; then
+      # Numeric value
+      echo -n "  \"$field\": $(redis-cli HGET "$REDIS_KEY" "$field")"
+    else
+      # String value
+      value=$(redis-cli HGET "$REDIS_KEY" "$field" | sed 's/"/\\"/g')
+      echo -n "  \"$field\": \"$value\""
+    fi
+  done <<< "$ALL_FIELDS"
+  echo ""
+  echo "}"
+else
+  # Raw format
+  redis-cli HGETALL "$REDIS_KEY"
+fi