@claude-flow/cli 3.6.9 → 3.6.11

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

@@ -1,545 +1,363 @@
 /**
  * CLAUDE.md Generator
- * Generates enforceable, analyzer-optimized Claude Code configuration
- * with template variants for different usage patterns.
+ * Generates lean, enforceable Claude Code configuration optimized for token efficiency.
  *
  * Templates: minimal | standard | full | security | performance | solo
- * All templates use bullet-format rules with imperative keywords for enforceability.
+ * All templates use imperative rules and agent comms-first coordination.
  */
-// --- Section Generators (each returns enforceable markdown) ---
+// --- Section Generators ---
 function behavioralRules() {
-    return `## Behavioral Rules (Always Enforced)
+    return `## Rules
 
 - 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
+- NEVER create files unless absolutely necessary — prefer editing existing files
+- NEVER create documentation files unless explicitly requested
+- NEVER save working files or tests to root — use \`/src\`, \`/tests\`, \`/docs\`, \`/config\`, \`/scripts\`
 - 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`;
+- NEVER commit secrets, credentials, or .env files
+- Keep files under 500 lines
+- Validate input at system boundaries`;
 }
-function projectArchitecture(options) {
-    return `## Project Architecture
+function agentComms() {
+    return `## Agent Comms (SendMessage-First Coordination)
 
-- 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
+Named agents coordinate via \`SendMessage\`, not polling or shared state.
 
-### Project Config
+\`\`\`
+Lead (you) ←→ architect ←→ developer ←→ tester ←→ reviewer
+              (named agents message each other directly)
+\`\`\`
 
-- **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 Agent tool for spawning agents, not just MCP
-- ALWAYS spawn ALL agents in ONE message with full instructions via Agent tool
-- ALWAYS batch ALL file reads/writes/edits in ONE message
-- ALWAYS batch ALL Bash commands in ONE message`;
-}
-function swarmOrchestration() {
-    return `## Swarm Orchestration
+### Spawning a Coordinated Team
 
-- MUST initialize the swarm using CLI tools when starting complex tasks
-- MUST spawn concurrent agents using Claude Code's Agent tool
-- Never use CLI tools alone for execution — Agent tool agents do the actual work
-- MUST call CLI tools AND Agent tool in ONE message for complex work
+\`\`\`javascript
+// ALL agents in ONE message, each knows WHO to message next
+Agent({ prompt: "Research the codebase. SendMessage findings to 'architect'.",
+  subagent_type: "researcher", name: "researcher", run_in_background: true })
+Agent({ prompt: "Wait for 'researcher'. Design solution. SendMessage to 'coder'.",
+  subagent_type: "system-architect", name: "architect", run_in_background: true })
+Agent({ prompt: "Wait for 'architect'. Implement it. SendMessage to 'tester'.",
+  subagent_type: "coder", name: "coder", run_in_background: true })
+Agent({ prompt: "Wait for 'coder'. Write tests. SendMessage results to 'reviewer'.",
+  subagent_type: "tester", name: "tester", run_in_background: true })
+Agent({ prompt: "Wait for 'tester'. Review code quality and security.",
+  subagent_type: "reviewer", name: "reviewer", run_in_background: true })
+
+// Kick off the pipeline
+SendMessage({ to: "researcher", summary: "Start", message: "[task context]" })
+\`\`\`
+
+### Patterns
 
-### 3-Tier Model Routing (ADR-026)
+| Pattern | Flow | Use When |
+|---------|------|----------|
+| **Pipeline** | A → B → C → D | Sequential dependencies (feature dev) |
+| **Fan-out** | Lead → A, B, C → Lead | Independent parallel work (research) |
+| **Supervisor** | Lead ↔ workers | Ongoing coordination (complex refactor) |
 
-| 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%) |
+### Rules
 
-- For Tier 1 simple transforms, use Edit tool directly — no LLM agent needed`;
+- ALWAYS name agents — \`name: "role"\` makes them addressable
+- ALWAYS include comms instructions in prompts — who to message, what to send
+- Spawn ALL agents in ONE message with \`run_in_background: true\`
+- After spawning: STOP, tell user what's running, wait for results
+- NEVER poll status — agents message back or complete automatically`;
 }
-function antiDriftConfig() {
-    return `## Swarm Configuration & Anti-Drift
+function swarmConfig(options) {
+    return `## Swarm & Routing
 
-- 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
+### Config
+- **Topology**: ${options.runtime.topology} (anti-drift)
+- **Max Agents**: ${options.runtime.maxAgents}
+- **Memory**: ${options.runtime.memoryBackend}
+- **HNSW**: ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'}
+- **Neural**: ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'}
 
 \`\`\`bash
 npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
-\`\`\``;
-}
-function autoStartProtocol() {
-    return `## Swarm Protocols & Routing
-
-### Auto-Start Swarm Protocol
-
-When the user requests a complex task, spawn agents in background and WAIT:
-
-\`\`\`javascript
-// 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
-Agent("Research requirements", "Analyze codebase patterns and store findings in memory", {subagent_type: "researcher", run_in_background: true})
-Agent("Design architecture", "Design architecture based on research", {subagent_type: "system-architect", run_in_background: true})
-Agent("Implement solution", "Implement the solution following the design", {subagent_type: "coder", run_in_background: true})
-Agent("Write tests", "Write comprehensive tests for the implementation", {subagent_type: "tester", run_in_background: true})
-Agent("Review code quality", "Review code quality, security, and best practices", {subagent_type: "reviewer", run_in_background: true})
 \`\`\`
 
 ### Agent Routing
 
-| 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 |
-
-### Task Complexity Detection
-
-- 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 tool calls
-- ALWAYS put ALL Agent calls in ONE message for parallel execution
-- After spawning, STOP — do NOT add more tool calls or check status
-- Never poll agent status repeatedly — trust agents to return
-- When agent results arrive, review ALL results before proceeding`;
+| Task | Agents | Topology |
+|------|--------|----------|
+| Bug Fix | researcher, coder, tester | hierarchical |
+| Feature | architect, coder, tester, reviewer | hierarchical |
+| Refactor | architect, coder, reviewer | hierarchical |
+| Performance | perf-engineer, coder | hierarchical |
+| Security | security-architect, auditor | hierarchical |
+
+### When to Swarm
+- **YES**: 3+ files, new features, cross-module refactoring, API changes, security, performance
+- **NO**: single file edits, 1-2 line fixes, docs updates, config changes, questions
+
+### 3-Tier Model Routing
+
+| Tier | Handler | Use Cases |
+|------|---------|-----------|
+| 1 | Agent Booster (WASM) | Simple transforms — skip LLM, use Edit directly |
+| 2 | Haiku | Simple tasks, low complexity |
+| 3 | Sonnet/Opus | Architecture, security, complex reasoning |`;
 }
-function cliCommandsTable() {
-    return `## V3 CLI Commands
-
-### Core Commands
-
-| 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 |
-
-### Quick CLI Examples
+function memoryAndLearning() {
+    return `## Memory & Learning
 
+### Before Any Task
 \`\`\`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 (16 Roles + Custom)
+npx @claude-flow/cli@latest memory search --query "[task keywords]" --namespace patterns
+npx @claude-flow/cli@latest hooks route --task "[task description]"
+\`\`\`
 
-### Core Development
-\`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
+### After Success
+\`\`\`bash
+npx @claude-flow/cli@latest memory store --namespace patterns --key "[name]" --value "[what worked]"
+npx @claude-flow/cli@latest hooks post-task --task-id "[id]" --success true --store-results true
+\`\`\`
 
-### Specialized
-\`security-architect\`, \`security-auditor\`, \`memory-specialist\`, \`performance-engineer\`
+### MCP Tools (use \`ToolSearch("keyword")\` to discover)
 
-### Coordination
-\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`
+| Category | Key Tools |
+|----------|-----------|
+| **Memory** | \`memory_store\`, \`memory_search\`, \`memory_search_unified\` |
+| **Bridge** | \`memory_import_claude\`, \`memory_bridge_status\` |
+| **Swarm** | \`swarm_init\`, \`swarm_status\`, \`swarm_health\` |
+| **Agents** | \`agent_spawn\`, \`agent_list\`, \`agent_status\` |
+| **Hooks** | \`hooks_route\`, \`hooks_post-task\`, \`hooks_worker-dispatch\` |
+| **Security** | \`aidefence_scan\`, \`aidefence_is_safe\`, \`aidefence_has_pii\` |
+| **Hive-Mind** | \`hive-mind_init\`, \`hive-mind_consensus\`, \`hive-mind_spawn\` |
 
-### GitHub & Repository
-\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`
+### Background Workers
 
-Any string can be used as a custom agent type — these are the typed roles with specialized behavior.`;
-}
-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 |
+| Worker | When |
+|--------|------|
+| \`audit\` | After security changes |
+| \`optimize\` | After performance work |
+| \`testgaps\` | After adding features |
+| \`map\` | Every 5+ file changes |
+| \`document\` | After API changes |
 
 \`\`\`bash
-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
+function agentTypes() {
+    return `## Agents
 
-### Before Starting Any Task
-\`\`\`bash
-npx @claude-flow/cli@latest memory search --query "[task keywords]" --namespace patterns
-npx @claude-flow/cli@latest hooks route --task "[task description]"
-\`\`\`
+**Core**: \`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
+**Architecture**: \`system-architect\`, \`backend-dev\`, \`mobile-dev\`
+**Security**: \`security-architect\`, \`security-auditor\`
+**Performance**: \`performance-engineer\`, \`perf-analyzer\`
+**Coordination**: \`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`
+**GitHub**: \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`
+
+Any string works as a custom agent type.`;
+}
+function cliQuickRef() {
+    return `## CLI Quick Reference
 
-### After Completing Any Task Successfully
 \`\`\`bash
-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
+npx @claude-flow/cli@latest init --wizard           # Setup
+npx @claude-flow/cli@latest swarm init --v3-mode     # Start swarm
+npx @claude-flow/cli@latest memory search --query "" # Vector search
+npx @claude-flow/cli@latest hooks route --task ""    # Route to agent
+npx @claude-flow/cli@latest doctor --fix             # Diagnostics
+npx @claude-flow/cli@latest security scan            # Security scan
+npx @claude-flow/cli@latest performance benchmark    # Benchmarks
 \`\`\`
 
-- ALWAYS check memory before starting new features, debugging, or refactoring
-- ALWAYS store patterns in memory after solving bugs, completing features, or finding optimizations`;
+26 commands, 140+ subcommands. Use \`--help\` on any command for details.`;
 }
-function memoryCommands() {
-    return `## Memory & Vector Search
-
-### MCP Tools (use via ToolSearch to discover)
-
-| Tool | Description |
-|------|-------------|
-| \`memory_store\` | Store value with ONNX 384-dim vector embedding |
-| \`memory_search\` | Semantic vector search by query |
-| \`memory_retrieve\` | Get entry by key |
-| \`memory_list\` | List entries in namespace |
-| \`memory_delete\` | Delete entry |
-| \`memory_import_claude\` | Import Claude Code memories into AgentDB (allProjects=true for all) |
-| \`memory_search_unified\` | Search across ALL namespaces (Claude + AgentDB + patterns) |
-| \`memory_bridge_status\` | Show bridge health, vectors, SONA, intelligence |
-
-### CLI Commands
+function setupAndBoundary() {
+    return `## Setup
 
 \`\`\`bash
-# Store with vector embedding
-npx @claude-flow/cli@latest memory store --key "pattern-auth" --value "JWT with refresh" --namespace patterns
-
-# Semantic search
-npx @claude-flow/cli@latest memory search --query "authentication patterns"
-
-# Import all Claude Code memories into AgentDB
-node .claude/helpers/auto-memory-hook.mjs import-all
+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
 \`\`\`
 
-### Claude Code ↔ AgentDB Bridge
-
-Claude Code auto-memory files (\`~/.claude/projects/*/memory/*.md\`) are automatically imported into AgentDB with ONNX vector embeddings on session start. Use \`memory_search_unified\` to search across both stores.`;
-}
-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`;
+**Agent tool** handles execution (agents, files, code, git). **MCP tools** handle coordination (swarm, memory, hooks). **CLI** is the same via Bash.`;
 }
 function buildAndTest() {
     return `## Build & Test
 
-\`\`\`bash
-# Build
-npm run build
-
-# Test
-npm test
+- ALWAYS run tests after code changes
+- ALWAYS verify build succeeds before committing
 
-# Lint
-npm run lint
-\`\`\`
-
-- ALWAYS run tests after making code changes
-- ALWAYS verify build succeeds before committing`;
+\`\`\`bash
+npm run build && npm test
+\`\`\``;
 }
 function securitySection() {
-    return `## Security Protocol
+    return `## Security
 
-- 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
+- NEVER hardcode secrets in source — use environment variables
+- Always validate input at boundaries (Zod schemas)
+- Always sanitize file paths (prevent traversal)
+- Always use parameterized queries (prevent injection)
 
-### 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
 \`\`\`
 
-### Security Agents
-- \`security-architect\` — threat modeling, architecture review
-- \`security-auditor\` — code audit, vulnerability detection
-- Use agent routing code 9 (hierarchical/specialized) for security tasks`;
+Agents: \`security-architect\` (threat modeling), \`security-auditor\` (vulnerability detection)`;
 }
 function performanceSection() {
-    return `## Performance Optimization Protocol
+    return `## Performance
 
-- Always run benchmarks before and after performance changes
-- Always profile before optimizing — never guess at bottlenecks
-- Prefer algorithmic improvements over micro-optimizations
-- Use DiskANN or HNSW for vector search (auto-selected by dataset size)
-- Use Int8 quantization for ~4x memory reduction when needed
+- Always benchmark before AND after optimization
+- Always profile before optimizing — never guess bottlenecks
+- Use HNSW/DiskANN for vector search, Int8 quantization for memory reduction
 
-### Performance Tooling
 \`\`\`bash
 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
 \`\`\`
 
-### Performance Agents
-- \`performance-engineer\` — profiling, benchmarking, optimization
-- \`perf-analyzer\` — bottleneck detection, analysis
-- Use agent routing code 7 (hierarchical/specialized) for performance tasks`;
+Agents: \`performance-engineer\` (profiling), \`perf-analyzer\` (bottleneck detection)`;
 }
-function intelligenceSystem() {
-    return `## Intelligence System
-
-- **SONA**: Self-Optimizing Pattern Learning (sub-millisecond pattern matching)
-- **HNSW/DiskANN**: HNSW-indexed vector search with DiskANN SSD-friendly fallback
-- **ONNX Embeddings**: all-MiniLM-L6-v2, 384 dimensions, real neural vectors
-- **ReasoningBank**: Pattern storage with file persistence
-
-The learning pipeline:
-1. **RETRIEVE** — Fetch relevant patterns via HNSW/DiskANN vector search
-2. **JUDGE** — Evaluate with verdicts (success/failure) from post-task hooks
-3. **DISTILL** — Extract key learnings, store as patterns with embeddings
-4. **CONSOLIDATE** — Persist patterns to disk across sessions`;
-}
-function envVars() {
-    return `## Environment Variables
+function hooksRef() {
+    return `## Hooks
+
+| Hook | Purpose |
+|------|---------|
+| \`pre-task\` / \`post-task\` | Task lifecycle + learning |
+| \`pre-edit\` / \`post-edit\` | File editing + neural training |
+| \`session-start\` / \`session-end\` | Session persistence |
+| \`route\` | Route to optimal agent |
+| \`intelligence\` | Pattern learning (SONA) |
+| \`worker\` | Background worker dispatch |
 
 \`\`\`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
+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 session-start --session-id "[id]"
+npx @claude-flow/cli@latest hooks route --task "[task]"
+npx @claude-flow/cli@latest hooks worker dispatch --trigger audit
 \`\`\``;
 }
-function mcpToolDiscovery() {
-    return `## Key MCP Tools (314 available — use ToolSearch to discover)
-
-### Most Used Tools
-
-| Category | Tools | What They Do |
-|----------|-------|-------------|
-| **Memory** | \`memory_store\`, \`memory_search\`, \`memory_search_unified\` | Store/search with ONNX vector embeddings |
-| **Claude Bridge** | \`memory_import_claude\`, \`memory_bridge_status\` | Import Claude memories into AgentDB |
-| **Swarm** | \`swarm_init\`, \`swarm_status\`, \`swarm_health\` | Multi-agent coordination |
-| **Agents** | \`agent_spawn\`, \`agent_list\`, \`agent_status\` | Agent lifecycle |
-| **Hive-Mind** | \`hive-mind_init\`, \`hive-mind_spawn\`, \`hive-mind_consensus\` | Byzantine/Raft consensus |
-| **Hooks** | \`hooks_route\`, \`hooks_session-start\`, \`hooks_post-task\` | Task routing + learning |
-| **Workers** | \`hooks_worker-list\`, \`hooks_worker-dispatch\` | 12 background workers |
-| **Security** | \`aidefence_scan\`, \`aidefence_is_safe\` | Prompt injection detection |
-| **Intelligence** | \`hooks_intelligence\`, \`neural_status\` | Pattern learning + SONA |
-
-### Swarm Capabilities
-
-- **Topologies**: hierarchical (anti-drift), mesh, ring, star, adaptive
-- **Consensus**: Raft (leader-based), Byzantine (PBFT), Gossip (eventual)
-- **Hive-Mind**: Queen-led coordination with spawn, broadcast, consensus voting, shared memory
-- **12 Background Workers**: audit, optimize, testgaps, map, deepdive, document, refactor, benchmark, ultralearn, consolidate, predict, preload
-
-### Memory Capabilities
-
-- **ONNX Embeddings**: all-MiniLM-L6-v2, 384 dimensions — real neural vectors
-- **DiskANN**: SSD-friendly vector search (8,000x faster insert than HNSW, perfect recall at 1K)
-- **sql.js**: Cross-platform SQLite (WASM, no native compilation)
-- **Claude Code Bridge**: Auto-imports MEMORY.md files into AgentDB on session start
-- **Unified Search**: \`memory_search_unified\` searches Claude memories + AgentDB + patterns
-- **SONA Learning**: Trajectory recording → pattern extraction → file persistence
-
-### How to Discover Tools
-
-Use ToolSearch to find specific tools:
-\`\`\`
-ToolSearch("memory search")     → memory_store, memory_search, memory_search_unified
-ToolSearch("swarm")             → swarm_init, swarm_status, swarm_health, swarm_shutdown
-ToolSearch("hive consensus")    → hive-mind_consensus, hive-mind_status
-ToolSearch("+aidefence")        → aidefence_scan, aidefence_is_safe, aidefence_has_pii
-\`\`\``;
+function intelligenceSystem() {
+    return `## Intelligence (SONA + HNSW)
+
+Pipeline: **RETRIEVE** (vector search) → **JUDGE** (success/failure) → **DISTILL** (extract patterns) → **CONSOLIDATE** (persist)
+
+- **ONNX Embeddings**: all-MiniLM-L6-v2, 384-dim
+- **HNSW/DiskANN**: 150x-12,500x faster search
+- **SONA**: Sub-millisecond pattern adaptation
+- **Claude Bridge**: Auto-imports \`~/.claude/projects/*/memory/*.md\` into AgentDB`;
 }
-function setupAndBoundary() {
-    return `## Quick Setup
+function federationRef() {
+    return `## Federation
+
+Cross-installation agent collaboration with zero-trust security.
 
 \`\`\`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
+npx @claude-flow/cli@latest federation init
+npx @claude-flow/cli@latest federation join wss://peer:8443
+npx @claude-flow/cli@latest federation send --to peer --type task-request --message "..."
+npx @claude-flow/cli@latest federation status
 \`\`\`
 
-## Claude Code vs MCP Tools
-
-- **Claude Code Agent tool** handles execution: agents, file ops, code generation, git
-- **MCP tools** (via ToolSearch) handle coordination: swarm, memory, hooks, routing, hive-mind
-- **CLI commands** (via Bash) are the same tools with terminal output
-- Use \`ToolSearch("keyword")\` to discover available MCP tools
-
-## Support
+- 5-tier trust: UNTRUSTED → VERIFIED → ATTESTED → TRUSTED → PRIVILEGED
+- PII pipeline: 14 types auto-stripped before data leaves your node
+- mTLS + ed25519 handshake, HMAC-signed envelopes
+- Compliance: HIPAA, SOC2, GDPR audit modes`;
+}
+function envVars() {
+    return `## Environment
 
-- Documentation: https://github.com/ruvnet/ruflo
-- Issues: https://github.com/ruvnet/ruflo/issues`;
+\`\`\`bash
+CLAUDE_FLOW_CONFIG=./claude-flow.config.json
+CLAUDE_FLOW_LOG_LEVEL=info
+CLAUDE_FLOW_MEMORY_BACKEND=hybrid
+CLAUDE_FLOW_MEMORY_PATH=./data/memory
+\`\`\``;
 }
 // --- Template Composers ---
-/**
- * Template section map — defines which sections are included per template.
- */
 const TEMPLATE_SECTIONS = {
     minimal: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
+        (_opts) => agentComms(),
+        swarmConfig,
         (_opts) => buildAndTest(),
-        (_opts) => securityRulesLight(),
-        concurrencyRules,
-        (_opts) => antiDriftConfig(),
-        executionRules,
-        (_opts) => cliCommandsTable(),
+        (_opts) => cliQuickRef(),
         (_opts) => setupAndBoundary(),
     ],
     standard: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
-        (_opts) => buildAndTest(),
-        (_opts) => securityRulesLight(),
-        concurrencyRules,
-        (_opts) => swarmOrchestration(),
-        (_opts) => antiDriftConfig(),
-        executionRules,
-        (_opts) => cliCommandsTable(),
+        (_opts) => agentComms(),
+        swarmConfig,
+        (_opts) => memoryAndLearning(),
         (_opts) => agentTypes(),
-        (_opts) => memoryCommands(),
-        (_opts) => mcpToolDiscovery(),
+        (_opts) => buildAndTest(),
+        (_opts) => cliQuickRef(),
         (_opts) => setupAndBoundary(),
     ],
     full: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
-        (_opts) => buildAndTest(),
-        (_opts) => securityRulesLight(),
-        concurrencyRules,
-        (_opts) => swarmOrchestration(),
-        (_opts) => antiDriftConfig(),
-        (_opts) => autoStartProtocol(),
-        executionRules,
-        (_opts) => cliCommandsTable(),
+        (_opts) => agentComms(),
+        swarmConfig,
+        (_opts) => memoryAndLearning(),
         (_opts) => agentTypes(),
-        (_opts) => hooksSystem(),
-        (_opts) => learningProtocol(),
-        (_opts) => memoryCommands(),
-        (_opts) => mcpToolDiscovery(),
+        (_opts) => hooksRef(),
         (_opts) => intelligenceSystem(),
+        (_opts) => federationRef(),
+        (_opts) => buildAndTest(),
         (_opts) => envVars(),
+        (_opts) => cliQuickRef(),
         (_opts) => setupAndBoundary(),
     ],
     security: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
