claude-flow-novice 2.15.11 → 2.16.1

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

@@ -1,14 +1,12 @@
 ---
-description: "Execute CFN Loop in CLI mode (production, cost-optimized, 95-98% savings)"
-argument-hint: "<task description> [--mode=mvp|standard|enterprise] [--max-iterations=n]"
-allowed-tools: ["Task", "TodoWrite", "Read", "Bash"]
+description: "Execute CFN Loop in simplified CLI mode (Main Chat coordination, provider routing)"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise] [--provider=zai|kimi|anthropic|openrouter] [--model=<model>] [--agents=N] [--threshold=0.75]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Bash", "SlashCommand"]
 ---
 
-# CFN Loop CLI Mode - Production Execution
+# CFN Loop CLI Mode - Parallel Agent Coordination
 
-🚨 **IMPORTANT: This slash command MUST auto-execute the coordinator spawn via Bash tool.**
-
-**DO NOT just show instructions. EXECUTE the bash command immediately after reading this.**
+🚨 **v2.0 ARCHITECTURE:** Main Chat spawns parallel CLI agents with threshold-based completion
 
 ---
 
@@ -18,519 +16,293 @@ allowed-tools: ["Task", "TodoWrite", "Read", "Bash"]
 ```
 TASK_DESCRIPTION: $ARGUMENTS (extract task, remove flags)
 MODE: Parse from --mode flag or default to "standard"
-MAX_ITERATIONS: Parse from --max-iterations flag or default to 10
+PROVIDER: Parse from --provider flag or use Main Chat setting
+MODEL: Parse from --model flag or use provider default
+AGENTS: Parse from --agents flag or default to 4
+THRESHOLD: Parse from --threshold flag or default to 0.75 (3/4 agents)
 ```
 
-**Step 2: Set Redis Environment Variables (REQUIRED for CLI mode)**
+**Step 2: Set Environment Variables**
 ```bash
-# Set Redis connection parameters for CLI mode
-export CFN_REDIS_HOST="${CFN_REDIS_HOST:-localhost}"
-export CFN_REDIS_PORT="${CFN_REDIS_PORT:-6379}"
-export CFN_REDIS_PASSWORD="${CFN_REDIS_PASSWORD:-${REDIS_PASSWORD:-}}"
+# Generate task ID
+TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
+echo "📋 Task ID: $TASK_ID"
+echo "🎯 Mode: $MODE"
+echo "🤖 Provider: $PROVIDER (from --provider or Main Chat setting)"
+echo "👥 Agents: $AGENTS (threshold: $THRESHOLD)"
+if [ -n "$MODEL" ]; then
+  echo "🧠 Model: $MODEL"
+fi
 
-echo "✅ Redis environment: $CFN_REDIS_HOST:$CFN_REDIS_PORT"
+# Set working directory
+export PROJECT_ROOT="${PROJECT_ROOT:-$(pwd)}"
+export TASK_ID="$TASK_ID"
+export MODE="$MODE"
 ```
 
-**Step 3: Verify Redis Availability (CRITICAL - CLI mode REQUIRES Redis)**
+**Step 3: Verify Redis Availability (Required for coordination)**
 ```bash
-# Build redis-cli command with authentication
-if [ -n "$CFN_REDIS_PASSWORD" ]; then
-  REDIS_CLI="redis-cli -h $CFN_REDIS_HOST -p $CFN_REDIS_PORT -a $CFN_REDIS_PASSWORD"
-else
-  REDIS_CLI="redis-cli -h $CFN_REDIS_HOST -p $CFN_REDIS_PORT"
-fi
-
-# Test Redis connectivity (suppress password warning)
-if ! $REDIS_CLI PING >/dev/null 2>&1; then
-  echo "❌ ERROR: Redis not available at $CFN_REDIS_HOST:$CFN_REDIS_PORT"
-  echo ""
-  echo "   CLI mode REQUIRES Redis for agent coordination."
-  echo "   Without Redis, CLI mode cannot function."
+# Check Redis connection
+if ! redis-cli ping >/dev/null 2>&1; then
+  echo "❌ ERROR: Redis not available for Main Chat coordination"
   echo ""
+  echo "   CLI mode requires Redis for agent coordination."
   echo "   Options:"
   echo "   1. Start Redis: docker-compose up -d redis"
   echo "   2. Use Task mode instead: /cfn-loop-task \"<task>\""
-  echo ""
-  echo "   If Redis is running but authentication failed:"
-  echo "   - Check CFN_REDIS_PASSWORD or REDIS_PASSWORD environment variable"
-  echo "   - Verify Redis password in .env file"
   exit 1
 fi
 
-echo "✅ Redis available and authenticated at $CFN_REDIS_HOST:$CFN_REDIS_PORT"
+echo "✅ Redis available for Main Chat coordination"
 ```
 
