claude-flow-novice 2.14.13 → 2.14.15

package/claude-assets/commands/CFN_LOOP_TASK_MODE.md

@@ -6,11 +6,11 @@
 
 ## Overview
 
-Task Mode: Main Chat acts as coordinator and spawns agents directly via Task() tool with full context injection and visibility.
+Task Mode: Main Chat spawns coordinator and agents via Task() tool with full context injection and visibility.
 
 | Aspect | Task Mode | CLI Mode |
 |--------|-----------|----------|
-| **Spawning** | Main Chat spawns agents directly via Task() | Coordinator spawns agents via npx CLI |
+| **Spawning** | Main Chat via Task() | Coordinator 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,50 +35,6 @@ Task Mode: Main Chat acts as coordinator and spawns agents directly via Task() t
 
 ---
 
-## 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)
@@ -132,15 +88,15 @@ return validators.slice(0, 6); // Max 6
 ## Sprint Completion Workflow
 
 **Key Difference in Task Mode:**
-- Product Owner spawned via `Task()` by Main Chat acting as coordinator (NOT via `execute-decision.sh`)
+- Product Owner spawned via `Task()` by 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** - Main Chat (as coordinator) spawns Product Owner via Task():
+**Task Mode** - Coordinator spawns Product Owner via Task():
 ```javascript
-// Main Chat (as coordinator) builds context and spawns PO
+// Coordinator builds context and spawns PO
 const poContext = `
   CFN Loop iteration ${iteration} complete.
   Loop 2 Consensus: ${consensus} (threshold: ${threshold})
@@ -208,7 +164,7 @@ EOF
 ### 5. Execute Product Owner Suggested Next Steps
 
 **After PROCEED Decision:**
-Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Main Chat (as coordinator) must proceed by spawning specialized agents to execute these tasks:
+Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Coordinator (main chat) must proceed by spawning specialized agents to execute these tasks:
 
 ```javascript
 // Parse PO feedback for suggested next steps
@@ -349,7 +305,7 @@ threshold = Math.min(threshold, 0.98); // Cap at 0.98
 ## Background Backlog Worker
 
 ### Architecture
-- **Main Chat (as coordinator)**: Spawns Task() agents directly for Sprint N (foreground)
+- **Main Chat**: Spawns Task() agents for Sprint N (foreground)
 - **Background CLI**: Processes P3 backlog items (detached process)
 
 ### Launch Background Worker

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

@@ -14,12 +14,14 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 
 ## What is CLI Mode?
 
-**CLI Mode Architecture:**
+**CLI Mode Architecture v3.0 (Enhanced):**
 - Main Chat spawns **single coordinator agent** via Task()
-- Coordinator spawns **all workers via CLI** (`npx claude-flow-novice`)
+- Enhanced coordinator spawns **all workers via CLI** with protocol compliance
 - CLI agents use **Z.ai custom routing** (when enabled)
-- Background execution with **Redis monitoring**
+- **Real-time monitoring** with automatic recovery from stuck agents
+- Background execution with **Redis monitoring** and progress visibility
 - **95-98% cost savings** vs Task tool spawning
+- **Enhanced features**: Process health checking, context validation, broadcast protocol
 
 **Cost Breakdown:**
 ```
@@ -77,138 +79,57 @@ Savings: 64% with custom routing, 95-98% vs all-Task
 
 ## 🚨 CRITICAL EXECUTION INSTRUCTIONS
 
-**YOU ARE MAIN CHAT. YOU SPAWN ONLY ONE AGENT: cfn-v3-coordinator**
+**THIS IS A SLASH COMMAND - MAIN CHAT EXECUTES THIS DIRECTLY**
 
+**DO NOT manually spawn Task() agents for CFN Loop workflows**
+**DO NOT spawn cfn-v3-coordinator manually**
 **DO NOT spawn Loop 3 agents (backend-dev, researcher, etc.)**
 **DO NOT spawn Loop 2 agents (reviewer, tester, etc.)**
 **DO NOT spawn product-owner**
-**DO NOT ask user which agents to use**
 
