claude-flow-novice 2.14.12 → 2.14.13

package/.claude/commands/CFN_LOOP_TASK_MODE.md

@@ -6,11 +6,11 @@
 
 ## Overview
 
-Task Mode: Main Chat spawns coordinator and agents via Task() tool with full context injection and visibility.
+Task Mode: Main Chat acts as coordinator and spawns agents directly via Task() tool with full context injection and visibility.
 
 | Aspect | Task Mode | CLI Mode |
 |--------|-----------|----------|
-| **Spawning** | Main Chat via Task() | Coordinator via npx CLI |
+| **Spawning** | Main Chat spawns agents directly via Task() | Coordinator spawns agents via npx CLI |
 | **Visibility** | Full transparency in Main Chat | Background, Redis logs |
 | **Provider** | All Anthropic | CLI uses Z.ai routing |
 | **Cost** | ~$0.150/iteration | ~$0.054/iteration (64% savings) |
@@ -35,6 +35,50 @@ Task Mode: Main Chat spawns coordinator and agents via Task() tool with full con
 
 ---
 
+## Task Mode Execution Pattern
+
+**Key Principle: Main Chat IS the coordinator**
+
+In Task Mode, Main Chat directly spawns all agents via Task() tool. No coordinator agent is used.
+
+### Example: Zone A React Router Migration
+
+```javascript
+// ✅ CORRECT - Main Chat spawns agents directly
+Task("backend-developer", `
+  Migrate React Router from v4 to v6 in Zone A components
+  Deliverables: Updated Routes, component fixes, tests
+  Directory: frontend/src/zone-a/
+`);
+
+Task("react-frontend-engineer", `
+  Review and fix any component issues after router migration
+  Focus on route parameters, navigation, and component integration
+`);
+
+Task("tester", `
+  Test React Router v6 migration in Zone A
+  Verify all routes work, navigation functions, no regressions
+`);
+
+// Later: Process outputs, collect confidence, decide next iteration
+```
+
+### What NOT to Do in Task Mode
+
+```javascript
+// ❌ INCORRECT - Don't spawn coordinator agent
+Task("cfn-v3-coordinator", "Coordinate React Router migration");
+
+// ❌ INCORRECT - Don't use CLI commands in Task Mode
+Bash("npx claude-flow-novice swarm 'task description'");
+
+// ❌ INCORRECT - Don't nest CFN Loop calls
+Task("reviewer", "/cfn-loop 'review this code'");  // Causes infinite loops
+```
+
+---
+
 ## Agent Specialization
 
 ### Loop 3 (Implementation)
@@ -88,15 +132,15 @@ return validators.slice(0, 6); // Max 6
 ## Sprint Completion Workflow
 
 **Key Difference in Task Mode:**
-- Product Owner spawned via `Task()` by coordinator (NOT via `execute-decision.sh`)
+- Product Owner spawned via `Task()` by Main Chat acting as coordinator (NOT via `execute-decision.sh`)
 - Use helper scripts for parsing/validation: `parse-decision.sh`, `validate-deliverables.sh`
 - CLI Mode uses `execute-decision.sh` which handles spawning + all logic
 
 ### 1. Consensus Validation
 
-**Task Mode** - Coordinator spawns Product Owner via Task():
+**Task Mode** - Main Chat (as coordinator) spawns Product Owner via Task():
 ```javascript
-// Coordinator builds context and spawns PO
+// Main Chat (as coordinator) builds context and spawns PO
 const poContext = `
   CFN Loop iteration ${iteration} complete.
   Loop 2 Consensus: ${consensus} (threshold: ${threshold})
@@ -164,7 +208,7 @@ EOF
 ### 5. Execute Product Owner Suggested Next Steps
 
 **After PROCEED Decision:**
-Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Coordinator (main chat) must proceed by spawning specialized agents to execute these tasks:
+Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Main Chat (as coordinator) must proceed by spawning specialized agents to execute these tasks:
 
 ```javascript
 // Parse PO feedback for suggested next steps
@@ -305,7 +349,7 @@ threshold = Math.min(threshold, 0.98); // Cap at 0.98
 ## Background Backlog Worker
 
 ### Architecture
-- **Main Chat**: Spawns Task() agents for Sprint N (foreground)
+- **Main Chat (as coordinator)**: Spawns Task() agents directly for Sprint N (foreground)
 - **Background CLI**: Processes P3 backlog items (detached process)
 
 ### Launch Background Worker

package/.claude/commands/cfn-loop-cli.md

@@ -149,7 +149,7 @@ Task("cfn-v3-coordinator", `
 
   1. INVOKE ORCHESTRATOR (CLI spawning):
 
-     TASK_ID="cfn-cli-$(date +%s)"
+     TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
      MODE="${mode}"
      LOOP3_AGENTS="backend-dev,researcher,devops"  # Customize for task
      LOOP2_AGENTS="reviewer,tester,architect,security-specialist"  # Scale by complexity

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

@@ -17,7 +17,7 @@ AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
   --task-type "software-development" \
   --description "Implement JWT authentication with refresh tokens")
 
-echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-developer", "security-specialist"]
 echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
 ```
 
@@ -35,7 +35,7 @@ echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
 ## Agent Selection Rules
 
 ### Software Development
-**Base Loop 3:** backend-dev, coder
+**Base Loop 3:** backend-developer, coder
 **Add if keywords:**
 - "security", "authentication", "JWT" → security-specialist
 - "database", "SQL", "schema" → database-engineer (if exists)

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

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

package/.claude/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

@@ -697,6 +697,23 @@ EOF
 # 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 ""

package/claude-assets/agents/cfn-dev-team/CLAUDE.md

@@ -112,7 +112,7 @@ npx claude-flow-novice agent-spawn my-first-agent --task-id test-1
 │   ├── tester.md               # Testing & validation
 │   └── coordinator.md          # Multi-agent coordination
 ├── development/                 # Development-focused agents
-│   ├── backend-dev.md
+│   ├── backend-developer.md
 │   ├── react-frontend-engineer.md
 │   └── devops-engineer.md
 ├── security/                    # Security-focused agents
@@ -613,7 +613,7 @@ Agents can work together using Redis pub/sub and CLI spawning:
 ### Agent Spawning Pattern
 ```bash
 # Spawn agents via CLI (coordinators only)
-npx claude-flow-novice agent-spawn backend-dev --task-id "${TASK_ID}"
+npx claude-flow-novice agent-spawn backend-developer --task-id "${TASK_ID}"
 npx claude-flow-novice agent-spawn reviewer --task-id "${TASK_ID}"
 ```
 
@@ -948,7 +948,7 @@ acl_level: 1
 - `.claude/agents/core-agents/coder.md` - Code implementation
 - `.claude/agents/core-agents/reviewer.md` - Code review
 - `.claude/agents/core-agents/tester.md` - Testing & validation
-- `.claude/agents/development/backend-dev.md` - Backend development
+- `.claude/agents/development/backend-developer.md` - Backend development
 - `.claude/agents/security/security-specialist.md` - Security analysis
 
 ### Documentation