-**Step 4: Generate Task ID**
+**Step 4: Spawn Parallel CLI Agents**
 ```bash
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
-echo "📋 Task ID: $TASK_ID"
-```
-
-**Step 5: Spawn Coordinator (REQUIRED - Execute this command now via Bash tool)**
-```bash
-# Spawn coordinator with Redis environment variables
-CFN_REDIS_HOST="$CFN_REDIS_HOST" \
-CFN_REDIS_PORT="$CFN_REDIS_PORT" \
-CFN_REDIS_PASSWORD="$CFN_REDIS_PASSWORD" \
-npx claude-flow-novice agent cfn-v3-coordinator \
-  --task-id "$TASK_ID" \
-  --context "TASK_DESCRIPTION='$TASK_DESCRIPTION' MODE='$MODE' MAX_ITERATIONS=$MAX_ITERATIONS TASK_ID='$TASK_ID'" \
-  --timeout 300 \
-  --background=true
-```
+# Define agent types based on task complexity
+# For comprehensive tasks, spawn multiple specialized agents
+AGENT_TYPES=("backend-developer" "tester" "code-reviewer" "security-specialist")
 
-**Step 6: Inform User**
-After spawning coordinator, tell user:
-- ✅ CFN Loop coordinator spawned with task ID: $TASK_ID
-- 📊 Monitor progress: `redis-cli -h $CFN_REDIS_HOST -p $CFN_REDIS_PORT HGETALL "cfn_loop:task:$TASK_ID:context"`
-- 🌐 Web dashboard: http://localhost:3000
+echo "🚀 Spawning $AGENTS parallel CLI agents..."
 
----
-
-## Background Information (DO NOT show this to user unless they ask)
-
-**Task**: $ARGUMENTS
-
-## What is CLI Mode?
+# Spawn agents in BACKGROUND (use & to allow Main Chat to continue)
+for i in $(seq 1 $AGENTS); do
+  AGENT_TYPE="${AGENT_TYPES[$((i-1)) % ${#AGENT_TYPES[@]}]}"
+  AGENT_ID="${AGENT_TYPE}-${TASK_ID}-${i}"
 
-**CLI Mode Architecture v3.0 (Enhanced):**
-- Main Chat processes **slash command** then spawns coordinator agent via CLI with background=true
-- Coordinator spawns **all workers via CLI** with background=true for cost optimization
-- All CLI agents use **Z.ai custom routing** (when enabled)
-- **Real-time monitoring** with automatic recovery from stuck agents
-- Background execution with **Redis monitoring** and progress visibility
-- **Enhanced features**: Process health checking, context validation, broadcast protocol
+  echo "  → Spawning agent $i: $AGENT_TYPE ($AGENT_ID)"
 
+  npx claude-flow-novice agent "$AGENT_TYPE" \
+    --task-id "$TASK_ID" \
+    --mode "$MODE" \
+    --provider "$PROVIDER" \
+    --context "$TASK_DESCRIPTION" \
+    </dev/null >/tmp/agent-${AGENT_ID}.log 2>&1 &
+done
 
