claude-flow 3.0.0-alpha.7 → 3.0.0-alpha.71

package/v3/@claude-flow/cli/dist/src/init/claudemd-generator.js

@@ -9,77 +9,230 @@ export function generateClaudeMd(options) {
     const topology = options.runtime.topology;
     const maxAgents = options.runtime.maxAgents;
     const memoryBackend = options.runtime.memoryBackend;
-    return `# Claude Code Configuration - SPARC Development Environment
+    return `# Claude Code Configuration - Claude Flow V3
 
 ## 🚨 AUTOMATIC SWARM ORCHESTRATION
 
 **When starting work on complex tasks, Claude Code MUST automatically:**
 
-1. **Initialize the swarm** using MCP tools
+1. **Initialize the swarm** using CLI tools via Bash
 2. **Spawn concurrent agents** using Claude Code's Task tool
 3. **Coordinate via hooks** and memory
 
-### 🚨 CRITICAL: MCP + Task Tool in SAME Message
+### 🚨 CRITICAL: CLI + Task Tool in SAME Message
 
 **When user says "spawn swarm" or requests complex work, Claude Code MUST in ONE message:**
-1. Call MCP tools to initialize coordination
+1. Call CLI tools via Bash to initialize coordination
 2. **IMMEDIATELY** call Task tool to spawn REAL working agents
-3. Both MCP and Task calls must be in the SAME response
+3. Both CLI and Task calls must be in the SAME response
 
-**MCP alone does NOT execute work - Task tool agents do the actual work!**
+**CLI coordinates, Task tool agents do the actual work!**
 
-### 🔄 Auto-Start Swarm Protocol
+### 🤖 INTELLIGENT 3-TIER MODEL ROUTING (ADR-026)
 
-When the user requests a complex task (multi-file changes, feature implementation, refactoring), **immediately execute this pattern in a SINGLE message:**
+**The routing system has 3 tiers for optimal cost/performance:**
 
+| Tier | Handler | Latency | Cost | Use Cases |
+|------|---------|---------|------|-----------|
+| **1** | Agent Booster | <1ms | $0 | Simple transforms (var→const, add-types, remove-console) |
+| **2** | Haiku | ~500ms | $0.0002 | Simple tasks, bug fixes, low complexity |
+| **3** | Sonnet/Opus | 2-5s | $0.003-$0.015 | Architecture, security, complex reasoning |
+
+**Before spawning agents, get routing recommendation:**
+\`\`\`bash
+npx @claude-flow/cli@latest hooks pre-task --description "[task description]"
+\`\`\`
+
+**When you see these recommendations:**
+
+1. \`[AGENT_BOOSTER_AVAILABLE]\` → Skip LLM entirely, use Edit tool directly
+   - Intent types: \`var-to-const\`, \`add-types\`, \`add-error-handling\`, \`async-await\`, \`add-logging\`, \`remove-console\`
+
+2. \`[TASK_MODEL_RECOMMENDATION] Use model="X"\` → Use that model in Task tool:
 \`\`\`javascript
-// STEP 1: Initialize swarm coordination via MCP (in parallel with agent spawning)
-mcp__claude-flow__swarm_init({
-  topology: "${topology}",
-  maxAgents: ${maxAgents},
-  strategy: "adaptive"
+Task({
+  prompt: "...",
+  subagent_type: "coder",
+  model: "haiku"  // ← USE THE RECOMMENDED MODEL (haiku/sonnet/opus)
 })
+\`\`\`
+
+**Benefits:** 75% cost reduction, 352x faster for Tier 1 tasks
+
+---
+
+### 🛡️ Anti-Drift Config (PREFERRED)
 
-// STEP 2: Spawn agents concurrently using Claude Code's Task tool
-// ALL Task calls MUST be in the SAME message for parallel execution
-Task("Coordinator", "You are the swarm coordinator. Initialize session, coordinate other agents via memory. Run: npx claude-flow@v3alpha hooks session-start", "hierarchical-coordinator")
-Task("Researcher", "Analyze requirements and existing code patterns. Store findings in memory via hooks.", "researcher")
-Task("Architect", "Design implementation approach based on research. Document decisions in memory.", "system-architect")
-Task("Coder", "Implement the solution following architect's design. Coordinate via hooks.", "coder")
-Task("Tester", "Write tests for the implementation. Report coverage via hooks.", "tester")
-Task("Reviewer", "Review code quality and security. Document findings.", "reviewer")
-
-// STEP 3: Batch all todos
-TodoWrite({ todos: [
-  {content: "Initialize swarm coordination", status: "in_progress", activeForm: "Initializing swarm"},
-  {content: "Research and analyze requirements", status: "in_progress", activeForm: "Researching requirements"},
-  {content: "Design architecture", status: "pending", activeForm: "Designing architecture"},
-  {content: "Implement solution", status: "pending", activeForm: "Implementing solution"},
-  {content: "Write tests", status: "pending", activeForm: "Writing tests"},
-  {content: "Review and finalize", status: "pending", activeForm: "Reviewing code"}
-]})
-
-// STEP 4: Store swarm state in memory
-mcp__claude-flow__memory_usage({
-  action: "store",
-  namespace: "swarm",
-  key: "current-session",
-  value: JSON.stringify({task: "[user's task]", agents: 6, startedAt: new Date().toISOString()})
+**Use this to prevent agent drift:**
+\`\`\`bash
+# Small teams (6-8 agents) - use hierarchical for tight control
+npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# Large teams (10-15 agents) - use hierarchical-mesh for V3 queen + peer communication
+npx @claude-flow/cli@latest swarm init --topology hierarchical-mesh --max-agents 15 --strategy specialized
+\`\`\`
+
+**Valid Topologies:**
+- \`hierarchical\` - Queen controls workers directly (anti-drift for small teams)
+- \`hierarchical-mesh\` - V3 queen + peer communication (recommended for 10+ agents)
+- \`mesh\` - Fully connected peer network
+- \`ring\` - Circular communication pattern
+- \`star\` - Central coordinator with spokes
+- \`hybrid\` - Dynamic topology switching
+
+**Anti-Drift Guidelines:**
+- **hierarchical**: Coordinator catches divergence
+- **max-agents 6-8**: Smaller team = less drift
+- **specialized**: Clear roles, no overlap
+- **consensus**: raft (leader maintains state)
+
+---
+
+### 🔄 Auto-Start Swarm Protocol (Background Execution)
+
+When the user requests a complex task, **spawn agents in background and WAIT for completion:**
+
+\`\`\`javascript
+// STEP 1: Initialize swarm coordination (anti-drift config)
+Bash("npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized")
+
+// STEP 2: Spawn ALL agents IN BACKGROUND in a SINGLE message
+// Use run_in_background: true so agents work concurrently
+Task({
+  prompt: "Research requirements, analyze codebase patterns, store findings in memory",
+  subagent_type: "researcher",
+  description: "Research phase",
+  run_in_background: true  // ← CRITICAL: Run in background
 })
+Task({
+  prompt: "Design architecture based on research. Document decisions.",
+  subagent_type: "system-architect",
+  description: "Architecture phase",
+  run_in_background: true
+})
+Task({
+  prompt: "Implement the solution following the design. Write clean code.",
+  subagent_type: "coder",
+  description: "Implementation phase",
+  run_in_background: true
+})
+Task({
+  prompt: "Write comprehensive tests for the implementation.",
+  subagent_type: "tester",
+  description: "Testing phase",
+  run_in_background: true
+})
+Task({
+  prompt: "Review code quality, security, and best practices.",
+  subagent_type: "reviewer",
+  description: "Review phase",
+  run_in_background: true
+})
+
+// STEP 3: WAIT - Tell user agents are working, then STOP
+// Say: "I've spawned 5 agents to work on this in parallel. They'll report back when done."
+// DO NOT check status repeatedly. Just wait for user or agent responses.
+\`\`\`
+
+### ⏸️ CRITICAL: Spawn and Wait Pattern
+
+**After spawning background agents:**
+
+1. **TELL USER** - "I've spawned X agents working in parallel on: [list tasks]"
+2. **STOP** - Do not continue with more tool calls
+3. **WAIT** - Let the background agents complete their work
+4. **RESPOND** - When agents return results, review and synthesize
+
+**Example response after spawning:**
+\`\`\`
+I've launched 5 concurrent agents to work on this:
+- 🔍 Researcher: Analyzing requirements and codebase
+- 🏗️ Architect: Designing the implementation approach
+- 💻 Coder: Implementing the solution
+- 🧪 Tester: Writing tests
+- 👀 Reviewer: Code review and security check
+
+They're working in parallel. I'll synthesize their results when they complete.
 \`\`\`
 
-### 📋 Agent Routing by Task Type
+### 🚫 DO NOT:
+- Continuously check swarm status
+- Poll TaskOutput repeatedly
+- Add more tool calls after spawning
+- Ask "should I check on the agents?"
 
-**Automatically select agents based on task:**
+### ✅ DO:
+- Spawn all agents in ONE message
+- Tell user what's happening
+- Wait for agent results to arrive
+- Synthesize results when they return
 
-| Task Type | Required Agents | Topology |
-|-----------|-----------------|----------|
-| Bug Fix | researcher, coder, tester | mesh |
-| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
-| Refactoring | architect, coder, reviewer | mesh |
-| Performance | researcher, coder, perf-analyzer | hierarchical |
-| Security Audit | security-manager, reviewer, tester | hierarchical |
-| Documentation | researcher, api-docs | mesh |
+## 🧠 AUTO-LEARNING PROTOCOL
+
+### Before Starting Any Task
+\`\`\`bash
+# 1. Search memory for relevant patterns from past successes
+Bash("npx @claude-flow/cli@latest memory search --query '[task keywords]' --namespace patterns")
+
+# 2. Check if similar task was done before
+Bash("npx @claude-flow/cli@latest memory search --query '[task type]' --namespace tasks")
+
+# 3. Load learned optimizations
+Bash("npx @claude-flow/cli@latest hooks route --task '[task description]'")
+\`\`\`
+
+### After Completing Any Task Successfully
+\`\`\`bash
+# 1. Store successful pattern for future reference
+Bash("npx @claude-flow/cli@latest memory store --namespace patterns --key '[pattern-name]' --value '[what worked]'")
+
+# 2. Train neural patterns on the successful approach
+Bash("npx @claude-flow/cli@latest hooks post-edit --file '[main-file]' --train-neural true")
+
+# 3. Record task completion with metrics
+Bash("npx @claude-flow/cli@latest hooks post-task --task-id '[id]' --success true --store-results true")
+
+# 4. Trigger optimization worker if performance-related
+Bash("npx @claude-flow/cli@latest hooks worker dispatch --trigger optimize")
+\`\`\`
+
+### Continuous Improvement Triggers
+
+| Trigger | Worker | When to Use |
+|---------|--------|-------------|
+| After major refactor | \`optimize\` | Performance optimization |
+| After adding features | \`testgaps\` | Find missing test coverage |
+| After security changes | \`audit\` | Security analysis |
+| After API changes | \`document\` | Update documentation |
+| Every 5+ file changes | \`map\` | Update codebase map |
+| Complex debugging | \`deepdive\` | Deep code analysis |
+
+### Memory-Enhanced Development
+
+**ALWAYS check memory before:**
+- Starting a new feature (search for similar implementations)
+- Debugging an issue (search for past solutions)
+- Refactoring code (search for learned patterns)
+- Performance work (search for optimization strategies)
+
+**ALWAYS store in memory after:**
+- Solving a tricky bug (store the solution pattern)
+- Completing a feature (store the approach)
+- Finding a performance fix (store the optimization)
+- Discovering a security issue (store the vulnerability pattern)
+
+### 📋 Agent Routing (Anti-Drift)
+
+| Code | Task | Agents |
+|------|------|--------|
+| 1 | Bug Fix | coordinator, researcher, coder, tester |
+| 3 | Feature | coordinator, architect, coder, tester, reviewer |
+| 5 | Refactor | coordinator, architect, coder, reviewer |
+| 7 | Performance | coordinator, perf-engineer, coder |
+| 9 | Security | coordinator, security-architect, auditor |
+| 11 | Docs | researcher, api-docs |
+
+**Codes 1-9: hierarchical/specialized (anti-drift). Code 11: mesh/balanced**
 
 ### 🎯 Task Complexity Detection
 
@@ -99,36 +252,6 @@ mcp__claude-flow__memory_usage({
 - Configuration changes
 - Quick questions/exploration
 
-### 🔧 Settings Configuration
-
-The following settings are auto-configured in \`.claude/settings.json\`:
-
-\`\`\`json
-{
-  "hooks": {
-    "PreToolUse": [{
-      "matcher": "Task",
-      "commands": ["npx claude-flow@v3alpha hooks pre-task --tool Task"]
-    }],
-    "PostToolUse": [{
-      "matcher": "Task",
-      "commands": ["npx claude-flow@v3alpha hooks post-task --tool Task"]
-    }],
-    "UserPromptSubmit": [{
-      "matcher": ".*",
-      "commands": ["npx claude-flow@v3alpha hooks route-task"]
-    }]
-  },
-  "permissions": {
-    "allow": [
-      "Bash(npx claude-flow:*)",
-      "mcp__claude-flow__*",
-      "mcp__ruv-swarm__*"
-    ]
-  }
-}
-\`\`\`
-
 ## 🚨 CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT
 
 **ABSOLUTE RULES**:
@@ -146,24 +269,6 @@ The following settings are auto-configured in \`.claude/settings.json\`:
 - **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
 - **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
 
-### 🎯 CRITICAL: Claude Code Task Tool for Agent Execution
-
-**Claude Code's Task tool is the PRIMARY way to spawn agents:**
-\`\`\`javascript
-// ✅ CORRECT: Use Claude Code's Task tool for parallel agent execution
-[Single Message]:
-  Task("Research agent", "Analyze requirements and patterns...", "researcher")
-  Task("Coder agent", "Implement core features...", "coder")
-  Task("Tester agent", "Create comprehensive tests...", "tester")
-  Task("Reviewer agent", "Review code quality...", "reviewer")
-  Task("Architect agent", "Design system architecture...", "system-architect")
-\`\`\`
-
-**MCP tools are ONLY for coordination setup:**
-- \`mcp__claude-flow__swarm_init\` - Initialize coordination topology
-- \`mcp__claude-flow__agent_spawn\` - Define agent types for coordination
-- \`mcp__claude-flow__task_orchestrate\` - Orchestrate high-level workflows
-
 ### 📁 File Organization Rules
 
 **NEVER save to root folder. Use these directories:**
@@ -174,36 +279,94 @@ The following settings are auto-configured in \`.claude/settings.json\`:
 - \`/scripts\` - Utility scripts
 - \`/examples\` - Example code
 
-## Project Configuration
+## Project Config (Anti-Drift Defaults)
+
+- **Topology**: hierarchical (prevents drift)
+- **Max Agents**: 8 (smaller = less drift)
+- **Strategy**: specialized (clear roles)
+- **Consensus**: raft
+- **Memory**: ${memoryBackend}
+- **HNSW**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
+- **Neural**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}
+
+## 🚀 V3 CLI Commands (26 Commands, 140+ Subcommands)
+
+### Core Commands
+
+| Command | Subcommands | Description |
+|---------|-------------|-------------|
+| \`init\` | 4 | Project initialization with wizard, presets, skills, hooks |
+| \`agent\` | 8 | Agent lifecycle (spawn, list, status, stop, metrics, pool, health, logs) |
+| \`swarm\` | 6 | Multi-agent swarm coordination and orchestration |
+| \`memory\` | 11 | AgentDB memory with vector search (150x-12,500x faster) |
+| \`mcp\` | 9 | MCP server management and tool execution |
+| \`task\` | 6 | Task creation, assignment, and lifecycle |
+| \`session\` | 7 | Session state management and persistence |
+| \`config\` | 7 | Configuration management and provider setup |
+| \`status\` | 3 | System status monitoring with watch mode |
+| \`workflow\` | 6 | Workflow execution and template management |
+| \`hooks\` | 17 | Self-learning hooks + 12 background workers |
+| \`hive-mind\` | 6 | Queen-led Byzantine fault-tolerant consensus |
+
+### Advanced Commands
+
+| Command | Subcommands | Description |
+|---------|-------------|-------------|
+| \`daemon\` | 5 | Background worker daemon (start, stop, status, trigger, enable) |
+| \`neural\` | 5 | Neural pattern training (train, status, patterns, predict, optimize) |
+| \`security\` | 6 | Security scanning (scan, audit, cve, threats, validate, report) |
+| \`performance\` | 5 | Performance profiling (benchmark, profile, metrics, optimize, report) |
+| \`providers\` | 5 | AI providers (list, add, remove, test, configure) |
+| \`plugins\` | 5 | Plugin management (list, install, uninstall, enable, disable) |
+| \`deployment\` | 5 | Deployment management (deploy, rollback, status, environments, release) |
+| \`embeddings\` | 4 | Vector embeddings (embed, batch, search, init) - 75x faster with agentic-flow |
+| \`claims\` | 4 | Claims-based authorization (check, grant, revoke, list) |
+| \`migrate\` | 5 | V2 to V3 migration with rollback support |
+| \`doctor\` | 1 | System diagnostics with health checks |
+| \`completions\` | 4 | Shell completions (bash, zsh, fish, powershell) |
+
+### Quick CLI Examples
+
+\`\`\`bash
+# Initialize project
+npx @claude-flow/cli@latest init --wizard
+
+# Start daemon with background workers
+npx @claude-flow/cli@latest daemon start
+
+# Spawn an agent
+npx @claude-flow/cli@latest agent spawn -t coder --name my-coder
 
-This project is configured with Claude Flow V3:
-- **Topology**: ${topology}
-- **Max Agents**: ${maxAgents}
-- **Memory Backend**: ${memoryBackend}
-- **HNSW Indexing**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
-- **Neural Learning**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}
+# Initialize swarm
+npx @claude-flow/cli@latest swarm init --v3-mode
 
-## SPARC Workflow Phases
+# Search memory (HNSW-indexed)
+npx @claude-flow/cli@latest memory search --query "authentication patterns"
 
-1. **Specification** - Requirements analysis (\`sparc run spec-pseudocode\`)
-2. **Pseudocode** - Algorithm design (\`sparc run spec-pseudocode\`)
-3. **Architecture** - System design (\`sparc run architect\`)
-4. **Refinement** - TDD implementation (\`sparc tdd\`)
-5. **Completion** - Integration (\`sparc run integration\`)
+# System diagnostics
+npx @claude-flow/cli@latest doctor --fix
 
-## Code Style & Best Practices
+# Security scan
+npx @claude-flow/cli@latest security scan --depth full
 
-- **Modular Design**: Files under 500 lines
-- **Environment Safety**: Never hardcode secrets
-- **Test-First**: Write tests before implementation
-- **Clean Architecture**: Separate concerns
-- **Documentation**: Keep updated
+# Performance benchmark
+npx @claude-flow/cli@latest performance benchmark --suite all
+\`\`\`
 
-## 🚀 Available Agents
+## 🚀 Available Agents (60+ Types)
 
 ### Core Development
 \`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
 
+### V3 Specialized Agents
+\`security-architect\`, \`security-auditor\`, \`memory-specialist\`, \`performance-engineer\`
+
+### 🔐 @claude-flow/security
+CVE remediation, input validation, path security:
+- \`InputValidator\` - Zod validation
+- \`PathValidator\` - Traversal prevention
+- \`SafeExecutor\` - Injection protection
+
 ### Swarm Coordination
 \`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`, \`collective-intelligence-coordinator\`, \`swarm-memory-manager\`
 
@@ -225,347 +388,303 @@ This project is configured with Claude Flow V3:
 ### Testing & Validation
 \`tdd-london-swarm\`, \`production-validator\`
 
-## 🎯 Claude Code vs MCP Tools
-
-### Claude Code Handles ALL EXECUTION:
-- **Task tool**: Spawn and run agents concurrently for actual work
-- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
-- Code generation and programming
-- Bash commands and system operations
-- Implementation work
-- Project navigation and analysis
-- TodoWrite and task management
-- Git operations
-- Package management
-- Testing and debugging
-
-### MCP Tools ONLY COORDINATE:
-- Swarm initialization (topology setup)
-- Agent type definitions (coordination patterns)
-- Task orchestration (high-level planning)
-- Memory management
-- Neural features
-- Performance tracking
-- GitHub integration
+## 🪝 V3 Hooks System (27 Hooks + 12 Workers)
+
+### All Available Hooks
+
+| Hook | Description | Key Options |
+|------|-------------|-------------|
+| \`pre-edit\` | Get context before editing files | \`--file\`, \`--operation\` |
+| \`post-edit\` | Record editing outcome for learning | \`--file\`, \`--success\`, \`--train-neural\` |
+| \`pre-command\` | Assess risk before commands | \`--command\`, \`--validate-safety\` |
+| \`post-command\` | Record command execution outcome | \`--command\`, \`--track-metrics\` |
+| \`pre-task\` | Record task start, get agent suggestions | \`--description\`, \`--coordinate-swarm\` |
+| \`post-task\` | Record task completion for learning | \`--task-id\`, \`--success\`, \`--store-results\` |
+| \`session-start\` | Start/restore session (v2 compat) | \`--session-id\`, \`--auto-configure\` |
+| \`session-end\` | End session and persist state | \`--generate-summary\`, \`--export-metrics\` |
+| \`session-restore\` | Restore a previous session | \`--session-id\`, \`--latest\` |
+| \`route\` | Route task to optimal agent | \`--task\`, \`--context\`, \`--top-k\` |
+| \`route-task\` | (v2 compat) Alias for route | \`--task\`, \`--auto-swarm\` |
+| \`explain\` | Explain routing decision | \`--topic\`, \`--detailed\` |
+| \`pretrain\` | Bootstrap intelligence from repo | \`--model-type\`, \`--epochs\` |
+| \`build-agents\` | Generate optimized agent configs | \`--agent-types\`, \`--focus\` |
+| \`metrics\` | View learning metrics dashboard | \`--v3-dashboard\`, \`--format\` |
+| \`transfer\` | Transfer patterns via IPFS registry | \`store\`, \`from-project\` |
+| \`list\` | List all registered hooks | \`--format\` |
+| \`intelligence\` | RuVector intelligence system | \`trajectory-*\`, \`pattern-*\`, \`stats\` |
+| \`worker\` | Background worker management | \`list\`, \`dispatch\`, \`status\`, \`detect\` |
+| \`progress\` | Check V3 implementation progress | \`--detailed\`, \`--format\` |
+| \`statusline\` | Generate dynamic statusline | \`--json\`, \`--compact\`, \`--no-color\` |
+| \`coverage-route\` | Route based on test coverage gaps | \`--task\`, \`--path\` |
+| \`coverage-suggest\` | Suggest coverage improvements | \`--path\` |
+| \`coverage-gaps\` | List coverage gaps with priorities | \`--format\`, \`--limit\` |
+| \`pre-bash\` | (v2 compat) Alias for pre-command | Same as pre-command |
+| \`post-bash\` | (v2 compat) Alias for post-command | Same as post-command |
+
+### 12 Background Workers
+
+| Worker | Priority | Description |
+|--------|----------|-------------|
+| \`ultralearn\` | normal | Deep knowledge acquisition |
+| \`optimize\` | high | Performance optimization |
+| \`consolidate\` | low | Memory consolidation |
+| \`predict\` | normal | Predictive preloading |
+| \`audit\` | critical | Security analysis |
+| \`map\` | normal | Codebase mapping |
+| \`preload\` | low | Resource preloading |
+| \`deepdive\` | normal | Deep code analysis |
+| \`document\` | normal | Auto-documentation |
+| \`refactor\` | normal | Refactoring suggestions |
+| \`benchmark\` | normal | Performance benchmarking |
+| \`testgaps\` | normal | Test coverage analysis |
 
-**KEY**: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.
-
-## 🚀 Quick Setup
+### Essential Hook Commands
 
 \`\`\`bash
-# Add MCP servers (Claude Flow required, others optional)
-claude mcp add claude-flow npx claude-flow@v3alpha mcp start
-claude mcp add ruv-swarm npx ruv-swarm mcp start  # Optional: Enhanced coordination
-claude mcp add flow-nexus npx flow-nexus@latest mcp start  # Optional: Cloud features
-\`\`\`
+# Core hooks
+npx @claude-flow/cli@latest hooks pre-task --description "[task]"
+npx @claude-flow/cli@latest hooks post-task --task-id "[id]" --success true
+npx @claude-flow/cli@latest hooks post-edit --file "[file]" --train-neural true
 
-## MCP Tool Categories
+# Session management
+npx @claude-flow/cli@latest hooks session-start --session-id "[id]"
+npx @claude-flow/cli@latest hooks session-end --export-metrics true
+npx @claude-flow/cli@latest hooks session-restore --session-id "[id]"
 
-### Coordination
-\`swarm_init\`, \`agent_spawn\`, \`task_orchestrate\`
+# Intelligence routing
+npx @claude-flow/cli@latest hooks route --task "[task]"
+npx @claude-flow/cli@latest hooks explain --topic "[topic]"
 
-### Monitoring
-\`swarm_status\`, \`agent_list\`, \`agent_metrics\`, \`task_status\`, \`task_results\`
+# Neural learning
+npx @claude-flow/cli@latest hooks pretrain --model-type moe --epochs 10
+npx @claude-flow/cli@latest hooks build-agents --agent-types coder,tester
 
-### Memory & Neural
-\`memory_usage\`, \`neural_status\`, \`neural_train\`, \`neural_patterns\`
+# Background workers
+npx @claude-flow/cli@latest hooks worker list
+npx @claude-flow/cli@latest hooks worker dispatch --trigger audit
+npx @claude-flow/cli@latest hooks worker status
 
-### GitHub Integration
-\`github_swarm\`, \`repo_analyze\`, \`pr_enhance\`, \`issue_triage\`, \`code_review\`
+# Coverage-aware routing
+npx @claude-flow/cli@latest hooks coverage-gaps --format table
+npx @claude-flow/cli@latest hooks coverage-route --task "[task]"
 
-### System
-\`benchmark_run\`, \`features_detect\`, \`swarm_monitor\`
+# Statusline (for Claude Code integration)
+npx @claude-flow/cli@latest hooks statusline
+npx @claude-flow/cli@latest hooks statusline --json
+\`\`\`
 
-## 🚀 Agent Execution Flow with Claude Code
+## 🔄 Migration (V2 to V3)
 
-### The Correct Pattern:
+\`\`\`bash
+# Check migration status
+npx @claude-flow/cli@latest migrate status
 
-1. **Optional**: Use MCP tools to set up coordination topology
-2. **REQUIRED**: Use Claude Code's Task tool to spawn agents that do actual work
-3. **REQUIRED**: Each agent runs hooks for coordination
-4. **REQUIRED**: Batch all operations in single messages
+# Run migration with backup
+npx @claude-flow/cli@latest migrate run --backup
 
-### Example Full-Stack Development:
+# Rollback if needed
+npx @claude-flow/cli@latest migrate rollback
 
-\`\`\`javascript
-// Single message with all agent spawning via Claude Code's Task tool
-[Parallel Agent Execution]:
-  Task("Backend Developer", "Build REST API with Express. Use hooks for coordination.", "backend-dev")
-  Task("Frontend Developer", "Create React UI. Coordinate with backend via memory.", "coder")
-  Task("Database Architect", "Design PostgreSQL schema. Store schema in memory.", "code-analyzer")
-  Task("Test Engineer", "Write Jest tests. Check memory for API contracts.", "tester")
-  Task("DevOps Engineer", "Setup Docker and CI/CD. Document in memory.", "cicd-engineer")
-  Task("Security Auditor", "Review authentication. Report findings via hooks.", "reviewer")
-
-  // All todos batched together
-  TodoWrite { todos: [...8-10 todos...] }
-
-  // All file operations together
-  Write "backend/server.js"
-  Write "frontend/App.jsx"
-  Write "database/schema.sql"
+# Validate migration
+npx @claude-flow/cli@latest migrate validate
 \`\`\`
 
-## 📋 Agent Coordination Protocol
+## 🧠 Intelligence System (RuVector)
 
-### Every Agent Spawned via Task Tool MUST:
+V3 includes the RuVector Intelligence System:
+- **SONA**: Self-Optimizing Neural Architecture (<0.05ms adaptation)
+- **MoE**: Mixture of Experts for specialized routing
+- **HNSW**: 150x-12,500x faster pattern search
+- **EWC++**: Elastic Weight Consolidation (prevents forgetting)
+- **Flash Attention**: 2.49x-7.47x speedup
 
-**1️⃣ BEFORE Work:**
-\`\`\`bash
-npx claude-flow@v3alpha hooks pre-task --description "[task]"
-npx claude-flow@v3alpha hooks session-restore --session-id "swarm-[id]"
-\`\`\`
+The 4-step intelligence pipeline:
+1. **RETRIEVE** - Fetch relevant patterns via HNSW
+2. **JUDGE** - Evaluate with verdicts (success/failure)
+3. **DISTILL** - Extract key learnings via LoRA
+4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++
 
-**2️⃣ DURING Work:**
-\`\`\`bash
-npx claude-flow@v3alpha hooks post-edit --file "[file]" --memory-key "swarm/[agent]/[step]"
-npx claude-flow@v3alpha hooks notify --message "[what was done]"
-\`\`\`
+## 📦 Embeddings Package (v3.0.0-alpha.12)
 
-**3️⃣ AFTER Work:**
-\`\`\`bash
-npx claude-flow@v3alpha hooks post-task --task-id "[task]"
-npx claude-flow@v3alpha hooks session-end --export-metrics true
-\`\`\`
+Features:
+- **sql.js**: Cross-platform SQLite persistent cache (WASM, no native compilation)
+- **Document chunking**: Configurable overlap and size
+- **Normalization**: L2, L1, min-max, z-score
+- **Hyperbolic embeddings**: Poincaré ball model for hierarchical data
+- **75x faster**: With agentic-flow ONNX integration
+- **Neural substrate**: Integration with RuVector
 
-## 🚀 Swarm Lifecycle Management
+## 🐝 Hive-Mind Consensus
 
-### Session Start (AUTOMATIC)
-When beginning ANY development task, Claude Code should:
+### Topologies
+- \`hierarchical\` - Queen controls workers directly
+- \`mesh\` - Fully connected peer network
+- \`hierarchical-mesh\` - Hybrid (recommended)
+- \`adaptive\` - Dynamic based on load
 
-\`\`\`javascript
-// 1. Check for existing swarm session
-mcp__claude-flow__swarm_status({})
+### Consensus Strategies
+- \`byzantine\` - BFT (tolerates f < n/3 faulty)
+- \`raft\` - Leader-based (tolerates f < n/2)
+- \`gossip\` - Epidemic for eventual consistency
+- \`crdt\` - Conflict-free replicated data types
+- \`quorum\` - Configurable quorum-based
 
-// 2. If no active swarm, initialize one
-mcp__claude-flow__swarm_init({ topology: "${topology}", maxAgents: ${maxAgents} })
+## V3 Performance Targets
 
-// 3. Restore previous context if available
-mcp__claude-flow__memory_usage({ action: "retrieve", namespace: "swarm", key: "last-session" })
-\`\`\`
+| Metric | Target |
+|--------|--------|
+| Flash Attention | 2.49x-7.47x speedup |
+| HNSW Search | 150x-12,500x faster |
+| Memory Reduction | 50-75% with quantization |
+| MCP Response | <100ms |
+| CLI Startup | <500ms |
+| SONA Adaptation | <0.05ms |
 
-### Task Execution (AUTOMATIC)
-For each significant task:
+## 📊 Performance Optimization Protocol
 
-\`\`\`javascript
-// 1. Create task orchestration
-mcp__claude-flow__task_orchestrate({
-  task: "[task description]",
-  priority: "high",
-  strategy: "adaptive"
-})
+### Automatic Performance Tracking
+\`\`\`bash
+# After any significant operation, track metrics
+Bash("npx @claude-flow/cli@latest hooks post-command --command '[operation]' --track-metrics true")
 
-// 2. Spawn appropriate agents via Task tool (PARALLEL)
-Task("Agent1", "...", "agent-type")
-Task("Agent2", "...", "agent-type")
-Task("Agent3", "...", "agent-type")
+# Periodically run benchmarks (every major feature)
+Bash("npx @claude-flow/cli@latest performance benchmark --suite all")
 
-// 3. Monitor progress via MCP
-mcp__claude-flow__swarm_status({ includeAgents: true, includeMetrics: true })
+# Analyze bottlenecks when performance degrades
+Bash("npx @claude-flow/cli@latest performance profile --target '[component]'")
 \`\`\`
 
-### Session End (AUTOMATIC)
-When task completes or user ends session:
-
-\`\`\`javascript
-// 1. Save session state
-mcp__claude-flow__memory_usage({
-  action: "store",
-  namespace: "swarm",
-  key: "last-session",
-  value: JSON.stringify({ completedAt: new Date().toISOString(), summary: "..." })
-})
-
-// 2. Export metrics if enabled
-mcp__claude-flow__agent_metrics({})
+### Session Persistence (Cross-Conversation Learning)
+\`\`\`bash
+# At session start - restore previous context
+Bash("npx @claude-flow/cli@latest session restore --latest")
 
-// 3. Graceful shutdown (only if explicitly requested)
-// mcp__claude-flow__swarm_destroy({ swarmId: "..." })
+# At session end - persist learned patterns
+Bash("npx @claude-flow/cli@latest hooks session-end --generate-summary true --persist-state true --export-metrics true")
 \`\`\`
 
-## 🎯 Concurrent Execution Examples
+### Neural Pattern Training
+\`\`\`bash
+# Train on successful code patterns
+Bash("npx @claude-flow/cli@latest neural train --pattern-type coordination --epochs 10")
 
-### ✅ CORRECT WORKFLOW: MCP Coordinates, Claude Code Executes
+# Predict optimal approach for new tasks
+Bash("npx @claude-flow/cli@latest neural predict --input '[task description]'")
 
-\`\`\`javascript
-// Step 1: MCP tools set up coordination (optional, for complex tasks)
-[Single Message - Coordination Setup]:
-  mcp__claude-flow__swarm_init { topology: "${topology}", maxAgents: ${maxAgents} }
-  mcp__claude-flow__agent_spawn { type: "researcher" }
-  mcp__claude-flow__agent_spawn { type: "coder" }
-  mcp__claude-flow__agent_spawn { type: "tester" }
-
-// Step 2: Claude Code Task tool spawns ACTUAL agents that do the work
-[Single Message - Parallel Agent Execution]:
-  // Claude Code's Task tool spawns real agents concurrently
-  Task("Research agent", "Analyze API requirements and best practices. Check memory for prior decisions.", "researcher")
-  Task("Coder agent", "Implement REST endpoints with authentication. Coordinate via hooks.", "coder")
-  Task("Database agent", "Design and implement database schema. Store decisions in memory.", "code-analyzer")
-  Task("Tester agent", "Create comprehensive test suite with 90% coverage.", "tester")
-  Task("Reviewer agent", "Review code quality and security. Document findings.", "reviewer")
-
-  // Batch ALL todos in ONE call
-  TodoWrite { todos: [
-    {id: "1", content: "Research API patterns", status: "in_progress", priority: "high"},
-    {id: "2", content: "Design database schema", status: "in_progress", priority: "high"},
-    {id: "3", content: "Implement authentication", status: "pending", priority: "high"},
-    {id: "4", content: "Build REST endpoints", status: "pending", priority: "high"},
-    {id: "5", content: "Write unit tests", status: "pending", priority: "medium"},
-    {id: "6", content: "Integration tests", status: "pending", priority: "medium"},
-    {id: "7", content: "API documentation", status: "pending", priority: "low"},
-    {id: "8", content: "Performance optimization", status: "pending", priority: "low"}
-  ]}
-
-  // Parallel file operations
-  Bash "mkdir -p app/{src,tests,docs,config}"
-  Write "app/package.json"
-  Write "app/src/server.js"
-  Write "app/tests/server.test.js"
-  Write "app/docs/API.md"
+# View learned patterns
+Bash("npx @claude-flow/cli@latest neural patterns --list")
 \`\`\`
 
-### ❌ WRONG (Multiple Messages):
-\`\`\`javascript
-Message 1: mcp__claude-flow__swarm_init
-Message 2: Task("agent 1")
-Message 3: TodoWrite { todos: [single todo] }
-Message 4: Write "file.js"
-// This breaks parallel coordination!
-\`\`\`
-
-## V3 Performance Targets
-
-- **2.49x-7.47x** Flash Attention speedup
-- **150x-12,500x** search improvements with HNSW
-- **50-75%** memory reduction with quantization
-- **Sub-100ms** MCP response times
-
-## 🪝 V3 Hooks System (26 Hooks)
-
-Claude Flow V3 provides 26 hooks for comprehensive agent coordination and self-learning.
-
-### Hook Categories
-
-| Category | Hooks | Purpose |
-|----------|-------|---------|
-| **Core** | \`pre-edit\`, \`post-edit\`, \`pre-command\`, \`post-command\`, \`pre-task\`, \`post-task\` | Tool lifecycle |
-| **Routing** | \`route\`, \`metrics\`, \`list\` | Task analysis |
-| **Intelligence** | \`explain\`, \`pretrain\`, \`build-agents\`, \`transfer\`, \`init\` | Neural learning |
-| **Session** | \`session-start\`, \`session-end\`, \`session-restore\`, \`notify\` | Context management |
-| **Learning** | \`trajectory-start\`, \`trajectory-step\`, \`trajectory-end\` | Reinforcement learning |
-| **Patterns** | \`pattern-store\`, \`pattern-search\`, \`stats\`, \`learn\`, \`attention\` | Memory & search |
-
-### Essential Hook Commands
+## 🔧 Environment Variables
 
 \`\`\`bash
-# Core hooks for tool coordination
-npx claude-flow@v3alpha hooks pre-task --description "[task]"
-npx claude-flow@v3alpha hooks post-task --task-id "[id]" --success true
-npx claude-flow@v3alpha hooks post-edit --file "[file]" --train-patterns
+# Configuration
+CLAUDE_FLOW_CONFIG=./claude-flow.config.json
+CLAUDE_FLOW_LOG_LEVEL=info
+
+# Provider API Keys
+ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=...
+
+# MCP Server
+CLAUDE_FLOW_MCP_PORT=3000
+CLAUDE_FLOW_MCP_HOST=localhost
+CLAUDE_FLOW_MCP_TRANSPORT=stdio
+
+# Memory
+CLAUDE_FLOW_MEMORY_BACKEND=hybrid
+CLAUDE_FLOW_MEMORY_PATH=./data/memory
+\`\`\`
 
-# Session management
-npx claude-flow@v3alpha hooks session-start --session-id "[id]"
-npx claude-flow@v3alpha hooks session-end --export-metrics true --persist-patterns
-npx claude-flow@v3alpha hooks session-restore --session-id "[id]"
+## 🔍 Doctor Health Checks
 
-# Intelligence routing
-npx claude-flow@v3alpha hooks route --task "[task]" --include-explanation
-npx claude-flow@v3alpha hooks explain --topic "[topic]" --depth comprehensive
+Run \`npx @claude-flow/cli@latest doctor\` to check:
+- Node.js version (20+)
+- npm version (9+)
+- Git installation
+- Config file validity
+- Daemon status
+- Memory database
+- API keys
+- MCP servers
+- Disk space
+- TypeScript installation
 
-# Neural learning
-npx claude-flow@v3alpha hooks pretrain --model-type moe --epochs 10
-npx claude-flow@v3alpha hooks build-agents --agent-types coder,tester --config-format yaml
+## 🚀 Quick Setup
 
-# Trajectory learning (reinforcement)
-npx claude-flow@v3alpha hooks intelligence trajectory-start --session "[session]"
-npx claude-flow@v3alpha hooks intelligence trajectory-step --action "[action]" --reward "[reward]"
-npx claude-flow@v3alpha hooks intelligence trajectory-end --verdict success
+\`\`\`bash
+# Add MCP servers (auto-detects MCP mode when stdin is piped)
+claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
+claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start  # Optional
+claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start  # Optional
 
-# Pattern storage (HNSW-indexed)
-npx claude-flow@v3alpha hooks intelligence pattern-store --pattern "[pattern]" --embedding "[json]"
-npx claude-flow@v3alpha hooks intelligence pattern-search --query "[query]" --limit 10
+# Start daemon
+npx @claude-flow/cli@latest daemon start
 
-# Learning stats & attention
-npx claude-flow@v3alpha hooks intelligence stats
-npx claude-flow@v3alpha hooks intelligence attention --focus "[task]"
+# Run doctor
+npx @claude-flow/cli@latest doctor --fix
 \`\`\`
 
-### Intelligence System (RuVector)
-
-V3 includes the RuVector Intelligence System with:
-- **SONA**: Self-Optimizing Neural Architecture
-- **MoE**: Mixture of Experts for specialized routing
-- **HNSW**: 150x faster pattern search
-- **EWC++**: Elastic Weight Consolidation (prevents forgetting)
-- **Flash Attention**: 2.49x-7.47x speedup
-
-The 4-step intelligence pipeline:
-1. **RETRIEVE** - Fetch relevant patterns via HNSW
-2. **JUDGE** - Evaluate with verdicts (success/failure)
-3. **DISTILL** - Extract key learnings via LoRA
-4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++
+## 🎯 Claude Code vs CLI Tools
 
-### Auto-Configured Hooks
-
-The init system configures these hooks in \`.claude/settings.json\`:
-
-\`\`\`json
-{
-  "hooks": {
-    "PreToolUse": [
-      { "matcher": "Task", "commands": ["npx claude-flow@v3alpha hooks pre-task --tool Task"] }
-    ],
-    "PostToolUse": [
-      { "matcher": "Task", "commands": ["npx claude-flow@v3alpha hooks post-task --tool Task --train-patterns"] }
-    ],
-    "UserPromptSubmit": [
-      { "matcher": ".*", "commands": ["npx claude-flow@v3alpha hooks route-task --analyze-complexity"] }
-    ],
-    "SessionStart": [
-      { "commands": ["npx claude-flow@v3alpha hooks session-start --load-context"] }
-    ]
-  }
-}
-\`\`\`
-
-### Agent Coordination via Hooks
+### Claude Code Handles ALL EXECUTION:
+- **Task tool**: Spawn and run agents concurrently
+- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
+- Code generation and programming
+- Bash commands and system operations
+- TodoWrite and task management
+- Git operations
 
-Every spawned agent should use hooks for coordination:
+### CLI Tools Handle Coordination (via Bash):
+- **Swarm init**: \`npx @claude-flow/cli@latest swarm init --topology <type>\`
+- **Swarm status**: \`npx @claude-flow/cli@latest swarm status\`
+- **Agent spawn**: \`npx @claude-flow/cli@latest agent spawn -t <type> --name <name>\`
+- **Memory store**: \`npx @claude-flow/cli@latest memory store --key "mykey" --value "myvalue" --namespace patterns\`
+- **Memory search**: \`npx @claude-flow/cli@latest memory search --query "search terms"\`
+- **Memory list**: \`npx @claude-flow/cli@latest memory list --namespace patterns\`
+- **Memory retrieve**: \`npx @claude-flow/cli@latest memory retrieve --key "mykey" --namespace patterns\`
+- **Hooks**: \`npx @claude-flow/cli@latest hooks <hook-name> [options]\`
 
-\`\`\`javascript
-// In agent prompt instructions
-Task("Coder", \`
-  BEFORE starting: npx claude-flow@v3alpha hooks pre-task --description "Implement feature X"
+## 📝 Memory Commands Reference (IMPORTANT)
 
-  DURING work:
-  - After each file edit: npx claude-flow@v3alpha hooks post-edit --file "[file]"
-  - To notify others: npx claude-flow@v3alpha hooks notify --message "[update]"
+### Store Data (ALL options shown)
+\`\`\`bash
+# REQUIRED: --key and --value
+# OPTIONAL: --namespace (default: "default"), --ttl, --tags
+npx @claude-flow/cli@latest memory store --key "pattern-auth" --value "JWT with refresh tokens" --namespace patterns
+npx @claude-flow/cli@latest memory store --key "bug-fix-123" --value "Fixed null check" --namespace solutions --tags "bugfix,auth"
+\`\`\`
 
-  AFTER completing: npx claude-flow@v3alpha hooks post-task --success true
-\`, "coder")
+### Search Data (semantic vector search)
+\`\`\`bash
+# REQUIRED: --query (full flag, not -q)
+# OPTIONAL: --namespace, --limit, --threshold
+npx @claude-flow/cli@latest memory search --query "authentication patterns"
+npx @claude-flow/cli@latest memory search --query "error handling" --namespace patterns --limit 5
 \`\`\`
 
-## Advanced Features (V3)
+### List Entries
+\`\`\`bash
+# OPTIONAL: --namespace, --limit
+npx @claude-flow/cli@latest memory list
+npx @claude-flow/cli@latest memory list --namespace patterns --limit 10
+\`\`\`
 
-- 🚀 Automatic Topology Selection
-- ⚡ Parallel Execution (2.8-4.4x speed)
-- 🧠 Neural Training with ReasoningBank
-- 📊 Bottleneck Analysis
-- 🤖 Smart Auto-Spawning
-- 🛡️ Self-Healing Workflows
-- 💾 Cross-Session Memory with AgentDB
-- 🔗 GitHub Integration
-- 🔐 Security-Hardened Architecture
+### Retrieve Specific Entry
+\`\`\`bash
+# REQUIRED: --key
+# OPTIONAL: --namespace (default: "default")
+npx @claude-flow/cli@latest memory retrieve --key "pattern-auth"
+npx @claude-flow/cli@latest memory retrieve --key "pattern-auth" --namespace patterns
+\`\`\`
 
-## Integration Tips
+### Initialize Memory Database
+\`\`\`bash
+npx @claude-flow/cli@latest memory init --force --verbose
+\`\`\`
 
-1. Start with basic swarm init
-2. Scale agents gradually
-3. Use memory for context
-4. Monitor progress regularly
-5. Train patterns from success
-6. Enable hooks automation
-7. Use GitHub tools first
+**KEY**: CLI coordinates the strategy via Bash, Claude Code's Task tool executes with real agents.
 
 ## Support
 
@@ -574,7 +693,7 @@ Task("Coder", \`
 
 ---
 
-Remember: **Claude Flow coordinates, Claude Code creates!**
+Remember: **Claude Flow CLI coordinates, Claude Code Task tool creates!**
 
 # important-instruction-reminders
 Do what has been asked; nothing more, nothing less.
@@ -582,44 +701,91 @@ NEVER create files unless they're absolutely necessary for achieving your goal.
 ALWAYS prefer editing an existing file to creating a new one.
 NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
 Never save working files, text/mds and tests to the root folder.
+
+## 🚨 SWARM EXECUTION RULES (CRITICAL)
+1. **SPAWN IN BACKGROUND**: Use \`run_in_background: true\` for all agent Task calls
+2. **SPAWN ALL AT ONCE**: Put ALL agent Task calls in ONE message for parallel execution
+3. **TELL USER**: After spawning, list what each agent is doing (use emojis for clarity)
+4. **STOP AND WAIT**: After spawning, STOP - do NOT add more tool calls or check status
+5. **NO POLLING**: Never poll TaskOutput or check swarm status - trust agents to return
+6. **SYNTHESIZE**: When agent results arrive, review ALL results before proceeding
+7. **NO CONFIRMATION**: Don't ask "should I check?" - just wait for results
+
+Example spawn message:
+\`\`\`
+"I've launched 4 agents in background:
+- 🔍 Researcher: [task]
+- 💻 Coder: [task]
+- 🧪 Tester: [task]
+- 👀 Reviewer: [task]
+Working in parallel - I'll synthesize when they complete."
+\`\`\`
 `;
 }
 /**
  * Generate minimal CLAUDE.md content
  */
 export function generateMinimalClaudeMd(options) {
-    return `# Claude Code Configuration
+    return `# Claude Code Configuration - Claude Flow V3
+
+## Anti-Drift Config (PREFERRED)
+\`\`\`bash
+# Small teams (6-8 agents)
+npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
+
+# Large teams (10-15 agents)
+npx @claude-flow/cli@latest swarm init --topology hierarchical-mesh --max-agents 15 --strategy specialized
+\`\`\`
+**Valid topologies:** hierarchical, hierarchical-mesh, mesh, ring, star, hybrid
 
 ## Quick Reference
 
-- **Topology**: ${options.runtime.topology}
-- **Max Agents**: ${options.runtime.maxAgents}
+- **Topology**: hierarchical (prevents drift)
+- **Max Agents**: 8
+- **Strategy**: specialized
 - **Memory**: ${options.runtime.memoryBackend}
+- **HNSW**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
 
 ## Key Rules
 
-1. **Batch Operations**: All related operations in ONE message
-2. **Task Tool**: Use Claude Code's Task tool for agent execution
-3. **MCP Tools**: Only for coordination, not execution
-4. **File Organization**: Never save to root folder
+1. **Batch Operations**: All related ops in ONE message
+2. **Task Tool**: Claude Code's Task tool for execution
+3. **CLI Tools**: Bash for coordination
+4. **Anti-Drift**: Always use hierarchical + specialized for coding
 
 ## Agent Execution Pattern
 
 \`\`\`javascript
-// Single message with parallel agents
-Task("Researcher", "Analyze requirements...", "researcher")
-Task("Coder", "Implement features...", "coder")
-Task("Tester", "Write tests...", "tester")
+// Single message with parallel agents (background)
+Task({prompt: "Analyze...", subagent_type: "researcher", run_in_background: true})
+Task({prompt: "Implement...", subagent_type: "coder", run_in_background: true})
+Task({prompt: "Test...", subagent_type: "tester", run_in_background: true})
+\`\`\`
+
+## 26 CLI Commands
+
+\`\`\`bash
+# Core
+npx @claude-flow/cli@latest init --wizard
+npx @claude-flow/cli@latest agent spawn -t coder
+npx @claude-flow/cli@latest swarm init --v3-mode
+npx @claude-flow/cli@latest memory search --query "query"
+
+# Advanced
+npx @claude-flow/cli@latest daemon start
+npx @claude-flow/cli@latest doctor --fix
+npx @claude-flow/cli@latest security scan
+npx @claude-flow/cli@latest performance benchmark
 \`\`\`
 
 ## MCP Setup
 
 \`\`\`bash
-claude mcp add claude-flow npx claude-flow@v3alpha mcp start
+claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
 \`\`\`
 
 ---
-Remember: **Claude Flow coordinates, Claude Code creates!**
+Remember: **Claude Flow CLI coordinates, Claude Code Task tool creates!**
 `;
 }
 export default generateClaudeMd;