@claude-flow/cli 3.0.2 → 3.1.0-alpha.2

package/dist/src/init/claudemd-generator.js

@@ -1,501 +1,323 @@
 /**
  * CLAUDE.md Generator
- * Generates project-specific Claude Code configuration with V3 swarm guidance
+ * Generates enforceable, analyzer-optimized Claude Code configuration
+ * with template variants for different usage patterns.
+ *
+ * Templates: minimal | standard | full | security | performance | solo
+ * All templates use bullet-format rules with imperative keywords for enforceability.
  */
-/**
- * Generate CLAUDE.md content based on init options
- */
-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
-
-## 🚨 AUTOMATIC SWARM ORCHESTRATION
-
-**When starting work on complex tasks, Claude Code MUST automatically:**
-
-1. **Initialize the swarm** using MCP tools
-2. **Spawn concurrent agents** using Claude Code's Task tool
-3. **Coordinate via hooks** and memory
+// --- Section Generators (each returns enforceable markdown) ---
+function behavioralRules() {
+    return `## Behavioral Rules (Always Enforced)
+
+- Do what has been asked; nothing more, nothing less
+- 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 unless explicitly requested
+- NEVER save working files, text/mds, or tests to the root folder
+- Never continuously check status after spawning a swarm — wait for results
+- ALWAYS read a file before editing it
+- NEVER commit secrets, credentials, or .env files`;
+}
+function fileOrganization() {
+    return `## File Organization
+
+- NEVER save to root folder — use the directories below
+- Use \`/src\` for source code files
+- Use \`/tests\` for test files
+- Use \`/docs\` for documentation and markdown files
+- Use \`/config\` for configuration files
+- Use \`/scripts\` for utility scripts
+- Use \`/examples\` for example code`;
+}
+function projectArchitecture(options) {
+    return `## Project Architecture
 
-### 🚨 CRITICAL: MCP + Task Tool in SAME Message
+- Follow Domain-Driven Design with bounded contexts
+- Keep files under 500 lines
+- Use typed interfaces for all public APIs
+- Prefer TDD London School (mock-first) for new code
+- Use event sourcing for state changes
+- Ensure input validation at system boundaries
 
-**When user says "spawn swarm" or requests complex work, Claude Code MUST in ONE message:**
-1. Call MCP tools 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
+### Project Config
 
-**MCP alone does NOT execute work - Task tool agents do the actual work!**
+- **Topology**: ${options.runtime.topology}
+- **Max Agents**: ${options.runtime.maxAgents}
+- **Memory**: ${options.runtime.memoryBackend}
+- **HNSW**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
+- **Neural**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}`;
+}
+function concurrencyRules() {
+    return `## Concurrency: 1 MESSAGE = ALL RELATED OPERATIONS
+
+- All operations MUST be concurrent/parallel in a single message
+- Use Claude Code's Task tool for spawning agents, not just MCP
+- ALWAYS batch ALL todos in ONE TodoWrite call (5-10+ minimum)
+- ALWAYS spawn ALL agents in ONE message with full instructions via Task tool
+- ALWAYS batch ALL file reads/writes/edits in ONE message
+- ALWAYS batch ALL Bash commands in ONE message`;
+}
+function swarmOrchestration() {
+    return `## Swarm Orchestration
 
-### 🔄 Auto-Start Swarm Protocol
+- MUST initialize the swarm using CLI tools when starting complex tasks
+- MUST spawn concurrent agents using Claude Code's Task tool
+- Never use CLI tools alone for execution — Task tool agents do the actual work
+- MUST call CLI tools AND Task tool in ONE message for complex work
 
-When the user requests a complex task (multi-file changes, feature implementation, refactoring), **immediately execute this pattern in a SINGLE message:**
+### 3-Tier Model Routing (ADR-026)
 
-\`\`\`javascript
-// STEP 1: Initialize swarm coordination via MCP (in parallel with agent spawning)
-mcp__claude-flow__swarm_init({
-  topology: "${topology}",
-  maxAgents: ${maxAgents},
-  strategy: "adaptive"
-})
-
-// 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()})
-})
-\`\`\`
+| Tier | Handler | Latency | Cost | Use Cases |
+|------|---------|---------|------|-----------|
+| **1** | Agent Booster (WASM) | <1ms | $0 | Simple transforms (var→const, add types) — Skip LLM |
+| **2** | Haiku | ~500ms | $0.0002 | Simple tasks, low complexity (<30%) |
+| **3** | Sonnet/Opus | 2-5s | $0.003-0.015 | Complex reasoning, architecture, security (>30%) |
 
-### 📋 Agent Routing by Task Type
-
-**Automatically select agents based on task:**
-
-| 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 |
-
-### 🎯 Task Complexity Detection
-
-**AUTO-INVOKE SWARM when task involves:**
-- Multiple files (3+)
-- New feature implementation
-- Refactoring across modules
-- API changes with tests
-- Security-related changes
-- Performance optimization
-- Database schema changes
-
-**SKIP SWARM for:**
-- Single file edits
-- Simple bug fixes (1-2 lines)
-- Documentation updates
-- 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__*"
-    ]
-  }
+- Always check for \`[AGENT_BOOSTER_AVAILABLE]\` or \`[TASK_MODEL_RECOMMENDATION]\` before spawning agents
+- Use Edit tool directly when \`[AGENT_BOOSTER_AVAILABLE]\``;
 }
