claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/CLAUDE.md

@@ -5,23 +5,32 @@
 
 ## 1) Critical Rules (Single Source of Truth)
 
-* **Use agents for all non-trivial work** (≥4 steps or any multi-file / research / testing / architecture / security / integration / refactor / feature).
-* **Initialize swarm before any multi-agent work.**
-* **Batch operations**: one message per related batch (spawn, file edits, bash, todos, memory ops).
-* **Run post-edit hook after every file edit.**
-* **Never work solo** on multi-step tasks. Spawn parallel specialists.
-* **Never mix implementers and validators in the same message.**
-* **Never run tests inside agents.** Execute once; agents read results.
-* **Never save to project root.** Use proper subdirs.
-* **No guides/summaries/reports** unless explicitly asked.
-* **Use spartan language.**
-* **Redis persistence enables swarm recovery** - swarm state survives interruptions.
-* **ALL agent communication MUST use Redis pub/sub** - no direct file coordination.
-
-**Consensus thresholds**
-
-* Gate (agent self-confidence): **≥0.75 each**
-* Validators consensus: **≥0.90**
+**Core Principles:**
+* Use agents for all non-trivial work (≥4 steps or multi-file/research/testing/architecture/security)
+* Initialize swarm before multi-agent work
+* Batch operations: one message per related batch (spawn, file edits, bash, todos, memory ops)
+* Run post-edit hook after every file edit
+
+**Prohibited Patterns:**
+* Working solo on multi-step tasks — spawn parallel specialists
+* Mixing implementers + validators in same message
+* Running tests inside agents — execute once; agents read results
+* Concurrent test runs — terminate previous runs first
+* Saving to project root — use proper subdirs
+* Creating guides/summaries/reports unless explicitly asked
+* Agent coordination without Redis pub/sub messaging
+* Asking permission to retry/advance when criteria/iterations allow. Instead relaunch agents
+
+**Communication:**
+* Use spartan language
+* Redis persistence enables swarm recovery — state survives interruptions
+* ALL agent communication MUST use Redis pub/sub — no direct file coordination
+
+**Consensus thresholds** (mode-dependent)
+
+* Standard mode: Gate ≥0.75 • Consensus ≥0.90 • 4 validators • single PO
+* MVP mode: Gate ≥0.70 • Consensus ≥0.80 • 2 validators • single PO
+* Enterprise mode: Gate ≥0.75 • Consensus ≥0.95 • 4 validators • 4-person board • Loop 0.5 planning
 
 ---
 
