claude-flow-novice 2.15.10 → 2.16.0

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>]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Bash", "SlashCommand"]
 ---
 
-# CFN Loop CLI Mode - Production Execution
+# CFN Loop CLI Mode - Simplified Main Chat 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.**
+🚨 **NEW ARCHITECTURE:** Main Chat directly coordinates CLI agents via Redis BLPOP signaling
 
 ---
 
@@ -18,519 +16,215 @@ 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
 ```
 
-**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)"
+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"
-```
-
-**Step 4: Generate Task ID**
-```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
+echo "✅ Redis available for Main Chat coordination"
 ```
 
-**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
-
----
-
-## Background Information (DO NOT show this to user unless they ask)
-
-**Task**: $ARGUMENTS
-
-## What is CLI Mode?
-
-**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
-
-
-## Prerequisites
-
-**Enable Z.ai Custom Routing (One-Time Setup):**
+**Step 4: Spawn Initial CLI Agent (Main Chat Coordination Pattern)**
 ```bash
-/switch-api zai
-```
+# Determine first agent type based on task
+# This is a simplified selection - could be enhanced with task classification
+AGENT_TYPE="backend-developer"
 
-**Verify Status:**
-```bash
-/switch-api status
-# Expected: Main Chat=Anthropic, Task=Anthropic, CLI=Z.ai
-```
+# Spawn first CLI agent with provider routing
+echo "🚀 Spawning CLI agent: $AGENT_TYPE"
 
-## Command Options
-
-**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
+npx tsx src/cli/spawn-agent-cli.ts "$AGENT_TYPE" \
+  --task-id "$TASK_ID" \
+  --mode "$MODE" \
+  ${PROVIDER:+--provider "$PROVIDER"} \
+  ${MODEL:+--model "$MODEL"} \
+  --background
 
-# Enterprise mode (high quality, more validators)
-/cfn-loop-cli "Production security feature" --mode=enterprise --max-iterations=15
+echo "✅ CLI agent spawned with Task ID: $TASK_ID"
 ```
 
-**Options:**
-- `--mode=<mvp|standard|enterprise>`: Quality mode (default: standard)
-- `--max-iterations=<n>`: Max iterations per loop (default: 10)
-
-## Mode Comparison
-
-| 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
+**Step 5: Wait for Agent Completion (Main Chat BLPOP Pattern)**
 ```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
+# Main Chat waits for completion signal via Redis BLPOP
+echo "⏳ Waiting for CLI agent completion..."
 
-## Main Chat Monitoring Instructions
+SIGNAL_KEY="cfn:mainchat:signal:$TASK_ID"
+TIMEOUT_SECONDS=120
 
-**After spawning the coordinator, Main Chat should:**
+# Wait for completion signal with timeout
+COMPLETION_SIGNAL=$(timeout $TIMEOUT_SECONDS redis-cli BLPOP "$SIGNAL_KEY" $((TIMEOUT_SECONDS + 10)))
 
-### 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"
-
-# Check Redis context was created
-redis-cli EXISTS "cfn_loop:task:$TASK_ID:context" && echo "✅ Context stored" || echo "❌ No context"
-```
-
-### 2. Progress Monitoring (Every 2-5 minutes for long tasks)
-```bash
-# Check iteration progress and confidence scores
-redis-cli HGETALL "cfn_loop:task:$TASK_ID:context" | grep -E "(iteration|confidence|status)"
+if [ $? -eq 0 ] && [ -n "$COMPLETION_SIGNAL" ]; then
+  echo "✅ CLI agent completed successfully"
+  echo "📊 Completion signal received via Redis"
 
-# Monitor agent completion status
-redis-cli LRANGE "swarm:${TASK_ID}:agent:status" 0 -1
+  # Parse completion signal (second line contains JSON)
+  SIGNAL_DATA=$(echo "$COMPLETION_SIGNAL" | tail -n 1)
+  echo "🔍 Agent signal: $SIGNAL_DATA"
 
