claude-flow-novice 2.14.0 → 2.14.1

package/.claude/commands/cfn/README.md

@@ -1,157 +1,205 @@
-# CLAUDE.md Slash Command System
+# CFN Loop Commands - Quick Reference
 
-## 🎯 Simple, Focused CLAUDE.md Generation
+## Workflows vs Skills vs Playbooks - When to Use What
 
-A lightweight slash command system for generating CLAUDE.md files with NPX protection.
+### Skills (Most Common) - Building Blocks
+**What:** Single-purpose bash scripts in `.claude/skills/`
+**When:** Most tasks - they're the building blocks
+**Example:** `cfn-redis-coordination`, `cfn-agent-spawning`, `cfn-loop-validation`
 
-## 📋 Features
-
-### ✅ **Simple Slash Command**
 ```bash
-/claude-md                    # Generate CLAUDE.md for current project
-/claude-md --preview         # Show what would be generated
-/claude-md --force           # Overwrite without confirmation
-/claude-md --detect          # Auto-detect project and show recommendations
-/claude-md --no-backup       # Skip backup creation
+# Direct skill invocation
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh enter \
+  --task-id "task-123" \
+  --agent-id "coder-1"
 ```
 
-### 🛡️ **NPX Protection System**
-- **Problem**: NPX installs overwrite customized CLAUDE.md files
-- **Solution**: Generate `claude-copy-to-main.md` when existing CLAUDE.md detected
-- **Benefit**: User customizations are never lost
+**Use skills when:**
+- Single, focused operation needed
+- Called by agents or coordinators
+- Part of larger workflow
+- Reusable across different tasks
+
+### Playbooks (Not Currently Used) - Pre-Configured Sequences
+**What:** JSON files defining skill sequences for common patterns
+**When:** Repeating the same skill sequence often
+**Status:** Not implemented yet, use skills directly
+
+### Workflows - Complex Automation
+**What:** Event-driven, multi-step automation with conditions/branching
+**When:** Complex sequences with conditional logic
+**Example:** CI/CD pipelines, feature development workflows
+
+```yaml
+name: "feature-development"
+trigger: "branch-created"
+steps:
+  - name: "analyze"
+    agent: "researcher"
+
+  - name: "implement"
+    agent: "backend-dev"
+    depends: ["analyze"]
+    parallel: true  # Multiple agents in parallel
+
+  - name: "test"
+    agent: "tester"
+    depends: ["implement"]
+    condition: "if tests_exist"  # Conditional execution
+```
 
-### 🔄 **Integration Flow**
+**Use workflows when:**
+- Event-driven automation (git hooks, CI/CD)
+- Conditional branching logic needed
+- Multi-agent parallel execution
+- Long-running background processes
+- Integration with external systems
 
-**Normal Usage (Slash Command):**
-1. User runs `/claude-md`
-2. System detects project type
-3. Generates appropriate CLAUDE.md
-4. Creates backup if file exists
+## Decision Tree
 
-**NPX Install Protection:**
-1. NPX installs claude-flow-novice
-2. `postinstall` script runs
-3. Detects existing CLAUDE.md
-4. Creates `claude-copy-to-main.md` instead
-5. User manually merges desired changes
+```
+Need to automate something?
+├─ Single operation?
+│  └─ Use SKILL directly
+├─ Complex logic (conditionals, events, parallel)?
+│  └─ Create WORKFLOW (YAML via /workflow)
+└─ CFN Loop execution?
+   ├─ Planning first? → /write-plan then /cfn-loop-cli
+   ├─ Production? → /cfn-loop-cli
+   ├─ Debugging? → /cfn-loop-task
+   └─ Frontend? → /cfn-loop-frontend
+```
 
-## 🏗️ Architecture
+## Examples
 
-### **Files:**
-- `claude-md.js` - Core slash command implementation
-- `register-claude-md.js` - Slash command registration
-- `../npx/claude-md-protection.js` - NPX protection logic
-- `../../scripts/post-install-claude-md.js` - Post-install hook
+### Example 1: Simple Task (Use Skill)
+**Goal:** Enter waiting mode for agent
 
-### **Integration Points:**
-- **Existing Generator**: Uses `../language/claude-md-generator.js`
-- **Language Detection**: Uses `../language/language-detector.js`
-- **Preferences**: Reads `.claude-flow-novice/preferences/generation.json`
-- **Package.json**: `postinstall` script triggers protection
+```bash
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh enter \
+  --task-id "task-123" --agent-id "coder-1"
+```
 
-## 🎮 Usage Examples
+### Example 2: CFN Loop Execution
+**Goal:** Implement JWT authentication
 