@@ -51,7 +60,7 @@ executeSwarm({
 
 **Redis-backed Swarm Execution**:
 ```bash
-node test-swarm-direct.js "Create REST API with authentication" --executor --max-agents 3
+node tests/manual/test-swarm-direct.js "Create REST API with authentication" --executor --max-agents 3
 # Or: executeSwarm(objective, { strategy: 'development', mode: 'mesh' })
 ```
 
@@ -71,7 +80,14 @@ node test-swarm-direct.js "Create REST API with authentication" --executor --max
 node config/hooks/post-edit-pipeline.js "[FILE]" --memory-key "swarm/[agent]/[step]"
 ```
 
-**Useful flags (optional)**: `--tdd-mode` • `--minimum-coverage 80..90` • `--rust-strict`
+**Useful flags (optional)**: `--tdd-mode` • `--minimum-coverage 80..90` • `--rust-strict` • `--no-wasm` (disable 52x acceleration)
+
+**Markdown validation** (opt-in, better for CI): `--validate-markdown`
+
+**WASM 52x acceleration** enabled by default for:
+- JavaScript/TypeScript: AST parsing, linting, type checking
+- Rust files: Pattern matching (unwrap, panic, expect detection)
+- Markdown (opt-in): Link checking, structure analysis
 
 ### 3.3 Safe Test Execution
 
@@ -94,230 +110,169 @@ pkill -f vitest; pkill -f "npm test"
 ---
 
 ## 4) CFN Loop (Single Section)
+
+### 4.1 Loop Structure
+
 Loop 0: Epic/Sprint orchestration (multi-phase) → no iteration limit
+Loop 0.5: Planning consensus (Enterprise only) → architects vote on design; ≥0.85 consensus
 Loop 1: Phase execution (sequential phases) → no limit
-Loop 2: Consensus validation (team of 2-4 validators) → max 10/phase; exit at ≥0.90
-Loop 3: Primary swarm implementation → max 10/subtask; exit when all ≥0.75
-Loop 4: Product Owner decision gate (GOAP) → PROCEED / DEFER / ESCALATE
-
-Flow
+Loop 2: Consensus validation (2-4 validators) → max 5-15/phase; exit at ≥0.80-0.95
+Loop 3: Primary swarm implementation → max 5-15/subtask; exit when all ≥0.70-0.75
+Loop 4: Product Owner decision gate (GOAP) → PROCEED / DEFER / ESCALATE -> Re-inject detailed mode instructions
 
-Loop 3 implementers produce output + self-confidence scores.
-Can use up to 7 agents in mesh, if > 7 agents needed, use coordinators in mesh with teams under them in hierarchical. Can use up to 50 agents under a coordinator
+**Detailed Mode Instructions**:
+See instruction files for complete spawn patterns, Redis pub/sub coordination, SQLite memory patterns, git commit templates, and retry strategies.
+- MVP: `config/cfn-loop/instructions/mvp-instructions.md`
+- Standard: `config/cfn-loop/instructions/standard-instructions.md`
+- Enterprise: `config/cfn-loop/instructions/enterprise-instructions.md`
 
-Gate: if all ≥0.75, go to Loop 2; else retry Loop 3 with targeted/different agents.
+### 4.2 CFN Loop Modes
 
-Loop 2 validator team of 2-4 agents run; refer recommendations to product owner for decisions
+**Mode Selection**: Adapt quality gates to project needs
 
-**🎯 CRITICAL:** Loop 4 Product Owner runs autonomous GOAP decision:
+```bash
+/cfn-loop "Task" --mode=mvp          # Fast iteration
+/cfn-loop "Task" --mode=standard     # Balanced (default)
+/cfn-loop "Task" --mode=enterprise   # Full quality gates
+```
 
-After consensus validation, Product Owner agent makes autonomous PROCEED/DEFER/ESCALATE decision:
+**Mode Comparison**:
 
-PROCEED: Relaunch Loop 3 with targeted fixes or move to next sprint
+| Mode | Best For | Gate | Consensus | Iterations | Validators | Product Owner | Loop 0.5 |
+|------|----------|------|-----------|------------|------------|---------------|----------|
+| **MVP** | Prototypes, MVPs | ≥0.70 | ≥0.80 | 5 | 2 | Single | No |
+| **Standard** | General features | ≥0.75 | ≥0.90 | 10 | 4 | Single | No |
+| **Enterprise** | Production systems | ≥0.75 | ≥0.95 | 15 | 4 | 4-person board | Yes (≥0.85) |
 
-DEFER: Approve work, backlog out-of-scope issues. launch swarms for next steps
+**Auto-Detection**: Epic parser infers mode from filename patterns (`-mvp`, `-enterprise`)
 
-ESCALATE: Critical ambiguity → human review.
+```bash
+/parse-epic ./auth-mvp.json --cfn-mode=auto  # Detects MVP mode
+/parse-epic ./platform.json --cfn-mode=enterprise
+```
 
-Auto-transition phases when complete by rereading the root claude.md file and launching a swarm for next steps. No permission prompts.
+**Mode Storage**: Redis key `cfn:mode:{phaseId}` stores mode for swarm coordination
 
-### CFN Loop Coordination Example
 
-**Event Bus Coordination (Critical Rule #19 - Mandatory Redis pub/sub):**
-```bash
-# Loop 3 Start: Publish phase transition event
-/eventbus publish --type cfn.loop.phase.start --data '{"loop":3,"phase":"auth","swarmId":"cfn-phase-auth"}' --priority 9
+### CFN Loop Coordination Framework
 
-# Agent spawned: Publish lifecycle event
-/eventbus publish --type agent.lifecycle --data '{"agent":"coder-1","status":"spawned","loop":3}' --priority 8
+**Agent Coordination (Critical Rule #19 - Mandatory Redis pub/sub):**
 
-# Agent completion: Publish confidence score
-/eventbus publish --type agent.complete --data '{"agent":"coder-1","confidence":0.85,"loop":3}' --priority 8
+Choose coordination method based on scale and requirements:
 
-# Loop 2 Start: Publish validation event
-/eventbus publish --type cfn.loop.validation.start --data '{"loop":2,"validators":["reviewer-1","security-1"]}' --priority 9
+| Method | Use When | Example |
+|--------|----------|---------|
+| **Event Bus** | Enterprise scale (1000+ agents, 10K+ events/sec) | `/eventbus publish --type cfn.loop.phase.start` |
+| **Redis Pub/Sub** | Standard coordination (10-100 agents) | `redis-cli publish "swarm:coord" '{"agent":"id"}'` |
+| **SQLite Memory** | Persistent state with ACL (cross-loop data) | `/sqlite-memory store --key "cfn/phase/loop3" --level project` |
+| **Redis State** | Active coordination (ephemeral, TTL-based) | `redis-cli setex "cfn:phase:state" 3600 '{"loop":3}'` |
 
-# Subscribe to all CFN Loop events for coordination
-/eventbus subscribe --pattern "cfn.loop.*" --handler cfn-coordinator --batch-size 50
-```
+**Coordination Examples:**
 
-**Memory Persistence Across Loops:**
 ```bash
-# Loop 3: Store implementation results in SQLite with ACL
-/sqlite-memory store --key "cfn/phase-auth/loop3/results" --level project --data '{"confidence":0.85,"files":["auth.js"]}'
+# Event Bus (Enterprise) - High-throughput coordination
+/eventbus publish --type cfn.loop.phase.start --data '{"loop":3,"phase":"auth"}' --priority 9
+/eventbus subscribe --pattern "cfn.loop.*" --handler cfn-coordinator --batch-size 50
 
-# Loop 2: Validators read Loop 3 results
-/sqlite-memory retrieve --key "cfn/phase-auth/loop3/results" --level project
+# Redis Pub/Sub (Standard) - Direct agent coordination
+redis-cli publish "swarm:coordination" '{"agent":"coder-1","status":"ready","loop":3}'
+redis-cli subscribe "swarm:coordination"
 
-# Loop 4: Product Owner reads all loop data for decision
+# SQLite Memory (Persistent) - Cross-loop data with ACL
+/sqlite-memory store --key "cfn/phase-auth/loop3/results" --level project --data '{"confidence":0.85}'
 /sqlite-memory retrieve --key "cfn/phase-auth/*" --level project
 
-# Redis state for active coordination
+# Redis State (Ephemeral) - Active coordination state
 redis-cli setex "cfn:phase-auth:state" 3600 '{"loop":3,"agents":5,"confidence":0.85}'
+redis-cli get "cfn:phase-auth:state"
 ```
 
-**Git Commit After Each Completion:**
-```bash
-# After Loop 3 completes (all agents ≥0.75)
-git add .
-git commit -m "$(cat <<'EOF'
-feat(cfn-loop): Complete Loop 3 - Authentication Phase
-
-Loop 3 Implementation Results:
-- Confidence: 0.85 (target: ≥0.75) ✅
-- Agents: coder-1, coder-2, security-1
-- Files: auth.js, auth.test.js, auth-middleware.js
-
-Ready for Loop 2 validation
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-EOF
-)"
-
-# After Loop 2 validation completes (consensus ≥0.90)
-git add .
-git commit -m "$(cat <<'EOF'
-feat(cfn-loop): Complete Loop 2 - Validation Phase
-
-Loop 2 Validation Results:
-- Consensus: 0.92 (target: ≥0.90) ✅
-- Validators: reviewer-1, security-1
-- Issues: None
-- Recommendations: Add rate limiting (deferred to backlog)
-
-Ready for Loop 4 Product Owner decision
+**Git Commit After Loop Completion:**
 
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
+Use `/github-commit --chat` after each loop completes. Example:
 
-Co-Authored-By: Claude <noreply@anthropic.com>
-EOF
-)"
-
-# After Loop 4 Product Owner decision (PROCEED/DEFER)
-git add .
-git commit -m "$(cat <<'EOF'
-feat(cfn-loop): Complete Phase - Authentication System
-
-Loop 4 Product Owner Decision: DEFER ✅
-- Phase: Authentication System COMPLETE
-- Overall Confidence: 0.92
-- Status: Production ready, backlog created for enhancements
-
-Next: Auto-transition to next phase
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-EOF
-)"
-
-# After Sprint completes (multiple phases done)
-git add .
-git commit -m "$(cat <<'EOF'
-feat(cfn-loop): Complete Sprint 1 - User Management
-
-Sprint Summary:
-- Phases Completed: Auth (0.92), Profile (0.88), Permissions (0.91)
-- Total Agents: 15
-- Sprint Confidence: 0.90
-- Status: All phases validated and production ready
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-EOF
-)"
+```bash
+# After Loop 3 completes (all agents ≥0.75)
+/github-commit --chat
+# Generates: feat(cfn-loop): Complete Loop 3 - [Phase Name]
+# Includes: Confidence scores, agent list, files modified, next step
+```
 