-## Prerequisites
-
-**Enable Z.ai Custom Routing (One-Time Setup):**
-```bash
-/switch-api zai
+echo "✅ All $AGENTS CLI agents spawned with Task ID: $TASK_ID"
 ```
 
-**Verify Status:**
+**Step 5: Wait for Threshold Completion (FOREGROUND - Required for Main Chat)**
 ```bash
-/switch-api status
-# Expected: Main Chat=Anthropic, Task=Anthropic, CLI=Z.ai
-```
+# CRITICAL: Run monitor in FOREGROUND so Main Chat receives completion signal
+# DO NOT use run_in_background for this monitoring loop
 
-## Command Options
+COMPLETION_QUEUE="cfn:cli:${TASK_ID}:completion"
+REQUIRED=$(echo "$AGENTS * $THRESHOLD" | bc | cut -d. -f1)
 
-**Usage Examples:**
-```
-# Standard mode (recommended)
-/cfn-loop-cli "Implement JWT authentication"
-
-# MVP mode (fast, lower quality gates)
-/cfn-loop-cli "Build prototype feature" --mode=mvp
+echo "⏳ Monitoring for completion (${REQUIRED}/$AGENTS agents)..."
+echo "📊 Queue: $COMPLETION_QUEUE"
+echo ""
 
-# Enterprise mode (high quality, more validators)
-/cfn-loop-cli "Production security feature" --mode=enterprise --max-iterations=15
-```
+COMPLETED=0
+END_TIME=$(($(date +%s) + 300))  # 5 minute timeout
 
-**Options:**
-- `--mode=<mvp|standard|enterprise>`: Quality mode (default: standard)
-- `--max-iterations=<n>`: Max iterations per loop (default: 10)
-
-## Mode Comparison
+while [ $(date +%s) -lt $END_TIME ] && [ $COMPLETED -lt $REQUIRED ]; do
+  QUEUE_LEN=$(redis-cli LLEN "$COMPLETION_QUEUE" 2>/dev/null || echo "0")
 
-| Mode | Gate | Consensus | Iterations | Validators | Use Case |
-|------|------|-----------|------------|------------|----------|
-| MVP | ≥0.70 | ≥0.80 | 5 | 2 | Prototypes, proof-of-concept |
-| Standard | ≥0.95 | ≥0.90 | 10 | 3-4 | Production features |
-| Enterprise | ≥0.98 | ≥0.95 | 15 | 5 | Security, compliance, critical systems |
-
-## How CLI Mode Works
-
-1. **Main Chat** invokes `/cfn-loop-cli` slash command
-2. **SlashCommand tool** processes command and returns execution instructions to Main Chat
-3. **Main Chat** spawns `cfn-v3-coordinator` agent via bash with background=true
-4. **Coordinator** orchestrates the entire CFN Loop workflow in the background
-5. **Coordinator** spawns **Loop 3 workers via CLI** with background=true
-6. **Loop 3** agents implement the solution and validate against quality gates
-7. **Coordinator** spawns **Loop 2 workers via CLI** for validation
-8. **Product Owner** makes the final decision on deliverables
-9. **Background execution** with Redis coordination for scalability
-
-**CLI Architecture Pattern:**
-- Main Chat → SlashCommand (processing) → Main Chat spawns coordinator via bash
-```bash
-npx claude-flow-novice agent cfn-v3-coordinator \
-    --task-id "cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}" \    
-    --context "TASK_DESCRIPTION='Fix core infrastructure
-  dependencies' MODE='standard' MAX_ITERATIONS=10" \
-    --timeout 300 \
-    --background=true
-```
-- All agents spawned via CLI by coordinator with Z.ai routing and background execution
-- Background execution enables monitoring and recovery capabilities
+  if [ "$QUEUE_LEN" -gt 0 ]; then
+    SIGNAL=$(redis-cli LPOP "$COMPLETION_QUEUE")
+    if [ -n "$SIGNAL" ] && [ "$SIGNAL" != "(nil)" ]; then
+      COMPLETED=$((COMPLETED + 1))
+      AGENT_ID=$(echo "$SIGNAL" | jq -r '.agentId' 2>/dev/null || echo "unknown")
+      CONFIDENCE=$(echo "$SIGNAL" | jq -r '.confidence' 2>/dev/null || echo "N/A")
+      PROVIDER=$(echo "$SIGNAL" | jq -r '.provider' 2>/dev/null || echo "N/A")
 