-### **Basic Generation:**
+**Option 1: Plan First (Recommended for Complex Tasks)**
 ```bash
-# Generate CLAUDE.md for current project
-/claude-md
+# Step 1: Generate plan
+/write-plan "Implement JWT authentication" --mode=standard
+# Reviews: planning/PLAN_jwt_authentication.md
 
-# Output:
-# 🚀 Generating CLAUDE.md...
-# ✅ CLAUDE.md generated successfully
+# Step 2: Execute
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
 ```
 
-### **Preview Mode:**
+**Option 2: Direct Execution (Simple Tasks)**
 ```bash
-# See what would be generated
-/claude-md --preview
-
-# Output:
-# 📄 CLAUDE.md Preview:
-# ══════════════════════════════════════════════════
-# # Claude Code Configuration - JavaScript Project
-# ...
-# ══════════════════════════════════════════════════
-# 📊 Total length: 2,847 characters
+# Production execution (cost-optimized)
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+
+# OR debugging (full visibility)
+/cfn-loop-task "Implement JWT authentication" --mode=standard
 ```
 
-### **NPX Protection:**
+### Example 3: Complex Automation (Use Workflow)
+**Goal:** Full feature development (analyze → implement → test → deploy)
+
 ```bash
-# When NPX detects existing CLAUDE.md
-npm install claude-flow-novice
-
-# Output:
-# 🛡️ NPX Protection Activated
-# 📄 Generated: claude-copy-to-main.md
-# 💡 Your existing CLAUDE.md is protected from overwrite
-# 🔄 Review and merge changes manually as needed
-```
+# Create workflow (via /workflow)
+/workflow create feature-pipeline
 
-## 🧠 Smart Detection
-
-### **Project Type Detection:**
-- Analyzes `package.json`, file patterns, and directory structure
-- Detects frameworks (React, Express, Django, etc.)
-- Suggests appropriate CLAUDE.md configurations
-
-### **Confidence Levels:**
-- **High (>70%)**: Automatic generation recommended
-- **Medium (30-70%)**: Generate with user confirmation
-- **Low (<30%)**: Manual review suggested
-
-## 🔧 Configuration
-
-### **Generation Preferences:**
-`.claude-flow-novice/preferences/generation.json`:
-```json
-{
-  "autoGenerate": true,
-  "includeFrameworkSpecific": true,
-  "includeBestPractices": true,
-  "backupExisting": true,
-  "confidenceThreshold": 0.3
-}
+# Execute workflow
+/workflow execute feature-pipeline
 ```
 