-# After Epic completes (all sprints done)
-git add .
-git commit -m "$(cat <<'EOF'
-feat(cfn-loop): Complete Epic - E-commerce Platform v1.0
+**When to Commit:**
+- **Loop 3 complete**: All agents meet gate threshold (≥0.70-0.75)
+- **Loop 2 complete**: Validation consensus achieved (≥0.80-0.95)
+- **Loop 4 complete**: Product Owner decision made (PROCEED/DEFER/ESCALATE)
+- **Phase complete**: All loops done, ready for next phase
+- **Sprint complete**: Use `/github-commit --full` (auto-triggers `/cfn-loop-document --sprint=name`)
+- **Epic complete**: Use `/github-commit --full` + `/cfn-loop-document --epic=name`
 
-Epic Summary:
-- Sprints: User Management (0.90), Product Catalog (0.89), Checkout (0.92)
-- Total Phases: 12
-- Epic Confidence: 0.90
-- Status: Platform launch ready
+**Loop Telemetry (Print to Main Chat)**
 
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
+ALWAYS print telemetry between loops to keep user informed:
 
-Co-Authored-By: Claude <noreply@anthropic.com>
-EOF
-)"
+**After Loop 3 (Gate Check):**
 ```
+## Loop 3 Complete - [Phase Name] ([Mode])
 
-**Complete CFN Loop Flow with Coordination:**
-1. **Loop 3**: Agents coordinate via event bus, store results in SQLite → Commit on completion (≥0.75)
-2. **Loop 2**: Validators read Loop 3 memory, validate, publish consensus → Commit on validation (≥0.90)
-3. **Loop 4**: Product Owner reads all memory, makes GOAP decision → Commit on decision
-4. **Phase Complete**: Commit phase summary with all metrics
-5. **Sprint Complete**: Commit sprint summary with all phase results
-6. **Epic Complete**: Commit epic summary with all sprint results
-
-### CFN Loop Enterprise Commands
+**Confidence Scores:**
+- agent-1: 0.85 ✅ (description, key files)
+- agent-2: 0.82 ✅ (description, key files)
+- agent-3: 0.78 ✅ (description, key files)
 
-**Enterprise Fleet Management in CFN Loop:**
-```bash
-# Initialize fleet for CFN Loop phase (1000+ agents)
-/fleet init --max-agents 1500 --efficiency-target 0.40 --regions us-east-1,eu-west-1
+**Gate Result:** PASS (avg 0.82, target ≥[threshold])
+**Files Changed:** N files
+**Coverage:** X% (target ≥Y%)
+**Security:** Clean / Issues found
+**Blockers:** None / List issues
 