-## Main Chat Monitoring Instructions
+      echo "✅ Agent $COMPLETED completed: $AGENT_ID"
+      echo "   Confidence: $CONFIDENCE, Provider: $PROVIDER"
+      echo ""
 
-**After spawning the coordinator, Main Chat should:**
+      if [ $COMPLETED -ge $REQUIRED ]; then
+        echo "🎉 THRESHOLD MET! ($COMPLETED/$AGENTS agents)"
+        echo "✅ CFN Loop CLI task completed"
+        exit 0
+      fi
+    fi
+  fi
 
-### 1. Immediate Verification (First 30 seconds)
-```bash
-# Verify coordinator spawned successfully
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
-pgrep -f "cfn-v3-coordinator" && echo "✅ Coordinator running" || echo "❌ Coordinator failed"
+  sleep 3
+done
 
-# Check Redis context was created
-redis-cli EXISTS "cfn_loop:task:$TASK_ID:context" && echo "✅ Context stored" || echo "❌ No context"
+echo "⏰ Timeout: Only $COMPLETED/$AGENTS agents completed"
+exit 1
 ```
 
-### 2. Progress Monitoring (Every 2-5 minutes for long tasks)
+**Step 6: Query Agent Status (Optional - Interactive)**
 ```bash
-# Check iteration progress and confidence scores
-redis-cli HGETALL "cfn_loop:task:$TASK_ID:context" | grep -E "(iteration|confidence|status)"
+# Main Chat can query individual agent status during execution
+# Example: npx tsx src/cli/coordination/agent-messaging.ts status --task-id "$TASK_ID" --agent-id <agent-id>
 
-# Monitor agent completion status
-redis-cli LRANGE "swarm:${TASK_ID}:agent:status" 0 -1
-
-# Quick health check
-redis-cli HGET "cfn_loop:task:$TASK_ID:health" "coordinator"
+# Or send commands to running agents:
+# npx tsx src/cli/coordination/agent-messaging.ts send --task-id "$TASK_ID" --agent-id <agent-id> --command status
 ```
 
-### 3. Web Portal Monitoring (Recommended for >10 minute tasks)
-```bash
-# Start monitoring dashboard
-npm run portal:start
-
-# Access real-time progress at http://localhost:3000
-# - Live agent status dashboard
-# - Iteration progress visualization
-# - Confidence score trends
-# - Error rate monitoring
-```
-
-### 4. Background Execution Monitoring Pattern
-```bash
-# For long-running tasks, use this monitoring pattern:
-sleep 300  # Wait 5 minutes
-redis-cli HGETALL "cfn_loop:task:$TASK_ID:context" | grep status
-
-# If still running, continue monitoring
-if [ $? -eq 0 ]; then
-    echo "Task in progress, monitoring..."
-    sleep 300  # Wait another 5 minutes
-    redis-cli HGETALL "cfn_loop:task:$TASK_ID:context" | grep status
-fi
-```
-
-### 5. Troubleshooting If Coordinator Fails
-```bash
-# Investigate missing coordinator
-./.claude/skills/cfn-loop-orchestration/investigate-missing-coordinator.sh "$TASK_ID"
-
-# Check for process issues
-ps aux | grep "claude-flow-novice agent" | grep -v grep
-
-# Verify Redis connectivity
-redis-cli PING
-```
-
-## CLI Mode Benefits
-
-**Performance:**
-- Scales linearly with iterations (Task mode scales exponentially)
-- Background execution without timeout limitations
-- Parallel agent spawning for improved throughput
-
-**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)
-- Instant wake-up (<100ms latency)
-- Scalable (10+ agents, indefinite cycles)
+**Step 7: Inform User**
+Report completion status, which agents completed, and any additional information.
 