-\`\`\`
-
-## 🚨 CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT
+function antiDriftConfig() {
+    return `## Swarm Configuration & Anti-Drift
 
-**ABSOLUTE RULES**:
-1. ALL operations MUST be concurrent/parallel in a single message
-2. **NEVER save working files, text/mds and tests to the root folder**
-3. ALWAYS organize files in appropriate subdirectories
-4. **USE CLAUDE CODE'S TASK TOOL** for spawning agents concurrently, not just MCP
+- ALWAYS use hierarchical topology for coding swarms
+- Keep maxAgents at 6-8 for tight coordination
+- Use specialized strategy for clear role boundaries
+- Use \`raft\` consensus for hive-mind (leader maintains authoritative state)
+- Run frequent checkpoints via \`post-task\` hooks
+- Keep shared memory namespace for all agents
 
-### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+\`\`\`bash
+npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
+\`\`\``;
+}
+function autoStartProtocol() {
+    return `## Swarm Protocols & Routing
 
-**MANDATORY PATTERNS:**
-- **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
-- **Task tool (Claude Code)**: ALWAYS spawn ALL agents in ONE message with full instructions
-- **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
-- **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
-- **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+### Auto-Start Swarm Protocol
 
-### 🎯 CRITICAL: Claude Code Task Tool for Agent Execution
+When the user requests a complex task, spawn agents in background and WAIT:
 
-**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")
+// STEP 1: Initialize swarm coordination
+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
+Task({prompt: "Research requirements...", subagent_type: "researcher", run_in_background: true})
+Task({prompt: "Design architecture...", subagent_type: "system-architect", run_in_background: true})
+Task({prompt: "Implement solution...", subagent_type: "coder", run_in_background: true})
+Task({prompt: "Write tests...", subagent_type: "tester", run_in_background: true})
+Task({prompt: "Review code quality...", subagent_type: "reviewer", run_in_background: true})
 \`\`\`
 
-**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:**
-- \`/src\` - Source code files
-- \`/tests\` - Test files
-- \`/docs\` - Documentation and markdown files
-- \`/config\` - Configuration files
-- \`/scripts\` - Utility scripts
-- \`/examples\` - Example code
+### Agent Routing
 
-## Project Configuration
+| 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 |
 
-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'}
+### Task Complexity Detection
 
-## SPARC Workflow Phases
+- AUTO-INVOKE SWARM when task involves: 3+ files, new features, cross-module refactoring, API changes, security, or performance work
+- SKIP SWARM for: single file edits, simple bug fixes (1-2 lines), documentation updates, configuration changes`;
+}
+function executionRules() {
+    return `## Swarm Execution Rules
+
+- ALWAYS use \`run_in_background: true\` for all agent Task calls
+- ALWAYS put ALL agent Task calls in ONE message for parallel execution
+- After spawning, STOP — do NOT add more tool calls or check status
+- Never poll TaskOutput or check swarm status — trust agents to return
+- When agent results arrive, review ALL results before proceeding`;
+}
+function cliCommandsTable() {
+    return `## V3 CLI Commands
 
-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\`)
+### Core Commands
 
-## Code Style & Best Practices
+| Command | Subcommands | Description |
+|---------|-------------|-------------|
+| \`init\` | 4 | Project initialization |
+| \`agent\` | 8 | Agent lifecycle management |
+| \`swarm\` | 6 | Multi-agent swarm coordination |
+| \`memory\` | 11 | AgentDB memory with HNSW search |
+| \`task\` | 6 | Task creation and lifecycle |
+| \`session\` | 7 | Session state management |
+| \`hooks\` | 17 | Self-learning hooks + 12 workers |
+| \`hive-mind\` | 6 | Byzantine fault-tolerant consensus |
 
-- **Modular Design**: Files under 500 lines
-- **Environment Safety**: Never hardcode secrets
-- **Test-First**: Write tests before implementation
-- **Clean Architecture**: Separate concerns
-- **Documentation**: Keep updated
+### Quick CLI Examples
 
-## 🚀 Available Agents
+\`\`\`bash
+npx @claude-flow/cli@latest init --wizard
+npx @claude-flow/cli@latest agent spawn -t coder --name my-coder
+npx @claude-flow/cli@latest swarm init --v3-mode
+npx @claude-flow/cli@latest memory search --query "authentication patterns"
+npx @claude-flow/cli@latest doctor --fix
+\`\`\``;
+}
+function agentTypes() {
+    return `## Available Agents (60+ Types)
 
 ### Core Development
 \`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
 
-### Swarm Coordination
-\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`, \`collective-intelligence-coordinator\`, \`swarm-memory-manager\`
-
-### Consensus & Distributed
-\`byzantine-coordinator\`, \`raft-manager\`, \`gossip-coordinator\`, \`consensus-builder\`, \`crdt-synchronizer\`, \`quorum-manager\`, \`security-manager\`
+### Specialized
+\`security-architect\`, \`security-auditor\`, \`memory-specialist\`, \`performance-engineer\`
 
-### Performance & Optimization
-\`perf-analyzer\`, \`performance-benchmarker\`, \`task-orchestrator\`, \`memory-coordinator\`, \`smart-agent\`
+### Swarm Coordination
+\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`
 
 ### GitHub & Repository
-\`github-modes\`, \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`, \`workflow-automation\`, \`project-board-sync\`, \`repo-architect\`, \`multi-repo-swarm\`
+\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`
 
 ### SPARC Methodology
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\`, \`refinement\`
-
-### Specialized Development
-\`backend-dev\`, \`mobile-dev\`, \`ml-developer\`, \`cicd-engineer\`, \`api-docs\`, \`system-architect\`, \`code-analyzer\`, \`base-template-generator\`
-
-### 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
-
-**KEY**: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.
-
-## 🚀 Quick Setup
-
-\`\`\`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
-\`\`\`
-
-## MCP Tool Categories
-
-### Coordination
-\`swarm_init\`, \`agent_spawn\`, \`task_orchestrate\`
-
-### Monitoring
-\`swarm_status\`, \`agent_list\`, \`agent_metrics\`, \`task_status\`, \`task_results\`
-
-### Memory & Neural
-\`memory_usage\`, \`neural_status\`, \`neural_train\`, \`neural_patterns\`
-
-### GitHub Integration
-\`github_swarm\`, \`repo_analyze\`, \`pr_enhance\`, \`issue_triage\`, \`code_review\`
-
-### System
-\`benchmark_run\`, \`features_detect\`, \`swarm_monitor\`
-
-## 🚀 Agent Execution Flow with Claude Code
-
-### The Correct Pattern:
-
-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
-
-### Example Full-Stack Development:
-
-\`\`\`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"
-\`\`\`
-
-## 📋 Agent Coordination Protocol
-
-### Every Agent Spawned via Task Tool MUST:
+\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\``;
+}
+function hooksSystem() {
+    return `## Hooks System (27 Hooks + 12 Workers)
+
+### Essential Hooks
+
+| Hook | Description |
+|------|-------------|
+| \`pre-task\` / \`post-task\` | Task lifecycle with learning |
+| \`pre-edit\` / \`post-edit\` | File editing with neural training |
+| \`session-start\` / \`session-end\` | Session state persistence |
+| \`route\` | Route task to optimal agent |
+| \`intelligence\` | RuVector intelligence system |
+| \`worker\` | Background worker management |
+
+### 12 Background Workers
+
+| Worker | Priority | Description |
+|--------|----------|-------------|
+| \`optimize\` | high | Performance optimization |
+| \`audit\` | critical | Security analysis |
+| \`testgaps\` | normal | Test coverage analysis |
+| \`map\` | normal | Codebase mapping |
+| \`deepdive\` | normal | Deep code analysis |
+| \`document\` | normal | Auto-documentation |
 
-**1️⃣ BEFORE Work:**
 \`\`\`bash
-npx claude-flow@v3alpha hooks pre-task --description "[task]"
-npx claude-flow@v3alpha hooks session-restore --session-id "swarm-[id]"
-\`\`\`
+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 worker dispatch --trigger audit
+\`\`\``;
+}
+function learningProtocol() {
+    return `## Auto-Learning Protocol
 
-**2️⃣ DURING Work:**
+### Before Starting Any Task
 \`\`\`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]"
+npx @claude-flow/cli@latest memory search --query "[task keywords]" --namespace patterns
+npx @claude-flow/cli@latest hooks route --task "[task description]"
 \`\`\`
 
-**3️⃣ AFTER Work:**
+### After Completing Any Task Successfully
 \`\`\`bash
-npx claude-flow@v3alpha hooks post-task --task-id "[task]"
-npx claude-flow@v3alpha hooks session-end --export-metrics true
+npx @claude-flow/cli@latest memory store --namespace patterns --key "[pattern-name]" --value "[what worked]"
+npx @claude-flow/cli@latest hooks post-task --task-id "[id]" --success true --store-results true
 \`\`\`
 
-## 🚀 Swarm Lifecycle Management
-
-### Session Start (AUTOMATIC)
-When beginning ANY development task, Claude Code should:
+- ALWAYS check memory before starting new features, debugging, or refactoring
+- ALWAYS store patterns in memory after solving bugs, completing features, or finding optimizations`;
+}
+function memoryCommands() {
+    return `## Memory Commands Reference
 
-\`\`\`javascript
-// 1. Check for existing swarm session
-mcp__claude-flow__swarm_status({})
+\`\`\`bash
+# Store (REQUIRED: --key, --value; OPTIONAL: --namespace, --ttl, --tags)
+npx @claude-flow/cli@latest memory store --key "pattern-auth" --value "JWT with refresh" --namespace patterns
 
-// 2. If no active swarm, initialize one
-mcp__claude-flow__swarm_init({ topology: "${topology}", maxAgents: ${maxAgents} })
+# Search (REQUIRED: --query; OPTIONAL: --namespace, --limit, --threshold)
+npx @claude-flow/cli@latest memory search --query "authentication patterns"
 
-// 3. Restore previous context if available
-mcp__claude-flow__memory_usage({ action: "retrieve", namespace: "swarm", key: "last-session" })
-\`\`\`
+# List (OPTIONAL: --namespace, --limit)
+npx @claude-flow/cli@latest memory list --namespace patterns --limit 10
 
-### Task Execution (AUTOMATIC)
-For each significant task:
+# Retrieve (REQUIRED: --key; OPTIONAL: --namespace)
+npx @claude-flow/cli@latest memory retrieve --key "pattern-auth" --namespace patterns
+\`\`\``;
+}
+function securityRulesLight() {
+    return `## Security Rules
+
+- NEVER hardcode API keys, secrets, or credentials in source files
+- NEVER commit .env files or any file containing secrets
+- Always validate user input at system boundaries
+- Always sanitize file paths to prevent directory traversal
+- Run \`npx @claude-flow/cli@latest security scan\` after security-related changes`;
+}
+function buildAndTest() {
+    return `## Build & Test
 
-\`\`\`javascript
-// 1. Create task orchestration
-mcp__claude-flow__task_orchestrate({
-  task: "[task description]",
-  priority: "high",
-  strategy: "adaptive"
-})
-
-// 2. Spawn appropriate agents via Task tool (PARALLEL)
-Task("Agent1", "...", "agent-type")
-Task("Agent2", "...", "agent-type")
-Task("Agent3", "...", "agent-type")
-
-// 3. Monitor progress via MCP
-mcp__claude-flow__swarm_status({ includeAgents: true, includeMetrics: true })
-\`\`\`
+\`\`\`bash
+# Build
+npm run build
 
-### Session End (AUTOMATIC)
-When task completes or user ends session:
+# Test
+npm test
 
-\`\`\`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({})
-
-// 3. Graceful shutdown (only if explicitly requested)
-// mcp__claude-flow__swarm_destroy({ swarmId: "..." })
+# Lint
+npm run lint
 \`\`\`
 
-## 🎯 Concurrent Execution Examples
-
-### ✅ CORRECT WORKFLOW: MCP Coordinates, Claude Code Executes
+- ALWAYS run tests after making code changes
+- ALWAYS verify build succeeds before committing`;
+}
+function securitySection() {
+    return `## Security Protocol
 
-\`\`\`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"
-\`\`\`
+- NEVER hardcode API keys, secrets, or credentials in source files
+- NEVER commit .env files or any file containing secrets
+- Always validate all user input at system boundaries using Zod schemas
+- Always sanitize file paths to prevent directory traversal attacks
+- Always use parameterized queries — never concatenate SQL strings
+- Run security audit after any authentication or authorization changes
 
-### ❌ 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!
+### Security Scanning
+\`\`\`bash
+npx @claude-flow/cli@latest security scan --depth full
+npx @claude-flow/cli@latest security audit --report
+npx @claude-flow/cli@latest security cve --check
 \`\`\`
 
-## 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 |
+### Security Agents
+- \`security-architect\` — threat modeling, architecture review
+- \`security-auditor\` — code audit, vulnerability detection
+- Use agent routing code 9 (hierarchical/specialized) for security tasks`;
+}
+function performanceSection() {
+    return `## Performance Optimization Protocol
 
-### Essential Hook Commands
+- Always run benchmarks before and after performance changes
+- Always profile before optimizing — never guess at bottlenecks
+- Prefer algorithmic improvements over micro-optimizations
+- Keep HNSW search within 150x-12,500x faster target
+- Keep memory reduction within 50-75% target with quantization
 
+### Performance Tooling
 \`\`\`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
-
-# 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]"
-
-# Intelligence routing
-npx claude-flow@v3alpha hooks route --task "[task]" --include-explanation
-npx claude-flow@v3alpha hooks explain --topic "[topic]" --depth comprehensive
-
-# 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
-
-# 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
-
-# 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
-
-# Learning stats & attention
-npx claude-flow@v3alpha hooks intelligence stats
-npx claude-flow@v3alpha hooks intelligence attention --focus "[task]"
+npx @claude-flow/cli@latest performance benchmark --suite all
+npx @claude-flow/cli@latest performance profile --target "[component]"
+npx @claude-flow/cli@latest performance metrics --format table
 \`\`\`
 
-### Intelligence System (RuVector)
+### Performance Agents
+- \`performance-engineer\` — profiling, benchmarking, optimization
+- \`perf-analyzer\` — bottleneck detection, analysis
+- Use agent routing code 7 (hierarchical/specialized) for performance tasks`;
+}
+function intelligenceSystem() {
+    return `## 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
+- **SONA**: Self-Optimizing Neural Architecture (<0.05ms adaptation)
+- **HNSW**: 150x-12,500x faster pattern search
 - **EWC++**: Elastic Weight Consolidation (prevents forgetting)
 - **Flash Attention**: 2.49x-7.47x speedup
 
@@ -503,124 +325,162 @@ 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++
-
-### 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"] }
-    ]
-  }
+4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++`;
 }