-# Scale fleet during complex CFN phases
-/fleet scale --fleet-id cfn-fleet-phase3 --target-size 2000 --strategy predictive
+→ Proceeding to Loop 2 ([N] validators)
+```
 
-# Optimize resources for CFN Loop efficiency
-/fleet optimize --fleet-id cfn-fleet-phase3 --efficiency-target 0.45
+**After Loop 2 (Consensus):**
 ```
+## Loop 2 Complete - Validation ([Mode])
 
-**Event Bus Coordination for CFN Loop:**
-```bash
-# Initialize event bus for CFN Loop messaging (10,000+ events/sec)
-/eventbus init --throughput-target 10000 --worker-threads 4
+**Validator Scores:**
+- validator-1: 0.92 ✅ (key findings)
+- validator-2: 0.85 ✅ (key findings)
 
-# CFN Loop event publishing
-/eventbus publish --type cfn.loop.phase --data '{"phase":3,"status":"in-progress"}' --priority 8
+**Consensus:** 0.88 (target ≥[threshold]) [✅ or ⚠️]
+**Recommendations:**
+- [SEVERITY] Description (action: defer/backlog/fix)
 
-# CFN Loop event subscriptions
-/eventbus subscribe --pattern "cfn.loop.*" --handler cfn-loop-coordinator
+→ Proceeding to Loop 4 (Product Owner can override)
 ```
 