-### **NPX Detection:**
-- Environment variables (`NPX_INSTALL=true`)
-- Temporary directory patterns (`/.npm/_npx/`)
-- Package.json analysis (fresh installs)
-
-## 🎯 Design Principles
-
-### **Keep It Simple:**
-- Single focused command
-- Minimal configuration
-- Clear user feedback
-- No feature bloat
-
-### **Protect User Work:**
-- Never overwrite without permission
-- Always offer backup options
-- Provide clear merge instructions
-- Preserve customizations
-
-### **Smart Defaults:**
-- Auto-detect project type
-- Use appropriate templates
-- Respect user preferences
-- Fail safely
-
-## 🚀 Future Enhancements
-
-### **Potential Improvements (If Needed):**
-- Interactive confirmation prompts
-- Template customization options
-- Multi-project detection
-- Advanced merge assistance
-
-### **Not Planned (Avoiding Bloat):**
-- SQLite analysis integration
-- Multi-file scaffolding
-- Complex workflow automation
-- Enterprise features
+## Quick Reference Table
+
+| Type | Files | Complexity | Conditional Logic | Parallel Execution | Event-Driven |
+|------|-------|------------|-------------------|-------------------|--------------|
+| **Skill** | `.sh` scripts | Low | No | No | No |
+| **CFN Loop** | Slash commands | Medium | Yes (built-in) | Yes (agents) | No |
+| **Workflow** | `.yaml` definitions | High | Yes | Yes | Yes |
+
+---
+
+## CFN Loop Commands (Current)
+
+### Execution Commands
+- `/cfn-loop-task` - Task mode (debugging, full visibility, Main Chat coordinates)
+- `/cfn-loop-cli` - CLI mode (production, cost-optimized, coordinator spawns CLI agents)
+- `/cfn-loop-frontend` - Visual iteration (screenshot + video validation, supports both modes)
+
+### Planning & Documentation
+- `/write-plan` - Pre-planning phase (generates TDD implementation plan)
+- `/cfn-loop-document` - Documentation generation (updates `/readme`)
+
+### Configuration
+- `/cfn-mode` - Toggle CLI vs Task spawning mode
+- `/cfn-optimize-agents` - Agent optimization settings
+- `/cfn-claude-sync` - Sync rules from CLAUDE.md to commands
+
+### Infrastructure
+- `/switch-api` - Switch between Z.ai and Anthropic providers
+
+### Automation
+- `/workflow` - Event-driven workflow automation (complex multi-step)
+
+### Testing & Utilities
+- `/hello-world-tests` - CFN coordination validation tests (4 layers)
+- `/github-commit` - Git commit with CI/CD monitoring
+- `/launch-web-dashboard` - Start web portal (http://localhost:3000)
+- `/list-agents-rebuild` - Regenerate agent list from discovery
+
+### Adaptive Context (ACE System)
+- `/context-stats` - View adaptive context statistics
+- `/context-reflect` - Extract lessons from task execution
+- `/context-query` - Query context bullets by category/tags
+- `/context-inject` - Inject context into CLAUDE.md dynamically
+- `/context-curate` - Merge reflection deltas with deduplication
+
+---
+
+## When to Use Each Command
+
+### /write-plan (Pre-Planning)
+**Use before complex CFN Loop tasks:**
+- Security-critical features
+- Complex architecture decisions
+- Team collaboration (plan review)
+- Learning CFN Loop workflow
+
+### /cfn-loop-cli (Production)
+**Use for:**
+- Production features
+- Long-running tasks (>10 min)
+- Multi-iteration workflows
+- Cost-sensitive projects
+- **Cost:** $0.054/iteration with Z.ai routing
+
+### /cfn-loop-task (Debugging)
+**Use for:**
+- Debugging CFN Loop issues
+- Learning agent interactions
+- Prototyping configurations
+- Short tasks (<5 min)
+- **Cost:** $0.150/iteration (3x CLI, but full visibility)
+
+### /cfn-loop-frontend (Visual Iteration)
+**Use for:**
+- React/Vue/Angular components
+- UI implementation with mockups
+- Accessibility validation
+- Visual regression testing
+- **Supports:** Both CLI and Task modes
+
+### /workflow (Complex Automation)
+**Use for:**
+- CI/CD pipelines
+- Event-driven automation
+- Multi-step with conditionals
+- External system integration
 
 ---
 
-**Simple, focused, and protective - exactly what CLAUDE.md generation should be!** 🎯
+**Version:** 3.0.0 (2025-10-31) - Consolidated command structure with workflows/skills guide

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

@@ -0,0 +1,279 @@
+---
+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"]
+---
+
+# CFN Loop CLI Mode - Production Execution
+
+Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task tool).
+
+🚨 **CLI MODE: Production, Cost-Optimized, Background Execution**
+
+**Task**: $ARGUMENTS
+
+## What is CLI Mode?
+
+**CLI Mode Architecture:**
+- Main Chat spawns **single coordinator agent** via Task()
+- Coordinator spawns **all workers via CLI** (`npx claude-flow-novice`)
+- CLI agents use **Z.ai custom routing** (when enabled)
+- Background execution with **Redis monitoring**
+- **95-98% cost savings** vs Task tool spawning
+
+**Cost Breakdown:**
+```
+┌─────────────────────┬──────────────┬────────────┐
+│ Component           │ Provider     │ Cost/Call  │
+├─────────────────────┼──────────────┼────────────┤
+│ Main Chat           │ Anthropic    │ $0.015     │
+│ Coordinator (Task)  │ Anthropic    │ $0.015     │
+│ Loop 3 Agents (CLI) │ Z.ai         │ $0.003 ea  │
+│ Loop 2 Agents (CLI) │ Z.ai         │ $0.003 ea  │
+│ Product Owner (CLI) │ Z.ai         │ $0.003     │
+└─────────────────────┴──────────────┴────────────┘
+
+Total per iteration: ~$0.054 (vs $0.150 Task mode)
+Savings: 64% with custom routing, 95-98% vs all-Task
+```
+
+## Prerequisites
+
+**Enable Z.ai Custom Routing (One-Time Setup):**
+```bash
+/switch-api zai
+```
+
+**Verify Status:**
+```bash
+/switch-api status
+# Expected: Main Chat=Anthropic, Task=Anthropic, CLI=Z.ai
+```
+
+## Command Options
+
+```bash
+# Standard mode (recommended)
+/cfn-loop-cli "Implement JWT authentication"
+
+# MVP mode (fast, lower quality gates)
+/cfn-loop-cli "Build prototype feature" --mode=mvp
+
+# Enterprise mode (high quality, more validators)
+/cfn-loop-cli "Production security feature" --mode=enterprise --max-iterations=15
+```
+
+**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.75 | ≥0.90 | 10 | 3-4 | Production features |
+| Enterprise | ≥0.85 | ≥0.95 | 15 | 5 | Security, compliance, critical systems |
+
+## 🚨 CRITICAL EXECUTION INSTRUCTIONS
+
+**YOU ARE MAIN CHAT. YOU SPAWN ONLY ONE AGENT: cfn-v3-coordinator**
+
+**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.
+
+---
+
+### 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)"
+     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")
+```
+
+## Autonomous Execution Rules
+
+**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)
+
+**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
+
+## CLI Mode Benefits
+
+**Cost Savings:**
+- 64% savings with Z.ai routing vs all-Anthropic
+- 95-98% savings vs Task tool spawning
+- Scales linearly with iterations (Task mode scales exponentially)
+
+**Production Features:**
+- Background execution (no timeout issues)
+- Redis state persistence (crash recovery)
+- Zero-token waiting (BLPOP blocks without API calls)
+- Web portal visibility (http://localhost:3000)
+
+**Performance:**
+- Parallel agent spawning (no sequential bottleneck)
+- Instant wake-up (<100ms latency)
+- Scalable (10+ agents, indefinite cycles)
+
+## When to Use CLI Mode
+
+**Use CLI Mode for:**
+- ✅ Production features
+- ✅ Long-running tasks (>10 min)
+- ✅ Multi-iteration workflows
+- ✅ Cost-sensitive projects
+- ✅ Background execution
+
+**Use Task Mode for:**
+- Debugging (full visibility needed)
+- Learning CFN Loop workflow
+- Short prototypes (<5 min)
+- Single-iteration tasks
+
+## 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
+
+## 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`
+
+---
+
+**Version:** 1.0.0 (2025-10-31) - CLI mode: production execution, cost-optimized, background processing

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