-## Troubleshooting
+---
 
-**Custom routing not working:**
-```bash
-/switch-api status  # Check current provider
-/switch-api zai     # Enable Z.ai routing
-```
+## Background Information (DO NOT show this to user unless they ask)
 
-**Coordinator timeout:**
-- Expected for long tasks (>10 min)
-- Check web portal for progress: http://localhost:3000
-- Query Redis: `redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"`
+**Task**: $ARGUMENTS
 
-**No deliverables created:**
-- Orchestrator validates deliverables before PROCEED
-- Will force ITERATE if git diff shows zero changes
-- Check coordinator output for validation failures
+## What is CLI Mode?
 
-**Web Portal Access:**
-- Monitor real-time agent progress at http://localhost:3000
-- View detailed execution logs and health status
-- Track iteration progress and confidence scores
+**v2.0 CLI Mode Architecture (Parallel + Messaging):**
+- **Main Chat** spawns multiple CLI agents in parallel
+- **CLI agents** execute tasks and send Redis completion signals
+- **Main Chat** waits for threshold completion (e.g., 3/4 agents)
+- **Bidirectional messaging** - Main Chat can send commands to running agents
+- **Provider routing** via `--provider` and `--model` flags
+- **Graceful degradation** - continues when threshold met, doesn't wait for stragglers
 
-## Enhanced Monitoring v3.0
+## New Features (v2.0)
 
-CLI mode includes comprehensive monitoring capabilities for production workflows:
+### Parallel Agent Spawning
+- Spawn multiple agents simultaneously (default: 4)
+- Each agent works independently on the task
+- Different agent types for comprehensive coverage
 
-### Real-Time Progress Tracking
-- **Agent Status**: Monitor individual agent health and progress
-- **Iteration Progress**: Track confidence scores and gate validation
-- **Resource Usage**: CPU, memory, and Redis connection monitoring
-- **Error Detection**: Automatic identification of stuck or failed agents
+### Threshold-Based Completion
+- Exit when N/M agents complete (default: 75%)
+- Don't wait for slow/stuck agents
+- Configurable via `--threshold` flag
 
-### Monitoring Commands
+### Bidirectional Messaging
+Main Chat can communicate with running agents:
 
-**Check Task Status:**
+**Query agent status:**
 ```bash
-# View complete task context and progress
-redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"
-
-# Monitor agent completion status
-redis-cli LRANGE "swarm:${TASK_ID}:agent:status" 0 -1
+npx tsx src/cli/coordination/agent-messaging.ts status \
+  --task-id "$TASK_ID" --agent-id <agent-id>
 ```
 
-**Agent Health Monitoring:**
+**Send commands to agents:**
 ```bash
-# Check if coordinator is running
-pgrep -f "cfn-v3-coordinator" && echo "Coordinator alive" || echo "Coordinator missing"
+# Request status update
+npx tsx src/cli/coordination/agent-messaging.ts send \
+  --task-id "$TASK_ID" --agent-id <agent-id> --command status
 
-# Monitor active agent processes
-ps aux | grep "claude-flow-novice agent" | grep -v grep
+# Redirect agent to new task
+npx tsx src/cli/coordination/agent-messaging.ts send \
+  --task-id "$TASK_ID" --agent-id <agent-id> --command redirect \
+  --payload '{"newTask": "Focus on security tests"}'
 
-# Check Redis connectivity
-redis-cli PING
-```
-
-**Progress Monitoring:**
-```bash
-# Real-time agent completion monitoring
-watch -n 5 'redis-cli HGETALL "cfn_loop:task:$TASK_ID:context" | grep -E "(iteration|confidence|status)"'
+# Abort agent
+npx tsx src/cli/coordination/agent-messaging.ts send \
+  --task-id "$TASK_ID" --agent-id <agent-id> --command abort
 
-# Monitor agent signals
-redis-cli PUBLISH "swarm:${TASK_ID}:monitor" "status_check"
+# Pause agent
+npx tsx src/cli/coordination/agent-messaging.ts send \
+  --task-id "$TASK_ID" --agent-id <agent-id> --command pause \
+  --payload '{"seconds": 30}'
 ```
 