-**Compliance Validation in CFN Loop:**
-```bash
-# Validate compliance for CFN Loop deliverables
-/compliance validate --standard GDPR --scope data-privacy,audit-trail --detailed
-
-# Generate compliance reports for CFN Loop phases
-/compliance audit --period phase --format pdf --include-recommendations
+**After Loop 4 (PO Decision):**
 ```
+## Loop 4 Complete - Product Owner Decision ([Mode])
 
-**Performance Monitoring in CFN Loop:**
-```bash
-# Monitor CFN Loop performance metrics
-/performance analyze --component cfn-loop --timeframe phase
+**PO Review:**
+- Loop 3 avg: 0.82 ✅
+- Loop 2 consensus: 0.88 ([met/below] threshold)
+- Validator recommendations: [list]
 
-# WASM optimization for CFN Loop tasks
-/wasm optimize --code "./cfn-loop-implementation.js" --target 40x
+**Decision: [DEFER/PROCEED/ESCALATE]** [✅/⚠️]
+**Reasoning:** "[PO reasoning, including override justification if applicable]"
+**Override:** [Yes/No] (if consensus below threshold)
 
-# Error recovery for CFN Loop failures
-claude-flow-novice recovery:status --effectiveness-target 0.90
-```
-
-**Dashboard Visualization for CFN Loop:**
-```bash
-# CFN Loop progress dashboard
-/dashboard insights --fleet-id cfn-fleet-phase3 --timeframe phase
+**Backlog Items:** [list]
+**Required Fixes:** [list if PROCEED]
 
-# Real-time CFN Loop monitoring
-/dashboard monitor --fleet-id cfn-fleet-phase3 --alerts cfn-loop
+→ [Launching agents for next phase / Relaunching Loop 3 with fixes / Escalating to human]
 ```
 
-Retry Templates
+**Retry Templates**
 
-Loop 3 retry (low confidence): replace failing agents with specialists; add missing roles (security/perf).
-Loop 2 retry (consensus <0.90): target validator issues (e.g., fix SQLi, raise coverage) and refer recommendations to product owner for improvements
+Loop 3 retry (low confidence): replace failing agents with specialists; add missing roles (security/perf); relaunch agents
+Loop 2 retry (consensus <threshold): ALWAYS proceed to Loop 4; PO decides PROCEED (relaunch Loop 3) or DEFER (override validators)
 