-The coordinator handles ALL agent spawning internally via CLI.
+**Main Chat simply executes the slash command - everything else is automatic**
 
 ---
 
-### Execute This Task() Call:
-
-```javascript
-Task("cfn-v3-coordinator", `
-  CFN LOOP CLI MODE - PRODUCTION EXECUTION
-
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  TASK SPECIFICATION
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  Task Description: $ARGUMENTS
-  Task ID: cfn-cli-$(date +%s)
-  Mode: ${mode.toUpperCase()}
-
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  SUCCESS CRITERIA
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  Acceptance Criteria:
-  - [ ] Core functionality implemented
-  - [ ] All tests pass with >80% coverage
-  - [ ] Security review completed
-  - [ ] Documentation updated
-  - [ ] No regression in existing features
-
-  Quality Gates (${mode.toUpperCase()} MODE):
-  - Loop 3 Gate Threshold: ${mode === 'enterprise' ? 0.85 : mode === 'standard' ? 0.75 : 0.70}
-  - Loop 2 Consensus Threshold: ${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
-  - Max Iterations: ${maxIterations}
-
-  Definition of Done:
-  - Consensus ≥ threshold achieved
-  - All acceptance criteria met
-  - Product Owner approval received
-
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  ORCHESTRATION CONFIGURATION
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  Mode: ${mode.toUpperCase()}
-
-  Loop 3 Agents (Implementation) - SELECT BASED ON TASK:
-  Examples:
-  - Backend API: backend-dev, researcher, devops
-  - Full-Stack: backend-dev, react-frontend-engineer, devops
-  - Infrastructure: devops, rust-developer, researcher
-  - Security: security-specialist, backend-dev, researcher
-
-  Loop 2 Agents (Validation) - SCALE BY COMPLEXITY:
-  Simple (1-2 files): reviewer, tester
-  Standard (3-5 files): reviewer, tester, architect, security-specialist
-  Complex (>5 files): +code-analyzer, +performance-benchmarker
-
-  Product Owner: product-owner
-
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  EXECUTION INSTRUCTIONS
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  1. INVOKE ORCHESTRATOR (CLI spawning):
-
-     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
-
-     ./.claude/skills/cfn-loop-orchestration/orchestrate.sh \\
-       --task-id "$TASK_ID" \\
-       --mode "$MODE" \\
-       --loop3-agents "$LOOP3_AGENTS" \\
-       --loop2-agents "$LOOP2_AGENTS" \\
-       --product-owner "product-owner" \\
-       --max-iterations ${maxIterations}
-
-  2. ORCHESTRATOR HANDLES:
-     - Spawns all agents via CLI (background)
-     - Loop 3: Gate check (≥threshold) → PASS/ITERATE
-     - Loop 2: Consensus check (≥threshold) → COMPLETE/ITERATE
-     - Product Owner: PROCEED/ITERATE/ABORT decision
-     - Git commit/push on PROCEED
-     - Returns structured result to Main Chat
-
-  3. RETURN STRUCTURED RESULT:
-     {
-       "taskId": "cfn-cli-XXXXX",
-       "status": "complete|failed",
-       "iterations": {"loop3": N, "loop2": M},
-       "finalConsensus": 0.XX,
-       "acceptanceCriteria": {
-         "met": [...],
-         "pending": [...]
-       },
-       "deliverables": [...],
-       "recommendations": [...]
-     }
-
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  CRITICAL RULES
-  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  - DO NOT spawn agents with Task() - orchestrator uses CLI
-  - ALL agents run in background via npx claude-flow-novice
-  - USE Redis BLPOP for loop dependencies
-  - AGENTS use Z.ai routing automatically (when enabled)
-  - RETURN structured result when complete
-`, "cfn-v3-coordinator")
-```
+## How This Command Works:
+
+When Main Chat executes `/cfn-loop-cli "task description"`, this slash command:
+
+1. **Automatically spawns cfn-v3-coordinator** with proper parameters
+2. **Coordinator invokes enhanced orchestrator** with monitoring v3.0
+3. **Orchestrator spawns all agents via CLI** (background execution)
+4. **Handles complete CFN Loop workflow** with real-time monitoring
+5. **Returns structured result** to Main Chat when complete
+
+## Enhanced Features v3.0:
+
+- ✅ **Real-time monitoring** with automatic stuck agent recovery
+- ✅ **Process health checking** and dead process cleanup
+- ✅ **Protocol compliance** preventing "consensus on vapor" anti-patterns
+- ✅ **Progress visibility** with detailed timestamped reports
+- ✅ **95-98% cost savings** with Z.ai routing optimization
+- ✅ **Background execution** with Redis persistence
 
-## Autonomous Execution Rules
+## Main Chat Execution Rules
+
+**THIS SLASH COMMAND HANDLES EVERYTHING AUTOMATICALLY**
+
+**Main Chat simply executes:**
+```bash
+/cfn-loop-cli "Task description" --mode=standard
+```
 
-**YOU ARE FORBIDDEN FROM:**
-- ❌ Asking "Should I retry?" (coordinator handles automatically)
-- ❌ Asking "Proceed to consensus?" (orchestrator decides)
-- ❌ Waiting for approval during CFN Loop cycles
-- ❌ Spawning workers with Task() (use coordinator only)
+**The slash command automatically:**
+- ✅ Spawns coordinator with proper parameters
+- ✅ Handles all agent spawning via CLI
+- ✅ Manages complete CFN Loop workflow
+- ✅ Returns structured result when complete
 
-**YOU MUST:**
-- ✅ ALWAYS spawn single coordinator agent
-- ✅ LET coordinator invoke orchestrator internally
-- ✅ COORDINATOR handles all loop execution autonomously
-- ✅ ONLY return to chat when complete or blocked
+**Main Chat should NOT:**
+- ❌ Manually spawn any Task() agents for CFN Loop
+- ❌ Ask about retry/iteration decisions (handled automatically)
+- ❌ Monitor agent progress (slash command handles this)
+- ❌ Coordinate between agents (built-in coordination)
 
 ## CLI Mode Benefits
 
@@ -217,11 +138,15 @@ Task("cfn-v3-coordinator", `
 - 95-98% savings vs Task tool spawning
 - Scales linearly with iterations (Task mode scales exponentially)
 
-**Production Features:**
+**Production Features v3.0:**
 - Background execution (no timeout issues)
 - Redis state persistence (crash recovery)
 - Zero-token waiting (BLPOP blocks without API calls)
 - Web portal visibility (http://localhost:3000)
+- **Enhanced monitoring**: Real-time agent progress tracking
+- **Automatic recovery**: Dead process cleanup and agent restart
+- **Protocol compliance**: Prevents "consensus on vapor" anti-patterns
+- **Progress visibility**: Detailed reports with timestamps and health status
 
 **Performance:**
 - Parallel agent spawning (no sequential bottleneck)

package/claude-assets/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-developer", "security-specialist"]
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "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-developer, coder
+**Base Loop 3:** backend-dev, coder
 **Add if keywords:**
 - "security", "authentication", "JWT" → security-specialist
 - "database", "SQL", "schema" → database-engineer (if exists)

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

@@ -28,57 +28,12 @@ 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-assets/skills/cfn-loop-orchestration/helpers/context-injection.sh

@@ -116,79 +116,16 @@ inject_context_for_agent() {
   local task_id="$2"
   local iteration="${3:-1}"
 
-  # Retrieve structured task context from Redis
-  local task_context=""
-  local epic_context=""
-  local phase_context=""
-  local success_criteria=""
-  local expected_files=""
-
+  # Retrieve task context from Redis
+  local task_context
   if command -v redis-cli &> /dev/null; then
-    # 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 "")
+    task_context=$(redis-cli HGET "cfn_loop:task:$task_id:context" "task_description" 2>/dev/null || echo "")
+  else
+    task_context=""
   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 "# CFN Loop Context (No Task Description)"
+    echo "# ACE Context (No Task Description)"
     echo ""
     echo "_Task description not available for context injection._"
     return 1

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

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