-### Automatic Recovery Features
-
-**Dead Process Detection:**
-- Automatically detects and reports stuck agents
-- Process health checking with configurable timeouts
-- Automatic cleanup of orphaned Redis connections
-
-**Agent Restart Capability:**
-- Coordinator can restart failed agents automatically
-- Context preservation across agent restarts
-- Iteration state recovery from Redis persistence
-
-**Error Recovery Patterns:**
-- Timeout detection and agent termination
-- Context validation before spawning replacements
-- Graceful degradation with partial agent sets
-
-### Monitoring Dashboard Features
-
-**Web Portal (http://localhost:3000):**
-- Live agent status dashboard
-- Iteration progress visualization
-- Confidence score trends
-- Error rate monitoring
-- Resource usage graphs
-
-**CLI Monitoring Tools:**
-- `cfn-portal` - Start/stop monitoring dashboard
-- `cfn-context` - Query task context and status
-- `cfn-metrics` - View performance analytics
-- `cfn-redis` - Direct Redis inspection tools
-
-### Troubleshooting Monitoring Issues
+## Prerequisites
 
-**Missing Coordinator:**
+**Redis Required:**
 ```bash
-# Investigate coordinator failure
-./.claude/skills/cfn-loop-orchestration/investigate-missing-coordinator.sh "$TASK_ID"
+# Start Redis for coordination
+docker-compose up -d redis
 
-# Check for namespace mismatches
-redis-cli KEYS "cfn_loop:*" | head -10
+# Verify Redis is running
+redis-cli ping
 ```
 
-**Stuck Agents:**
+**Provider Routing Setup (Optional):**
 ```bash
-# Force cleanup of stuck agents
-./.claude/skills/cfn-loop-orchestration/cleanup-stuck-agents.sh "$TASK_ID"
-
-# Monitor agent timeouts
-redis-cli HGET "cfn_loop:task:$TASK_ID:timeouts" "agent_timeouts"
+# Configure Main Chat provider
+/switch-api zai    # Cost-optimized
+/switch-api kimi   # Mid-range quality
+/switch-api max    # High quality (Anthropic)
 ```
 
-**Redis Connection Issues:**
-```bash
-# Test Redis connectivity
-redis-cli -n 0 PING
-
-# Check Redis memory usage
-redis-cli INFO memory | grep used_memory_human
+## Command Options
 
-# Monitor Redis keyspace
-redis-cli DBSIZE
+**Usage Examples:**
 ```
+# Standard mode with default provider
+/cfn-loop-cli "Implement JWT authentication"
 
-## Usage Examples
-
-**Simple API Development:**
-```
-/cfn-loop-cli "Build REST API with user authentication"
-```
+# With specific provider
+/cfn-loop-cli "Build API service" --provider kimi
 
-**Complex Feature with High Quality Requirements:**
-```
-/cfn-loop-cli "Implement payment processing with PCI compliance" --mode=enterprise --max-iterations=15
-```
+# With specific provider and model
+/cfn-loop-cli "Create React component" --provider openrouter --model gpt-4
 
-**Quick Prototype:**
-```
-/cfn-loop-cli "Build MVP landing page" --mode=mvp
-```
+# MVP mode for fast prototyping
+/cfn-loop-cli "Build feature prototype" --mode=mvp
 
-**Infrastructure Deployment:**
+# Enterprise mode for critical systems
+/cfn-loop-cli "Security audit" --mode=enterprise --provider max
 ```
-/cfn-loop-cli "Set up CI/CD pipeline for microservices"
-```
-
-## Related Commands
-
-- **Task Mode**: `/cfn-loop-task` (debugging, full visibility)
-- **Frontend**: `/cfn-loop-frontend` (visual iteration workflow)
-- **Documentation**: `/cfn-loop-document` (generate docs)
-
-## Related Documentation
-
-- Task Mode Guide: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
-- Coordinator Parameters: `.claude/commands/cfn/CFN_COORDINATOR_PARAMETERS.md`
-- Redis Coordination: `.claude/skills/cfn-redis-coordination/SKILL.md`
-- Orchestration: `.claude/skills/cfn-loop-orchestration/SKILL.md`
-
----
-
-## 🚨 EXECUTION INSTRUCTIONS (Internal Use)
-
-**Main Chat: Slash command processing followed by CLI coordinator spawning:**
-
-The SlashCommand tool processes the command and returns execution instructions. Main Chat then spawns the coordinator agent using CLI with background=true for monitoring capabilities.
 
-**Coordinator Spawning Pattern:**
+**Options:**
+- `--mode=<mvp|standard|enterprise>`: Quality mode (default: standard)
+- `--provider=<zai|kimi|anthropic|openrouter>`: AI provider (default: Main Chat setting)
+- `--model=<model>`: Specific model (provider-specific)
 
-```bash
-# Generate unique task ID
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
+## Provider Routing Behavior
 
-# Extract task description and mode from slash command
-TASK_DESCRIPTION="$ARGUMENTS"
-MODE="${mode:-standard}"
-MAX_ITERATIONS="${maxIterations:-10}"
-
-# Spawn coordinator via CLI (background execution)
-npx claude-flow-novice agent cfn-v3-coordinator \
-  --task-id "$TASK_ID" \
-  --context "TASK_DESCRIPTION='$TASK_DESCRIPTION' MODE='$MODE' MAX_ITERATIONS=$MAX_ITERATIONS" \
-  --timeout 300 \
-  --background=true
-```
+**Main Chat + Task() tools:** Controlled by `/switch-api` command
 
-**Main Chat Execution Command:**
+**CLI agents:**
+- Uses `--provider` flag if specified
+- Falls back to Main Chat provider setting
+- Default to Z.ai glm-4.6 if no provider configured
 
-```bash
-# Main Chat should execute this command after processing slash command
-npx claude-flow-novice agent cfn-v3-coordinator \
-  --task-id "cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}" \
-  --context "TASK_DESCRIPTION='Fix core infrastructure dependencies - lucide-wrappers.tsx LucideIcon React 18 compatibility, resolve module export errors in types/, establish proper import path resolution' MODE='standard' MAX_ITERATIONS=10" \
-  --timeout 300 \
-  --background=true
-```
+**Fallback Hierarchy:**
+1. `--provider` flag (explicit)
+2. Main Chat provider setting (from `/switch-api`)
+3. Z.ai glm-4.6 (cost-effective default)
 
-**Internal Coordinator Pattern (what the coordinator does):**
-
-```bash
-# Generate unique task ID
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
-
-# Extract task description and mode from slash command arguments
-TASK_DESCRIPTION="parsed from $ARGUMENTS"
-MODE="${mode:-standard}"
-MAX_ITERATIONS="${maxIterations:-10}"
-
-# Determine appropriate agents based on task complexity
-TASK_COMPLEXITY="standard"  # auto-detect or pass from command
-case "$TASK_COMPLEXITY" in
-  "simple")
-    LOOP3_AGENTS="backend-dev,researcher"
-    LOOP2_AGENTS="reviewer,tester"
-    ;;
-  "standard")
-    LOOP3_AGENTS="backend-dev,researcher,devops"
-    LOOP2_AGENTS="reviewer,tester,architect,security-specialist"
-    ;;
-  "complex")
-    LOOP3_AGENTS="backend-dev,researcher,devops,rust-developer"
-    LOOP2_AGENTS="reviewer,tester,architect,security-specialist,code-analyzer"
-    ;;
-esac
-
-# Coordinator spawns CLI workers (background execution)
-npx claude-flow-novice agent "$LOOP3_AGENT" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "Complete deliverables and acceptance criteria" \
-  --timeout 300 \
-  --background=true
-
-# Monitor progress (required for background tasks)
-# redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"
-```
+## Mode Comparison
 
-**Critical Background Execution Instructions:**
-
-1. **Always use `--background=true`** for CLI mode to enable:
-   - Non-blocking coordinator execution
-   - Real-time monitoring capabilities
-   - Redis state persistence
-   - Automatic recovery features
-
-2. **Background execution means:**
-   - Coordinator runs independently of Main Chat
-   - Main Chat can monitor progress via Redis queries
-   - Long-running tasks won't timeout due to Bash tool limitations
-   - Web portal can track agent progress in real-time
-
-3. **Without `--background=true`:**
-   - Coordinator blocks Main Chat execution
-   - No monitoring capabilities
-   - Timeouts after 10 minutes (Bash tool limit)
-   - No recovery or persistence features
-
-**Why This Pattern:**
-- ✅ Coordinator via CLI with background=true for monitoring capabilities
-- ✅ All agents via CLI for maximum cost optimization (95-98% savings)
-- ✅ Background execution with enhanced monitoring
-- ✅ Z.ai routing automatically applied to all CLI agents
-- ✅ Redis coordination for agent communication
-- ✅ Enhanced monitoring and recovery capabilities
-- ✅ Clean separation: Main Chat → SlashCommand (processing) → Main Chat spawns CLI(coordinator) → CLI Workers
-- ✅ Production-ready with real-time progress tracking
-- ✅ No timeout limitations with `--background=true`
-
-**Enhanced Monitoring Benefits:**
-- Real-time agent progress tracking via Redis
-- Automatic recovery from stuck agents
-- Web portal visibility (http://localhost:3000)
-- Process health checking and cleanup
-- Context validation and preservation
-- Performance metrics and analytics
-
-**Version:** 3.1.0 (2025-11-05) - Removed cost information, added Main Chat monitoring instructions, clarified background execution requirements
+| Mode | Quality | Use Case | Description |
+|------|---------|----------|-------------|
+| MVP | Fast (70% gates) | Prototypes, quick experiments | Lower quality gates, fewer iterations |
+| Standard | Production (95% gates) | Most features | Balanced quality and speed |
+| Enterprise | High (98% gates) | Security, compliance | Maximum quality, thorough validation |
+
+## How New CLI Mode Works
+
+1. **Main Chat** processes `/cfn-loop-cli` command
+2. **Main Chat** spawns CLI agent directly with provider routing
+3. **CLI Agent** executes task with specified AI provider
+4. **CLI Agent** sends Redis completion signal when finished
+5. **Main Chat** receives signal via Redis BLPOP and continues
+6. **No complex orchestrator needed** - simple 2-layer coordination
+
+## Agent Environment Variables
+
+CLI agents automatically receive:
+- `TASK_ID`: Unique task identifier
+- `MODE`: Quality mode (mvp/standard/enterprise)
+- `PROVIDER`: AI provider (zai/kimi/anthropic/openrouter)
+- `MODEL`: Specific AI model
+- `AGENT_ID`: Generated unique agent identifier
+
+## Redis Signal Format
+
+CLI agents send completion signals in this format:
+```json
+{
+  "agentId": "agent-backend-dev-12345",
+  "taskId": "cfn-cli-67890",
+  "status": "completed",
+  "timestamp": "2025-11-22T12:00:00.000Z",
+  "provider": "kimi",
+  "model": "moonshot-v1-8k",
+  "confidence": 0.90,
+  "metadata": {
+    "iteration": 1,
+    "mode": "standard"
+  }
+}
+```
+
+This simplified architecture provides:
+- ✅ **Direct coordination** - Main Chat to CLI agents
+- ✅ **Provider flexibility** - Different AI providers per agent
+- ✅ **Cost optimization** - Use appropriate providers for each task
+- ✅ **Reliable signaling** - Redis BLPOP for coordination
+- ✅ **Simple architecture** - No complex orchestrator needed