-Stop only if: dual iteration limits reached, critical security/compilation error, or explicit STOP/PAUSE.
+**Mode-Specific Iteration Limits**:
+- MVP: Loop 3 max 5 iterations • Loop 2 max 5 iterations
+- Standard: Loop 3 max 10 iterations • Loop 2 max 10 iterations
+- Enterprise: Loop 3 max 15 iterations • Loop 2 max 15 iterations
+
+Stop only if: mode-specific iteration limits reached, critical security/compilation error, or explicit STOP/PAUSE.
 
 ---
 
@@ -327,64 +282,27 @@ Stop only if: dual iteration limits reached, critical security/compilation error
 
 **During**: coordinate via SwarmMemory → post-edit hook after every edit → self-validate and report confidence.
 
-**After**: achieve ≥0.90 validator consensus → store results → auto next steps.
-
----
-
-## 6) Prohibited Patterns
-
-* Implementers + validators in same message.
-* Tests inside agents; multiple concurrent test runs.
-* Solo work on multi-step tasks.
-* Asking permission to retry/advance when criteria/iterations allow.
-* Saving to root.
-* Creating guides/summaries/reports unless asked.
-* Agent coordination without Redis pub/sub messaging.
+**After**: achieve ≥0.80-0.95 validator consensus → store results → auto next steps.
 
 ---
 
-## 7) Agent Selection Cheatsheet
-
-* **Core**: coder • tester • reviewer
-* **Backend**: backend-dev • api-docs • system-architect
-* **Frontend/Mobile**: coder (specialized) • mobile-dev
-* **Quality**: tester • reviewer • security-specialist • perf-analyzer
-* **Planning/Ops**: researcher • planner • architect • devops-engineer • cicd-engineer
-* **Docs**: api-docs • researcher
-
-Pick roles for actual needs (no generic redundancy).
-
----
-
-## 8) Commands & Setup
+## 6) Commands & Setup
 
 **Swarm Execution**
 
 ```bash
 # Direct swarm execution (Redis-backed)
-node test-swarm-direct.js "Create REST API" --executor --max-agents 3
+node tests/manual/test-swarm-direct.js "Create REST API" --executor --max-agents 3
 
 # Swarm recovery after interruption
 redis-cli keys "swarm:*"  # Find interrupted swarms
-node test-swarm-recovery.js  # Execute recovery
+node tests/manual/test-swarm-recovery.js  # Execute recovery
 
 # CRITICAL: All agents MUST use Redis pub/sub for coordination
 redis-cli publish "swarm:coordination" '{"agent":"id","status":"message"}'
 ```
 
-**Essentials**
-
-* `npx claude-flow-novice status` — health
-* `npx claude-flow-novice --help` — commands
-* `/fullstack "goal"` — full-stack team + consensus
-* `/swarm`, `/sparc`, `/hooks` — autodiscovered
-* Redis persistence provides automatic recovery
-
-**File organization**: never save working files to root.
-
----
-
-## 9) Output & Telemetry (Concise)
+## 7) Output & Telemetry (Concise)
 
 **Agent confidence JSON (per agent)**
 
@@ -408,13 +326,13 @@ Loop 2: 0.87 (target 0.90) ❌ → Relaunch Loop 3 (security + coverage)
 
 ---
 
-## 10) CLI Command Reference (Agent Commands)
+## 8) CLI Command Reference
 
 ### Swarm Management
 
 ```bash
 # Initialize and execute swarms with Redis-backed coordination for persistent state across interruptions
-node test-swarm-direct.js "Objective description" --executor --max-agents 5
+node tests/manual/test-swarm-direct.js "Objective description" --executor --max-agents 5
 node src/cli/simple-commands/swarm.js "Build REST API" --strategy development --mode mesh
 claude-flow-novice swarm "Research cloud patterns" --strategy research --output-format json
 
@@ -431,111 +349,43 @@ redis-cli get "swarm:swarm_id"  # Retrieve complete state for specific swarm ins
 
 ```bash
 # Execute CFN Loop autonomous workflow with self-correcting consensus validation and retry mechanisms