@@ -398,13 +398,32 @@ Validating documentation...
 Documentation update complete.
 ```
 
+## CFN Loop Command Structure (v3.0)
+
+**Current Commands (as of 2025-10-31):**
+1. `/cfn-loop-task` - Task mode (debugging, full visibility)
+2. `/cfn-loop-cli` - CLI mode (production, cost-optimized)
+3. `/cfn-loop-frontend` - Visual iteration (screenshot + video validation)
+4. `/cfn-loop-document` - Documentation generation (this command)
+
+**Removed Commands (deprecated 2025-10-31):**
+- ❌ `/cfn-loop` (replaced by `/cfn-loop-cli` or `/cfn-loop-task`)
+- ❌ `/cfn-loop-single` (replaced by `/cfn-loop-cli`)
+- ❌ `/cfn-loop-epic` (use multiple `/cfn-loop-cli` executions)
+- ❌ `/cfn-loop-sprints` (use `/cfn-loop-cli` per sprint)
+
+**When documenting CFN Loop features:**
+- Reference correct command names (task/cli/frontend/document)
+- Update examples to use new commands
+- Mark deprecated commands clearly in changelog
+- Maintain backward compatibility notes
+
 ## Integration with CFN Loop
 
 ### Auto-Trigger Conditions
 ```javascript
 // Automatically trigger documentation after:
 if (
-  epicComplete ||                    // Epic completion
   sprintComplete ||                  // Sprint completion
   majorPhaseComplete ||              // Major phase completion
   newSlashCommandAdded ||            // New slash command

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

@@ -94,7 +94,7 @@ npm install -D @playwright/test
 
 ## Execution Pattern
 
-### Step 1: Parse Command Arguments
+### Step 1: Parse Command Arguments & Determine Mode
 
 ```javascript
 const params = {
@@ -107,9 +107,24 @@ const params = {
 };
 
 console.log(`Frontend CFN Loop: ${params.mode} mode, ${params.spawnMode} spawning`);
+
+// MODE DETECTION: Inject mode-specific instructions
+if (params.spawnMode === 'cli') {
+  console.log('━━━ CLI MODE INSTRUCTIONS ━━━');
+  console.log('Main Chat spawns ONLY cfn-frontend-coordinator');
+  console.log('Coordinator handles all visual iteration internally');
+  console.log('CLI agents use Z.ai routing (when enabled)');
+  console.log('Background execution with Redis monitoring');
+} else {
+  console.log('━━━ TASK MODE INSTRUCTIONS ━━━');
+  console.log('Main Chat coordinates entire visual iteration workflow');
+  console.log('NO coordinator agent spawned');
+  console.log('Main Chat spawns all agents via Task()');
+  console.log('Full visibility in Main Chat');
+}
 ```
 
-### Step 2: Mode Selection
+### Step 2: Execute Based on Mode
 
 #### CLI Mode (Default) - Spawn Frontend Coordinator