-        (_opts) => buildAndTest(),
-        concurrencyRules,
-        (_opts) => swarmOrchestration(),
-        (_opts) => antiDriftConfig(),
-        executionRules,
+        (_opts) => agentComms(),
+        swarmConfig,
         (_opts) => securitySection(),
-        (_opts) => cliCommandsTable(),
+        (_opts) => memoryAndLearning(),
         (_opts) => agentTypes(),
-        (_opts) => memoryCommands(),
+        (_opts) => buildAndTest(),
+        (_opts) => cliQuickRef(),
         (_opts) => setupAndBoundary(),
     ],
     performance: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
-        (_opts) => buildAndTest(),
-        (_opts) => securityRulesLight(),
-        concurrencyRules,
-        (_opts) => swarmOrchestration(),
-        (_opts) => antiDriftConfig(),
-        executionRules,
+        (_opts) => agentComms(),
+        swarmConfig,
         (_opts) => performanceSection(),
-        (_opts) => cliCommandsTable(),
+        (_opts) => memoryAndLearning(),
         (_opts) => agentTypes(),
-        (_opts) => memoryCommands(),
         (_opts) => intelligenceSystem(),
+        (_opts) => buildAndTest(),
+        (_opts) => cliQuickRef(),
         (_opts) => setupAndBoundary(),
     ],
     solo: [
         behavioralRules,
-        fileOrganization,
-        projectArchitecture,
+        (_opts) => agentComms(),
+        (_opts) => memoryAndLearning(),
         (_opts) => buildAndTest(),
-        (_opts) => securityRulesLight(),
-        concurrencyRules,
-        executionRules,
-        (_opts) => cliCommandsTable(),
-        (_opts) => memoryCommands(),
+        (_opts) => cliQuickRef(),
         (_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 - RuFlo V3\n`;
+    const header = `# Ruflo — Claude Code Configuration\n`;
     const body = sections.map(fn => fn(options)).join('\n\n');
     return `${header}\n${body}\n`;
 }
-/**
- * Generate minimal CLAUDE.md content (backward-compatible alias).
- */
 export function generateMinimalClaudeMd(options) {
     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)' },
+    { name: 'minimal', description: 'Lean start — rules, agent comms, swarm config, CLI ref (~80 lines)' },
+    { name: 'standard', description: 'Recommended — adds memory, learning, agent types (~140 lines)' },
+    { name: 'full', description: 'Everything — hooks, intelligence, federation (~220 lines)' },
+    { name: 'security', description: 'Security-focused — adds scanning, audit, threat agents' },
+    { name: 'performance', description: 'Performance-focused — adds benchmarking, profiling, SONA' },
+    { name: 'solo', description: 'Solo developer — comms, memory, no swarm (~90 lines)' },
 ];
 export default generateClaudeMd;
 //# sourceMappingURL=claudemd-generator.js.map