-/cfn-loop "Implement authentication system" --phase=auth --max-loop2=10
-/cfn-loop-sprints "E-commerce platform" --sprints=3 --max-loop2=5
-/cfn-loop-epic "User management system" --phases=4
-
-# SPARC methodology phases for systematic specification, architecture, refinement, and completion workflows
-/sparc analysis "Database performance issues"
-/sparc design "Microservices architecture"
-/sparc refine "API optimization"
-```
-
-### Fleet Management (Enterprise Scale)
-
-```bash
-# Initialize enterprise fleet manager for coordinating 1000+ agents with predictive scaling algorithms
-/fleet init --max-agents 1500 --regions us-east-1,eu-west-1 --efficiency-target 0.40
-
-# Auto-scale fleet size dynamically based on workload patterns and efficiency targets
-/fleet scale --fleet-id fleet-123 --target-size 2000 --strategy predictive
-
-# Optimize resource allocation across fleet with cost reduction and performance balancing algorithms
-/fleet optimize --fleet-id fleet-123 --efficiency-target 0.45 --cost-optimization
-
-# Deploy fleet across multiple regions with automatic failover and geographic load balancing
-/fleet regions --fleet-id fleet-123 --regions us-east-1,eu-west-1,ap-southeast-1 --failover
+/cfn-loop "Implement authentication system" --phase=auth --mode=standard
+/cfn-loop "Build MVP prototype" --mode=mvp  # Fast iteration (Gate: 0.70, Consensus: 0.80)
+/cfn-loop "Production API" --mode=enterprise  # Full quality gates with Loop 0.5 planning
 
-# Monitor fleet health with deep inspection of agent states and coordination metrics
-/fleet health --fleet-id fleet-123 --deep-check
+# Epic-level mode selection with auto-detection
+/parse-epic ./auth-mvp.json --cfn-mode=auto  # Detects MVP mode from filename
+/parse-epic ./platform-enterprise.json --cfn-mode=auto  # Detects Enterprise mode
 
-# Retrieve detailed performance metrics for fleet analysis and optimization decision making
-/fleet metrics --fleet-id fleet-123 --timeframe 24h --detailed
+# Sprint and epic orchestration
+/cfn-loop-sprints "E-commerce platform" --sprints=3 --mode=enterprise
+/cfn-loop-epic "User management system" --phases=4 --mode=standard
 ```
 
-### Event Bus Management (10,000+ events/sec)
+### Coordination and State Management
 
+**Redis Pub/Sub (Standard coordination):**
 ```bash
-# Initialize high-throughput event bus implementing mandatory Redis pub/sub coordination (Critical Rule #19)
-/eventbus init --throughput-target 10000 --latency-target 50 --worker-threads 4
-
-# Publish agent lifecycle and coordination events with weighted routing for priority handling
-/eventbus publish --type agent.lifecycle --data '{"agent": "coder-1", "status": "spawned"}' --strategy weighted
-
-# Subscribe to event patterns with batch processing for efficient coordination message handling
-/eventbus subscribe --pattern "agent.*" --handler process-agent-events --batch-size 100
-
-# Retrieve event bus throughput and latency metrics for performance monitoring and tuning
-/eventbus metrics --timeframe 1h --detailed
-
-# Monitor real-time event flow with filtering for debugging coordination issues and bottlenecks
-/eventbus monitor --filter "agent.*" --format table
+redis-cli publish "swarm:coordination" '{"agent":"coder-1","status":"ready"}'
+redis-cli subscribe "swarm:coordination"
+redis-cli setex "swarm:state" 3600 "$(cat swarm-state.json)"
+redis-cli get "swarm:state" | jq .
 ```
 
-### Fullstack Development
-
+**SQLite Memory (Persistent state with ACL):**
 ```bash