-\`\`\`
-
-### Agent Coordination via Hooks
+function envVars() {
+    return `## Environment Variables
 
-Every spawned agent should use hooks for coordination:
-
-\`\`\`javascript
-// In agent prompt instructions
-Task("Coder", \`
-  BEFORE starting: npx claude-flow@v3alpha hooks pre-task --description "Implement feature X"
-
-  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]"
+\`\`\`bash
+CLAUDE_FLOW_CONFIG=./claude-flow.config.json
+CLAUDE_FLOW_LOG_LEVEL=info
+ANTHROPIC_API_KEY=sk-ant-...
+CLAUDE_FLOW_MEMORY_BACKEND=hybrid
+CLAUDE_FLOW_MEMORY_PATH=./data/memory
+\`\`\``;
+}
+function setupAndBoundary() {
+    return `## Quick Setup
 
-  AFTER completing: npx claude-flow@v3alpha hooks post-task --success true
-\`, "coder")
+\`\`\`bash
+claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
+npx @claude-flow/cli@latest daemon start
+npx @claude-flow/cli@latest doctor --fix
 \`\`\`
 
-## Advanced Features (V3)
-
-- 🚀 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
+## Claude Code vs CLI Tools
 
-## Integration Tips
-
-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
+- Claude Code's Task tool handles ALL execution: agents, file ops, code generation, git
+- CLI tools handle coordination via Bash: swarm init, memory, hooks, routing
+- NEVER use CLI tools as a substitute for Task tool agents
 
 ## Support
 
 - Documentation: https://github.com/ruvnet/claude-flow
-- Issues: https://github.com/ruvnet/claude-flow/issues
-
----
-
-Remember: **Claude Flow coordinates, Claude Code creates!**
-
-# important-instruction-reminders
-Do what has been asked; nothing more, nothing less.
-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.
-`;
+- Issues: https://github.com/ruvnet/claude-flow/issues`;
+}
+// --- Template Composers ---
+/**
+ * Template section map — defines which sections are included per template.
+ */
+const TEMPLATE_SECTIONS = {
+    minimal: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        (_opts) => securityRulesLight(),
+        concurrencyRules,
+        (_opts) => antiDriftConfig(),
+        executionRules,
+        (_opts) => cliCommandsTable(),
+        (_opts) => setupAndBoundary(),
+    ],
+    standard: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        (_opts) => securityRulesLight(),
+        concurrencyRules,
+        (_opts) => swarmOrchestration(),
+        (_opts) => antiDriftConfig(),
+        executionRules,
+        (_opts) => cliCommandsTable(),
+        (_opts) => agentTypes(),
+        (_opts) => memoryCommands(),
+        (_opts) => setupAndBoundary(),
+    ],
+    full: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        (_opts) => securityRulesLight(),
+        concurrencyRules,
+        (_opts) => swarmOrchestration(),
+        (_opts) => antiDriftConfig(),
+        (_opts) => autoStartProtocol(),
+        executionRules,
+        (_opts) => cliCommandsTable(),
+        (_opts) => agentTypes(),
+        (_opts) => hooksSystem(),
+        (_opts) => learningProtocol(),
+        (_opts) => memoryCommands(),
+        (_opts) => intelligenceSystem(),
+        (_opts) => envVars(),
+        (_opts) => setupAndBoundary(),
+    ],
+    security: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        concurrencyRules,
+        (_opts) => swarmOrchestration(),
+        (_opts) => antiDriftConfig(),
+        executionRules,
+        (_opts) => securitySection(),
+        (_opts) => cliCommandsTable(),
+        (_opts) => agentTypes(),
+        (_opts) => memoryCommands(),
+        (_opts) => setupAndBoundary(),
+    ],
+    performance: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        (_opts) => securityRulesLight(),
+        concurrencyRules,
+        (_opts) => swarmOrchestration(),
+        (_opts) => antiDriftConfig(),
+        executionRules,
+        (_opts) => performanceSection(),
+        (_opts) => cliCommandsTable(),
+        (_opts) => agentTypes(),
+        (_opts) => memoryCommands(),
+        (_opts) => intelligenceSystem(),
+        (_opts) => setupAndBoundary(),
+    ],
+    solo: [
+        behavioralRules,
+        fileOrganization,
+        projectArchitecture,
+        (_opts) => buildAndTest(),
+        (_opts) => securityRulesLight(),
+        concurrencyRules,
+        executionRules,
+        (_opts) => cliCommandsTable(),
+        (_opts) => memoryCommands(),
+        (_opts) => setupAndBoundary(),
+    ],
+};
+// --- Public API ---
+/**
+ * Generate CLAUDE.md content based on init options and template.
+ * Template is determined by: options.runtime.claudeMdTemplate > explicit param > 'standard'
+ */
+export function generateClaudeMd(options, template) {
+    const tmpl = template ?? options.runtime.claudeMdTemplate ?? 'standard';
+    const sections = TEMPLATE_SECTIONS[tmpl] ?? TEMPLATE_SECTIONS.standard;
+    const header = `# Claude Code Configuration - Claude Flow V3\n`;
+    const body = sections.map(fn => fn(options)).join('\n\n');
+    return `${header}\n${body}\n`;
 }
 /**
- * Generate minimal CLAUDE.md content
+ * Generate minimal CLAUDE.md content (backward-compatible alias).
  */
 export function generateMinimalClaudeMd(options) {
-    return `# Claude Code Configuration
-
-## Quick Reference
-
-- **Topology**: ${options.runtime.topology}
-- **Max Agents**: ${options.runtime.maxAgents}
-- **Memory**: ${options.runtime.memoryBackend}
-
-## 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
-
-## Agent Execution Pattern
-
-\`\`\`javascript
-// Single message with parallel agents
-Task("Researcher", "Analyze requirements...", "researcher")
-Task("Coder", "Implement features...", "coder")
-Task("Tester", "Write tests...", "tester")
-\`\`\`
-
-## MCP Setup
-
-\`\`\`bash
-claude mcp add claude-flow npx claude-flow@v3alpha mcp start
-\`\`\`
-
----
-Remember: **Claude Flow coordinates, Claude Code creates!**
-`;
+    return generateClaudeMd(options, 'minimal');
 }
+/** Available template names for CLI wizard */
+export const CLAUDE_MD_TEMPLATES = [
+    { name: 'minimal', description: 'Quick start — behavioral rules, anti-drift config, CLI reference (~120 lines)' },
+    { name: 'standard', description: 'Recommended — swarm orchestration, agents, memory commands (~250 lines)' },
+    { name: 'full', description: 'Everything — hooks, learning protocol, intelligence system (~400 lines)' },
+    { name: 'security', description: 'Security-focused — adds security scanning, audit protocols, CVE checks' },
+    { name: 'performance', description: 'Performance-focused — adds benchmarking, profiling, optimization protocols' },
+    { name: 'solo', description: 'Solo developer — no swarm, simple agent usage, memory commands (~150 lines)' },
+];
 export default generateClaudeMd;
 //# sourceMappingURL=claudemd-generator.js.map