-# Quick health check
-redis-cli HGET "cfn_loop:task:$TASK_ID:health" "coordinator"
-```
-
-### 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
+  # Could spawn additional agents here based on signal content
+  # For now, we'll consider the task complete
+  echo "🎉 CFN Loop CLI task completed"
+else
+  echo "⚠️  CLI agent did not complete within timeout ($TIMEOUT_SECONDS seconds)"
+  echo "💡 Check agent logs or increase timeout if needed"
 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)
-
-## Troubleshooting
-
-**Custom routing not working:**
-```bash
-/switch-api status  # Check current provider
-/switch-api zai     # Enable Z.ai routing
-```
-
-**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"`
-
-**No deliverables created:**
-- Orchestrator validates deliverables before PROCEED
-- Will force ITERATE if git diff shows zero changes
-- Check coordinator output for validation failures
-
-**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
-
-## Enhanced Monitoring v3.0
-
-CLI mode includes comprehensive monitoring capabilities for production workflows:
-
-### 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
-
-### Monitoring Commands
-
-**Check Task 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
-```
-
-**Agent Health Monitoring:**
-```bash
-# Check if coordinator is running
-pgrep -f "cfn-v3-coordinator" && echo "Coordinator alive" || echo "Coordinator missing"
-
-# Monitor active agent processes
-ps aux | grep "claude-flow-novice agent" | grep -v grep
-
-# 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)"'
-
-# Monitor agent signals
-redis-cli PUBLISH "swarm:${TASK_ID}:monitor" "status_check"
-```
-
-### 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
+**Step 6: Inform User**
+Report completion status and any additional information.
 
-### Monitoring Dashboard Features
+---
 
-**Web Portal (http://localhost:3000):**
-- Live agent status dashboard
-- Iteration progress visualization
-- Confidence score trends
-- Error rate monitoring
-- Resource usage graphs
+## Background Information (DO NOT show this to user unless they ask)
 
-**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
+**Task**: $ARGUMENTS
 
-### Troubleshooting Monitoring Issues
+## What is CLI Mode?
 
-**Missing Coordinator:**
-```bash
-# Investigate coordinator failure
-./.claude/skills/cfn-loop-orchestration/investigate-missing-coordinator.sh "$TASK_ID"
+**NEW CLI Mode Architecture (Simplified):**
+- **Main Chat** directly spawns CLI agents with provider routing
+- **CLI agents** execute tasks and send Redis completion signals
+- **Main Chat** waits via Redis BLPOP for agent completion
+- **2-layer coordination** (Main Chat → CLI agents)
+- **Provider routing** via `--provider` and `--model` flags
+- **Fallback behavior** to Z.ai glm-4.6 if no provider specified
 
-# Check for namespace mismatches
-redis-cli KEYS "cfn_loop:*" | head -10
-```
+## Prerequisites
 
-**Stuck Agents:**
+**Redis Required:**
 ```bash
-# Force cleanup of stuck agents
-./.claude/skills/cfn-loop-orchestration/cleanup-stuck-agents.sh "$TASK_ID"
+# Start Redis for coordination
+docker-compose up -d redis
 
-# Monitor agent timeouts
-redis-cli HGET "cfn_loop:task:$TASK_ID:timeouts" "agent_timeouts"
+# Verify Redis is running
+redis-cli ping
 ```
 
-**Redis Connection Issues:**
+**Provider Routing Setup (Optional):**
 ```bash
-# Test Redis connectivity
-redis-cli -n 0 PING
-
-# Check Redis memory usage
-redis-cli INFO memory | grep used_memory_human
-
-# Monitor Redis keyspace
-redis-cli DBSIZE
-```
-
-## Usage Examples
-
-**Simple API Development:**
-```
-/cfn-loop-cli "Build REST API with user authentication"
+# Configure Main Chat provider
+/switch-api zai    # Cost-optimized
+/switch-api kimi   # Mid-range quality
+/switch-api max    # High quality (Anthropic)
 ```
 
-**Complex Feature with High Quality Requirements:**
-```
-/cfn-loop-cli "Implement payment processing with PCI compliance" --mode=enterprise --max-iterations=15
-```
-
-**Quick Prototype:**
-```
-/cfn-loop-cli "Build MVP landing page" --mode=mvp
-```
+## Command Options
 
-**Infrastructure Deployment:**
-```
-/cfn-loop-cli "Set up CI/CD pipeline for microservices"
+**Usage Examples:**
 ```
+# Standard mode with default provider
+/cfn-loop-cli "Implement JWT authentication"
 
-## 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:**
+# With specific provider
+/cfn-loop-cli "Build API service" --provider kimi
 
-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.
+# With specific provider and model
+/cfn-loop-cli "Create React component" --provider openrouter --model gpt-4
 
-**Coordinator Spawning Pattern:**
+# MVP mode for fast prototyping
+/cfn-loop-cli "Build feature prototype" --mode=mvp
 
-```bash
-# Generate unique task ID
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
-
-# 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
+# Enterprise mode for critical systems
+/cfn-loop-cli "Security audit" --mode=enterprise --provider max
 ```
 
-**Main Chat Execution Command:**
+**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
-# 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
-```
+## Provider Routing Behavior
 
-**Internal Coordinator Pattern (what the coordinator does):**
+**Main Chat + Task() tools:** Controlled by `/switch-api` command
 
-```bash
-# Generate unique task ID
-TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
+**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
 
-# 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
+**Fallback Hierarchy:**
+1. `--provider` flag (explicit)
+2. Main Chat provider setting (from `/switch-api`)
+3. Z.ai glm-4.6 (cost-effective default)
 
-# 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