-# Launch coordinated fullstack team with frontend, backend, and database specialists working in parallel
-/fullstack "Build e-commerce platform"
-/fullstack:develop "Add user authentication"
-/fullstack:status  # Check fullstack swarm coordination status and agent health
-/fullstack:terminate  # Clean shutdown of all fullstack agents with state preservation
-/fullstack:spawn "backend developer"  # Dynamically add specific agent role to active fullstack swarm
+/sqlite-memory init --database-path ./memory.db --acl-enabled
+/sqlite-memory store --key "cfn/phase/loop3" --level project --data '{"confidence":0.85}'
+/sqlite-memory retrieve --key "cfn/phase/*" --level project
 ```
 
-
-### Memory and State Management
-
+**Memory Safety:**
 ```bash
-# Validate memory operations for safety and prevent leaks or corruption across agent coordination
-/check:memory  # Check memory safety across all active swarms and agent instances
-/memory-safety --validate  # Run comprehensive memory validation with leak detection
-claude-flow-novice memory list  # List all memory entries organized by namespace and agent
+/check:memory  # Check memory safety across swarms
+claude-flow-novice memory list
 claude-flow-novice memory clear --namespace=swarm
-
-# Persist swarm state to Redis with TTL for recovery and cross-session coordination
-redis-cli setex "swarm:state" 3600 "$(cat swarm-state.json)"
-redis-cli get "swarm:state" | jq .  # Retrieve and parse swarm state JSON with pretty formatting
-redis-cli --scan --pattern "memory:*"  # Scan all memory entries for debugging and cleanup
-```
-
-
-### Utilities and Maintenance
-
-```bash
-# Clean up build artifacts, test processes, and development data for fresh environment resets
-claude-flow-novice utils:cleanup  # Remove all build artifacts and temporary files
-claude-flow-novice clean:test  # Clean test artifacts and cached test results
-redis-cli flushall  # Clear all Redis data (development only - destroys all state)
-pkill -f vitest; pkill -f "npm test"  # Force terminate hanging test processes
-
-
-### SQLite Memory Management
-
-```bash
-# Initialize SQLite-backed memory with 6-level ACL security (private/agent/swarm/project/team/system)
-/sqlite-memory init --database-path ./memory.db --acl-enabled --data-residency eu-west-1
-
-# Configure access control permissions at different security levels for project isolation
-/sqlite-memory set-acl --key "project-data" --level project --permissions read,write
-
-# Store and retrieve memory with ACL enforcement providing security layer Redis doesn't offer
-/sqlite-memory store --key "sensitive-data" --level system --data '{"encrypted": true}'
-/sqlite-memory retrieve --key "project-data" --level project
 ```
 
 ---
 
-## Additional Commands
-
-For specialized commands (compliance, performance optimization, WASM, build/deployment, neural operations, GitHub integration, workflow automation, security/monitoring, debugging, and SDK integration), see `readme/additional-commands.md`.
+For specialized commands (fullstack development, SPARC methodology, fleet management, event bus, compliance, performance, markdown validation, utilities, metrics reporting, WASM optimization, build/deployment, neural operations, GitHub integration, workflow automation, security/monitoring, debugging, and SDK integration), see `readme/additional-commands.md`.

package/.claude-flow-novice/dist/src/coordination/shared/transparency/transparency-system.js

@@ -349,7 +349,7 @@ import { Logger } from "../../../core/logger.js";
             totalTokensSaved,
             averageExecutionTimeMs,
             failureRate,
-            averagePauseResumeLatencyMs: this.calculateAveragePauseResumeLatency(),
+            averagePauseResumeLatencyMs: this.calculateAveragePauseResumeLatencyMs(),
             hierarchyDepth,
             dependencyResolutionRate,
             eventStreamStats: {