snow-flow 1.4.25 → 1.4.26

package/CLAUDE.md

@@ -1,4 +1,4 @@
-# Claude Code Configuration - SPARC Development Environment (Batchtools Optimized)
+# Claude Code Configuration - Snow-Flow Development Environment
 
 ## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
 
@@ -14,1042 +14,185 @@
 
 ### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
 
-**Examples of CORRECT concurrent execution:**
-
+**✅ CORRECT: Everything in ONE message**
 ```javascript
-// ✅ CORRECT: Everything in ONE message
 [Single Message]:
   - TodoWrite { todos: [10+ todos with all statuses/priorities] }
   - Task("Agent 1 with full instructions and hooks")
   - Task("Agent 2 with full instructions and hooks")
-  - Task("Agent 3 with full instructions and hooks")
-  - Read("file1.js")
-  - Read("file2.js")
-  - Write("output1.js", content)
-  - Write("output2.js", content)
-  - Bash("npm install")
-  - Bash("npm test")
-  - Bash("npm run build")
+  - Multiple Read/Write operations
+  - Multiple Bash commands
 ```
 
-**Examples of WRONG sequential execution:**
-
+**❌ WRONG: Multiple messages (NEVER DO THIS)**
 ```javascript
-// ❌ WRONG: Multiple messages (NEVER DO THIS)
 Message 1: TodoWrite { todos: [single todo] }
 Message 2: Task("Agent 1")
-Message 3: Task("Agent 2")
-Message 4: Read("file1.js")
-Message 5: Write("output1.js")
-Message 6: Bash("npm install")
-// This is 6x slower and breaks coordination!
-```
-
-### 🎯 CONCURRENT EXECUTION CHECKLIST:
-
-Before sending ANY message, ask yourself:
-
-- ✅ Are ALL related TodoWrite operations batched together?
-- ✅ Are ALL Task spawning operations in ONE message?
-- ✅ Are ALL file operations (Read/Write/Edit) batched together?
-- ✅ Are ALL bash commands grouped in ONE message?
-- ✅ Are ALL memory operations concurrent?
-
-If ANY answer is "No", you MUST combine operations into a single message!
-
-## Project Overview
-
-This project combines the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with **Real ServiceNow Integration** for systematic Test-Driven Development with AI assistance.
-
-**🚀 Batchtools Optimization Enabled**: This configuration includes optimized prompts and parallel processing capabilities for improved performance and efficiency.
-
-## 🏔️ **SNOW-FLOW: COMPLETE MCP TOOLKIT**
-
-**Production-Ready ServiceNow Integration + AI Orchestration via Natural Language**
-
-Snow-Flow provides comprehensive MCP tools for ServiceNow integration and AI orchestration. All tools work directly with your ServiceNow instance using OAuth authentication and are accessible through the natural language swarm interface.
-
-### **🛠️ Complete Snow-Flow MCP Tools**
-
-#### **🐝 AI Swarm Orchestration** (4 tools working)
-- `swarm_init` - Initialize AI swarm coordination topology  
-- `agent_spawn` - Create specialized AI agents for different tasks
-- `memory_usage` - Persistent memory across sessions
-- `neural_status` - Neural network pattern effectiveness
-
-#### **📊 ServiceNow Operations** (12/15 tools working)
-- ✅ `snow_operational_metrics` - Retrieve operational metrics and analytics
-- ✅ `snow_user_lookup` - Analyze user information with groups and roles
-- ✅ `snow_query_incidents` - Advanced incident querying with filters
-- ✅ `snow_catalog_item_search` - Search catalog items with fuzzy matching
-- ✅ `snow_catalog_item_manager` - Manage service catalog items
-- ✅ `snow_test_flow_with_mock` - Test flows with mock data
-- ✅ `snow_link_catalog_to_flow` - Link catalog items to flows
-- ✅ `snow_cleanup_test_artifacts` - Clean test artifacts safely
-- ✅ `snow_create_user_group` - Create ServiceNow user groups
-- ✅ `snow_create_user` - Create ServiceNow users
-- ✅ `snow_assign_user_to_group` - Manage group memberships
-- ✅ `snow_list_group_members` - List group members
-- ⚠️ `snow_analyze_incident` - Incident analysis (needs verification)
-- ⚠️ `snow_auto_resolve_incident` - Auto incident resolution (needs verification)
-- ⚠️ `snow_query_requests` - Service request queries (needs verification)
-
-#### **🔧 Platform Development** (2/2 tools working)
-- ✅ `snow_discover_platform_tables` - Discover UI, script, policy tables
-- ✅ `snow_table_schema_discovery` - Comprehensive table schema analysis
-
-#### **🔗 Integration** (10+ tools)
-- ✅ `snow_discover_integration_endpoints` - Find REST/SOAP endpoints
-- `snow_create_rest_message` - Create REST Message endpoints
-- `snow_create_rest_method` - Create REST methods
-- `snow_create_transform_map` - Create Transform Maps
-- `snow_create_field_map` - Create Field Maps
-- `snow_create_import_set` - Create Import Set tables
-- `snow_create_web_service` - Create Web Services
-- `snow_create_email_config` - Create Email configurations
-- `snow_test_integration` - Test integration endpoints
-- `snow_discover_data_sources` - Discover data sources
-
-#### **📈 Reporting & Analytics** (12+ tools)
-- ✅ `snow_discover_reporting_tables` - Table discovery for reporting
-- ✅ `snow_analyze_data_quality` - Data quality assessment
-- `snow_create_report` - Create reports with dynamic discovery
-- `snow_create_dashboard` - Create dashboards
-- `snow_create_kpi` - Create KPIs
-- `snow_create_data_visualization` - Create data visualizations
-- `snow_create_performance_analytics` - Performance analytics
-- `snow_create_scheduled_report` - Scheduled reports
-- `snow_discover_report_fields` - Discover report fields
-- `snow_generate_insights` - Generate data insights
-- `snow_export_report_data` - Export report data
-
-#### **⚙️ Automation** (11+ tools)
-- ✅ `snow_discover_automation_jobs` - Find scheduled jobs, notifications, SLAs
-- ✅ `snow_discover_events` - Discover ServiceNow events
-- ✅ `snow_discover_schedules` - Find system schedules
-- `snow_create_scheduled_job` - Create scheduled jobs
-- `snow_create_event_rule` - Create event rules
-- `snow_create_notification` - Create notifications
-- `snow_create_sla_definition` - Create SLA definitions
-- `snow_create_escalation_rule` - Create escalation rules
-- `snow_create_workflow_activity` - Create workflow activities
-- `snow_test_scheduled_job` - Test scheduled job execution
-
-#### **🛡️ Security & Compliance** (12+ tools)
-- `snow_create_security_policy` - Create security policies
-- `snow_create_compliance_rule` - Create compliance rules
-- `snow_create_audit_rule` - Create audit rules
-- `snow_create_access_control` - Create access controls
-- `snow_create_data_policy` - Create data policies
-- `snow_create_vulnerability_scan` - Create vulnerability scans
-- `snow_discover_security_frameworks` - Discover frameworks
-- `snow_discover_security_policies` - Discover policies
-- `snow_run_compliance_scan` - Run compliance scans
-- `snow_audit_trail_analysis` - Analyze audit trails
-- `snow_security_risk_assessment` - Security risk assessment
-
-#### **📦 Update Set Management** (9+ tools)
-- ✅ `snow_update_set_current` - Get current update set
-- ✅ `snow_update_set_list` - List update sets
-- `snow_update_set_create` - Create new update sets
-- `snow_update_set_switch` - Switch update sets
-- `snow_update_set_complete` - Mark update sets complete
-- `snow_update_set_add_artifact` - Track artifacts
-- `snow_update_set_preview` - Preview changes
-- `snow_update_set_export` - Export update sets
-- `snow_ensure_active_update_set` - Ensure active session
-
-#### **🚀 Deployment & Development** (15+ tools)
-- ✅ `snow_preview_widget` - Preview widget rendering
-- ✅ `snow_validate_deployment` - Validate deployments
-- ⚠️ `snow_deploy` - Deploy artifacts (permission issues)
-- ⚠️ `snow_widget_test` - Test widgets (404 errors)
-- `snow_auth_diagnostics` - Authentication diagnostics
-- `snow_create_ui_page` - Create UI pages
-- `snow_create_script_include` - Create script includes
-- `snow_create_business_rule` - Create business rules
-- `snow_create_client_script` - Create client scripts
-- `snow_create_ui_policy` - Create UI policies
-- `snow_create_ui_action` - Create UI actions
-- `snow_rollback_deployment` - Rollback deployments
-- `snow_deployment_status` - Check deployment status
-- `snow_export_artifact` - Export artifacts
-- `snow_import_artifact` - Import artifacts
-
-### **🎯 Natural Language Interface**
-
-Access all 50+ tools through the swarm command:
-
-```bash
-# AI Orchestration
-snow-flow swarm "Initialize a development swarm with 5 agents to analyze my ServiceNow instance"
-
-# User and group management  
-snow-flow swarm "Create a new user group for incident managers and add users"
-
-# Advanced analytics
-snow-flow swarm "Create a performance dashboard for incident resolution metrics"
-
-# Integration setup
-snow-flow swarm "Set up REST integration with external system for data import"
-
-# Security analysis
-snow-flow swarm "Run comprehensive security scan and create compliance report"
-
-# Automation deployment
-snow-flow swarm "Create automated notification rules for high priority incidents"
+Message 3: Read("file1.js")
+// This is 3x slower and breaks coordination!
 ```
 
-### **📊 Tool Status Summary**
-
-- **✅ Working Tools**: 35+ tools (70% success rate)
-- **⚠️ Limited Tools**: 8 tools (permission/config issues)
-- **🔧 In Development**: 5+ tools (under development)
-
-### **🔧 Technical Details**
-
-- **OAuth Authentication** with ServiceNow instances
-- **50+ MCP tools** across 8 categories
-- **AI Swarm Orchestration** for complex workflows
-- **TypeScript implementation** with comprehensive error handling
-- **Real-time API integration** - no mock data or demos
-- **Natural language interface** for all operations
-
-## SPARC Development Commands
-
-### Core SPARC Commands
-
-- `npx snow-flow sparc modes`: List all available SPARC development modes
-- `npx snow-flow sparc run <mode> "<task>"`: Execute specific SPARC mode for a task
-- `npx snow-flow sparc tdd "<feature>"`: Run complete TDD workflow using SPARC methodology
-- `npx snow-flow sparc info <mode>`: Get detailed information about a specific mode
-
-### Batchtools Commands (Optimized)
-
-- `npx snow-flow sparc batch <modes> "<task>"`: Execute multiple SPARC modes in parallel
-- `npx snow-flow sparc pipeline "<task>"`: Execute full SPARC pipeline with parallel processing
-- `npx snow-flow sparc concurrent <mode> "<tasks-file>"`: Process multiple tasks concurrently
-
-### Standard Build Commands
-
+## Build Commands
 - `npm run build`: Build the project
-- `npm run test`: Run the test suite
-- `npm run lint`: Run linter and format checks
+- `npm run test`: Run the full test suite
+- `npm run lint`: Run ESLint and format checks
 - `npm run typecheck`: Run TypeScript type checking
-
-## SPARC Methodology Workflow (Batchtools Enhanced)
-
-### 1. Specification Phase (Parallel Analysis)
-
+- `./snow-flow --help`: Show all available commands
+
+## Snow-Flow Complete Command Reference
+
+### Core System Commands
+- `./snow-flow start [--ui] [--port 3000]`: Start orchestration system
+- `./snow-flow status`: Show comprehensive system status
+- `./snow-flow config <subcommand>`: Configuration management
+
+### Agent Management
+- `./snow-flow agent spawn <type>`: Create AI agents
+- `./snow-flow agent list`: List all active agents
+
+### Task Orchestration
+- `./snow-flow task create <type>`: Create and manage tasks
+- `./snow-flow workflow <file>`: Execute workflow automation
+
+### Memory Management
+- `./snow-flow memory store <key> <data>`: Store persistent data
+- `./snow-flow memory get <key>`: Retrieve stored information
+- `./snow-flow memory list`: List all memory keys
+
+### SPARC Development Modes
+- `./snow-flow sparc "<task>"`: Run orchestrator mode (default)
+- `./snow-flow sparc run <mode> "<task>"`: Run specific SPARC mode
+- `./snow-flow sparc tdd "<feature>"`: Test-driven development mode
+
+### Swarm Coordination - 🚀 Enhanced with Complete Solution
+- `./snow-flow swarm "<objective>" [options]`: Multi-agent swarm coordination - één command voor alles!
+- `--strategy`: research, development, analysis, testing, optimization, maintenance
+- `--mode`: centralized, distributed, hierarchical, mesh, hybrid
+- `--max-agents <n>`: Maximum number of agents (default: 5)
+- `--parallel`: Enable parallel execution
+- `--monitor`: Real-time monitoring
+
+**🧠 Intelligent Features (enabled by default):**
+- `--smart-discovery`: Smart artifact discovery and reuse (default: **true**)
+- `--live-testing`: Enable live testing during development (default: **true**)
+- `--auto-deploy`: Automatic deployment when ready (default: **true**)
+- `--shared-memory`: Enable shared memory between agents (default: **true**)
+
+## Quick Start Workflows
+
+### 🚀 Intelligent Development Workflow
 ```bash
-# Create detailed specifications with concurrent requirements analysis
-npx snow-flow sparc run spec-pseudocode "Define user authentication requirements" --parallel
+# Simple usage - all intelligent features enabled by default!
+./snow-flow swarm "Create incident management dashboard with real-time updates"
+# This automatically:
+# ✅ Discovers existing artifacts to reuse
+# ✅ Tests in real-time on your ServiceNow instance
+# ✅ Deploys automatically when ready
+# ✅ Shares context between all agents
 ```
 
-**Batchtools Optimization**: Simultaneously analyze multiple requirement sources, validate constraints in parallel, and generate comprehensive specifications.
-
-### 2. Pseudocode Phase (Concurrent Logic Design)
-
+### Research Workflow
 ```bash
-# Develop algorithmic logic with parallel pattern analysis
-npx snow-flow sparc run spec-pseudocode "Create authentication flow pseudocode" --batch-optimize
+./snow-flow swarm "Research modern web frameworks" --strategy research --mode distributed --parallel
+./snow-flow sparc run researcher "Analyze React vs Vue performance"
+./snow-flow memory store "research_findings" "Key insights"
 ```
 
-**Batchtools Optimization**: Process multiple algorithm patterns concurrently, validate logic flows in parallel, and optimize data structures simultaneously.
-
-### 3. Architecture Phase (Parallel Component Design)
-
-```bash
-# Design system architecture with concurrent component analysis
-npx snow-flow sparc run architect "Design authentication service architecture" --parallel
-```
-
-**Batchtools Optimization**: Generate multiple architectural alternatives simultaneously, validate integration points in parallel, and create comprehensive documentation concurrently.
-
-### 4. Refinement Phase (Parallel TDD Implementation)
-
+### Development Workflow
 ```bash
-# Execute Test-Driven Development with parallel test generation
-npx snow-flow sparc tdd "implement user authentication system" --batch-tdd
+./snow-flow start --ui --port 3000
+./snow-flow sparc tdd "User authentication system with JWT tokens"
+./snow-flow swarm "Build e-commerce API" --strategy development --max-agents 8
 ```
 
-**Batchtools Optimization**: Generate multiple test scenarios simultaneously, implement and validate code in parallel, and optimize performance concurrently.
-
-### 5. Completion Phase (Concurrent Integration)
+## Integration Patterns
 
+### Memory-Driven Coordination
 ```bash
-# Integration with parallel validation and documentation
-npx snow-flow sparc run integration "integrate authentication with user management" --parallel
-```
-
-**Batchtools Optimization**: Run integration tests in parallel, generate documentation concurrently, and validate requirements simultaneously.
-
-## Batchtools Integration Features
-
-### Parallel Processing Capabilities
-
-- **Concurrent File Operations**: Read, analyze, and modify multiple files simultaneously
-- **Parallel Code Analysis**: Analyze dependencies, patterns, and architecture concurrently
-- **Batch Test Generation**: Create comprehensive test suites in parallel
-- **Concurrent Documentation**: Generate multiple documentation formats simultaneously
-
-### Performance Optimizations
-
-- **Smart Batching**: Group related operations for optimal performance
-- **Pipeline Processing**: Chain dependent operations with parallel stages
-- **Resource Management**: Efficient utilization of system resources
-- **Error Resilience**: Robust error handling with parallel recovery
-
-## Performance Benchmarks
-
-### Batchtools Performance Improvements
+# Store architecture decisions
+./snow-flow memory store "system_architecture" "Microservices with API Gateway"
 
-- **File Operations**: Up to 300% faster with parallel processing
-- **Code Analysis**: 250% improvement with concurrent pattern recognition
-- **Test Generation**: 400% faster with parallel test creation
-- **Documentation**: 200% improvement with concurrent content generation
-- **Memory Operations**: 180% faster with batched read/write operations
-
-## Code Style and Best Practices (Batchtools Enhanced)
-
-### SPARC Development Principles with Batchtools
-
-- **Modular Design**: Keep files under 500 lines, optimize with parallel analysis
-- **Environment Safety**: Never hardcode secrets, validate with concurrent checks
-- **Test-First**: Always write tests before implementation using parallel generation
-- **Clean Architecture**: Separate concerns with concurrent validation
-- **Parallel Documentation**: Maintain clear, up-to-date documentation with concurrent updates
-
-### Batchtools Best Practices
-
-- **Parallel Operations**: Use batchtools for independent tasks
-- **Concurrent Validation**: Validate multiple aspects simultaneously
-- **Batch Processing**: Group similar operations for efficiency
-- **Pipeline Optimization**: Chain operations with parallel stages
-- **Resource Management**: Monitor and optimize resource usage
-
-## Important Notes (Enhanced)
-
-- Always run tests before committing with parallel execution (`npm run test --parallel`)
-- Use SPARC memory system with concurrent operations to maintain context across sessions
-- Follow the Red-Green-Refactor cycle with parallel test generation during TDD phases
-- Document architectural decisions with concurrent validation in memory
-- Regular security reviews with parallel analysis for authentication or data handling code
-- Claude Code slash commands provide quick access to batchtools-optimized SPARC modes
-- Monitor system resources during parallel operations for optimal performance
-
-## Available Agents (54 Total)
-
-### 🚀 Concurrent Agent Usage
-
-**CRITICAL**: Always spawn multiple agents concurrently using the Task tool in a single message:
-
-```javascript
-// ✅ CORRECT: Concurrent agent deployment
-[Single Message]:
-  - Task("Agent 1", "full instructions", "agent-type-1")
-  - Task("Agent 2", "full instructions", "agent-type-2")
-  - Task("Agent 3", "full instructions", "agent-type-3")
-  - Task("Agent 4", "full instructions", "agent-type-4")
-  - Task("Agent 5", "full instructions", "agent-type-5")
+# All subsequent operations reference this decision
+./snow-flow sparc run coder "Implement user service based on system_architecture"
 ```
 
-### 📋 Agent Categories & Concurrent Patterns
-
-#### **Core Development Agents**
-
-- `coder` - Implementation specialist
-- `reviewer` - Code quality assurance
-- `tester` - Test creation and validation
-- `planner` - Strategic planning
-- `researcher` - Information gathering
-
-**Concurrent Usage:**
-
+### Multi-Stage Development
 ```bash
-# Deploy full development swarm
-Task("Research requirements", "...", "researcher")
-Task("Plan architecture", "...", "planner")
-Task("Implement features", "...", "coder")
-Task("Create tests", "...", "tester")
-Task("Review code", "...", "reviewer")
-```
-
-#### **Swarm Coordination Agents**
+# Stage 1: Research and planning
+./snow-flow sparc run researcher "Research authentication best practices"
+./snow-flow sparc run architect "Design authentication system"
 
-- `hierarchical-coordinator` - Queen-led coordination
-- `mesh-coordinator` - Peer-to-peer networks
-- `adaptive-coordinator` - Dynamic topology
-- `collective-intelligence-coordinator` - Hive-mind intelligence
-- `swarm-memory-manager` - Distributed memory
+# Stage 2: Implementation
+./snow-flow sparc tdd "User registration and login functionality"
 
-**Concurrent Swarm Deployment:**
-
-```bash
-# Deploy multi-topology coordination
-Task("Hierarchical coordination", "...", "hierarchical-coordinator")
-Task("Mesh network backup", "...", "mesh-coordinator")
-Task("Adaptive optimization", "...", "adaptive-coordinator")
+# Stage 3: Testing and deployment
+./snow-flow sparc run tester "Comprehensive security testing"
 ```
 
-#### **Consensus & Distributed Systems**
-
-- `byzantine-coordinator` - Byzantine fault tolerance
-- `raft-manager` - Leader election protocols
-- `gossip-coordinator` - Epidemic dissemination
-- `consensus-builder` - Decision-making algorithms
-- `crdt-synchronizer` - Conflict-free replication
-- `quorum-manager` - Dynamic quorum management
-- `security-manager` - Cryptographic security
-
-#### **Performance & Optimization**
-
-- `perf-analyzer` - Bottleneck identification
-- `performance-benchmarker` - Performance testing
-- `task-orchestrator` - Workflow optimization
-- `memory-coordinator` - Memory management
-- `smart-agent` - Intelligent coordination
-
-#### **GitHub & Repository Management**
-
-- `github-modes` - Comprehensive GitHub integration
-- `pr-manager` - Pull request management
-- `code-review-swarm` - Multi-agent code review
-- `issue-tracker` - Issue management
-- `release-manager` - Release coordination
-- `workflow-automation` - CI/CD automation
-- `project-board-sync` - Project tracking
-- `repo-architect` - Repository optimization
-- `multi-repo-swarm` - Cross-repository coordination
-
-#### **SPARC Methodology Agents**
-
-- `sparc-coord` - SPARC orchestration
-- `sparc-coder` - TDD implementation
-- `specification` - Requirements analysis
-- `pseudocode` - Algorithm design
-- `architecture` - System design
-- `refinement` - Iterative improvement
+## Advanced Batch Tool Patterns
 
-#### **Specialized Development**
-
-- `backend-dev` - API development
-- `mobile-dev` - React Native development
-- `ml-developer` - Machine learning
-- `cicd-engineer` - CI/CD pipelines
-- `api-docs` - OpenAPI documentation
-- `system-architect` - High-level design
-- `code-analyzer` - Code quality analysis
-- `base-template-generator` - Boilerplate creation
-
-#### **Testing & Validation**
-
-- `tdd-london-swarm` - Mock-driven TDD
-- `production-validator` - Real implementation validation
-
-#### **Migration & Planning**
-
-- `migration-planner` - System migrations
-- `swarm-init` - Topology initialization
-
-### 🎯 Concurrent Agent Patterns
-
-#### **Full-Stack Development Swarm (8 agents)**
-
-```bash
-Task("System architecture", "...", "system-architect")
-Task("Backend APIs", "...", "backend-dev")
-Task("Frontend mobile", "...", "mobile-dev")
-Task("Database design", "...", "coder")
-Task("API documentation", "...", "api-docs")
-Task("CI/CD pipeline", "...", "cicd-engineer")
-Task("Performance testing", "...", "performance-benchmarker")
-Task("Production validation", "...", "production-validator")
-```
-
-#### **Distributed System Swarm (6 agents)**
-
-```bash
-Task("Byzantine consensus", "...", "byzantine-coordinator")
-Task("Raft coordination", "...", "raft-manager")
-Task("Gossip protocols", "...", "gossip-coordinator")
-Task("CRDT synchronization", "...", "crdt-synchronizer")
-Task("Security management", "...", "security-manager")
-Task("Performance monitoring", "...", "perf-analyzer")
-```
-
-#### **GitHub Workflow Swarm (5 agents)**
-
-```bash
-Task("PR management", "...", "pr-manager")
-Task("Code review", "...", "code-review-swarm")
-Task("Issue tracking", "...", "issue-tracker")
-Task("Release coordination", "...", "release-manager")
-Task("Workflow automation", "...", "workflow-automation")
-```
-
-#### **SPARC TDD Swarm (7 agents)**
-
-```bash
-Task("Requirements spec", "...", "specification")
-Task("Algorithm design", "...", "pseudocode")
-Task("System architecture", "...", "architecture")
-Task("TDD implementation", "...", "sparc-coder")
-Task("London school tests", "...", "tdd-london-swarm")
-Task("Iterative refinement", "...", "refinement")
-Task("Production validation", "...", "production-validator")
-```
-
-### ⚡ Performance Optimization
-
-**Agent Selection Strategy:**
-
-- **High Priority**: Use 3-5 agents max for critical path
-- **Medium Priority**: Use 5-8 agents for complex features
-- **Large Projects**: Use 8+ agents with proper coordination
-
-**Memory Management:**
-
-- Use `memory-coordinator` for cross-agent state
-- Implement `swarm-memory-manager` for distributed coordination
-- Apply `collective-intelligence-coordinator` for decision-making
-
-For more information about SPARC methodology and batchtools optimization, see:
-
-- SPARC Guide: https://github.com/ruvnet/claude-code-flow/docs/sparc.md
-- Batchtools Documentation: https://github.com/ruvnet/claude-code-flow/docs/batchtools.md
-
-# important-instruction-reminders
-
-Message 3: Task("Agent 2")
-Message 4: Read("file1.js")
-Message 5: Write("output1.js")
-Message 6: Bash("npm install")
-// This is 6x slower and breaks coordination!
-
-```
-
-### 🎯 CONCURRENT EXECUTION CHECKLIST:
-
-Before sending ANY message, ask yourself:
-
-- ✅ Are ALL related TodoWrite operations batched together?
-- ✅ Are ALL Task spawning operations in ONE message?
-- ✅ Are ALL file operations (Read/Write/Edit) batched together?
-- ✅ Are ALL bash commands grouped in ONE message?
-- ✅ Are ALL memory operations concurrent?
-
-If ANY answer is "No", you MUST combine operations into a single message!
-
-## 🚀 CRITICAL: Claude Code Does ALL Real Work
-
-### 🎯 CLAUDE CODE IS THE ONLY EXECUTOR
-
-**ABSOLUTE RULE**: Claude Code performs ALL actual work:
-
-### ✅ Claude Code ALWAYS Handles:
-
-- 🔧 **ALL file operations** (Read, Write, Edit, MultiEdit, Glob, Grep)
-- 💻 **ALL code generation** and programming tasks
-- 🖥️ **ALL bash commands** and system operations
-- 🏗️ **ALL actual implementation** work
-- 🔍 **ALL project navigation** and code analysis
-- 📝 **ALL TodoWrite** and task management
-- 🔄 **ALL git operations** (commit, push, merge)
-- 📦 **ALL package management** (npm, pip, etc.)
-- 🧪 **ALL testing** and validation
-- 🔧 **ALL debugging** and troubleshooting
-
-### 🧠 Claude Flow MCP Tools ONLY Handle:
-
-- 🎯 **Coordination only** - Planning Claude Code's actions
-- 💾 **Memory management** - Storing decisions and context
-- 🤖 **Neural features** - Learning from Claude Code's work
-- 📊 **Performance tracking** - Monitoring Claude Code's efficiency
-- 🐝 **Swarm orchestration** - Coordinating multiple Claude Code instances
-- 🔗 **GitHub integration** - Advanced repository coordination
-
-### 🚨 CRITICAL SEPARATION OF CONCERNS:
-
-**❌ MCP Tools NEVER:**
-
-- Write files or create content
-- Execute bash commands
-- Generate code
-- Perform file operations
-- Handle TodoWrite operations
-- Execute system commands
-- Do actual implementation work
-
-**✅ MCP Tools ONLY:**
-
-- Coordinate and plan
-- Store memory and context
-- Track performance
-- Orchestrate workflows
-- Provide intelligence insights
-
-### ⚠️ Key Principle:
-
-**MCP tools coordinate, Claude Code executes.** Think of MCP tools as the "brain" that plans and coordinates, while Claude Code is the "hands" that do all the actual work.
-
-### 🔄 WORKFLOW EXECUTION PATTERN:
-
-**✅ CORRECT Workflow:**
-
-1. **MCP**: `mcp__snow-flow__swarm_init` (coordination setup)
-2. **MCP**: `mcp__snow-flow__agent_spawn` (planning agents)
-3. **MCP**: `mcp__snow-flow__task_orchestrate` (task coordination)
-4. **Claude Code**: `Task` tool to spawn agents with coordination instructions
-5. **Claude Code**: `TodoWrite` with ALL todos batched (5-10+ in ONE call)
-6. **Claude Code**: `Read`, `Write`, `Edit`, `Bash` (actual work)
-7. **MCP**: `mcp__snow-flow__memory_usage` (store results)
-
-**❌ WRONG Workflow:**
-
-1. **MCP**: `mcp__snow-flow__terminal_execute` (DON'T DO THIS)
-2. **MCP**: File creation via MCP (DON'T DO THIS)
-3. **MCP**: Code generation via MCP (DON'T DO THIS)
-4. **Claude Code**: Sequential Task calls (DON'T DO THIS)
-5. **Claude Code**: Individual TodoWrite calls (DON'T DO THIS)
-
-### 🚨 REMEMBER:
-
-- **MCP tools** = Coordination, planning, memory, intelligence
-- **Claude Code** = All actual execution, coding, file operations
-
-## 🚀 CRITICAL: Parallel Execution & Batch Operations
-
-### 🚨 MANDATORY RULE #1: BATCH EVERYTHING
-
-**When using swarms, you MUST use BatchTool for ALL operations:**
-
-1. **NEVER** send multiple messages for related operations
-2. **ALWAYS** combine multiple tool calls in ONE message
-3. **PARALLEL** execution is MANDATORY, not optional
-
-### ⚡ THE GOLDEN RULE OF SWARMS
-
-```
-
-If you need to do X operations, they should be in 1 message, not X messages
-
-````
-
-### 🚨 MANDATORY TODO AND TASK BATCHING
-
-**CRITICAL RULE FOR TODOS AND TASKS:**
-
-1. **TodoWrite** MUST ALWAYS include ALL todos in ONE call (5-10+ todos)
-2. **Task** tool calls MUST be batched - spawn multiple agents in ONE message
-3. **NEVER** update todos one by one - this breaks parallel coordination
-4. **NEVER** spawn agents sequentially - ALL agents spawn together
-
-### 📦 BATCH TOOL EXAMPLES
-
-**✅ CORRECT - Everything in ONE Message:**
+### TodoWrite Coordination
+Always use TodoWrite for complex task coordination:
 
 ```javascript
-[Single Message with BatchTool]:
-  // MCP coordination setup
-  mcp__snow-flow__swarm_init { topology: "mesh", maxAgents: 6 }
-  mcp__snow-flow__agent_spawn { type: "researcher" }
-  mcp__snow-flow__agent_spawn { type: "coder" }
-  mcp__snow-flow__agent_spawn { type: "analyst" }
-  mcp__snow-flow__agent_spawn { type: "tester" }
-  mcp__snow-flow__agent_spawn { type: "coordinator" }
-
-  // Claude Code execution - ALL in parallel
-  Task("You are researcher agent. MUST coordinate via hooks...")
-  Task("You are coder agent. MUST coordinate via hooks...")
-  Task("You are analyst agent. MUST coordinate via hooks...")
-  Task("You are tester agent. MUST coordinate via hooks...")
-  TodoWrite { todos: [5-10 todos with all priorities and statuses] }
-
-  // File operations in parallel
-  Bash "mkdir -p app/{src,tests,docs}"
-  Write "app/package.json"
-  Write "app/README.md"
-  Write "app/src/index.js"
-````
-
-**❌ WRONG - Multiple Messages (NEVER DO THIS):**
-
-```javascript
-Message 1: mcp__snow-flow__swarm_init
-Message 2: Task("researcher agent")
-Message 3: Task("coder agent")
-Message 4: TodoWrite({ todo: "single todo" })
-Message 5: Bash "mkdir src"
-Message 6: Write "package.json"
-// This is 6x slower and breaks parallel coordination!
-```
-
-### 🎯 BATCH OPERATIONS BY TYPE
-
-**Todo and Task Operations (Single Message):**
-
-- **TodoWrite** → ALWAYS include 5-10+ todos in ONE call
-- **Task agents** → Spawn ALL agents with full instructions in ONE message
-- **Agent coordination** → ALL Task calls must include coordination hooks
-- **Status updates** → Update ALL todo statuses together
-- **NEVER** split todos or Task calls across messages!
-
-**File Operations (Single Message):**
-
-- Read 10 files? → One message with 10 Read calls
-- Write 5 files? → One message with 5 Write calls
-- Edit 1 file many times? → One MultiEdit call
-
-**Swarm Operations (Single Message):**
-
-- Need 8 agents? → One message with swarm_init + 8 agent_spawn calls
-- Multiple memories? → One message with all memory_usage calls
-- Task + monitoring? → One message with task_orchestrate + swarm_monitor
-
-**Command Operations (Single Message):**
-
-- Multiple directories? → One message with all mkdir commands
-- Install + test + lint? → One message with all npm commands
-- Git operations? → One message with all git commands
-
-## 🚀 Quick Setup (Stdio MCP - Recommended)
-
-### 1. Add MCP Server (Stdio - No Port Needed)
-
-```bash
-# Add Snow Flow MCP server to Claude Code using stdio
-claude mcp add snow-flow npx snow-flow mcp start
+TodoWrite([
+  {
+    id: "architecture_design",
+    content: "Design system architecture and component interfaces",
+    status: "pending",
+    priority: "high",
+    dependencies: [],
+    estimatedTime: "60min",
+    assignedAgent: "architect"
+  },
+  {
+    id: "frontend_development", 
+    content: "Develop React components and user interface",
+    status: "pending",
+    priority: "medium",
+    dependencies: ["architecture_design"],
+    estimatedTime: "120min",
+    assignedAgent: "frontend_team"
+  }
+]);
 ```
 
-### 2. Use MCP Tools for Coordination in Claude Code
-
-Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
-
-**Initialize a swarm:**
-
-- Use the `mcp__snow-flow__swarm_init` tool to set up coordination topology
-- Choose: mesh, hierarchical, ring, or star
-- This creates a coordination framework for Claude Code's work
-
-**Spawn agents:**
-
-- Use `mcp__snow-flow__agent_spawn` tool to create specialized coordinators
-- Agent types represent different thinking patterns, not actual coders
-- They help Claude Code approach problems from different angles
-
-**Orchestrate tasks:**
-
-- Use `mcp__snow-flow__task_orchestrate` tool to coordinate complex workflows
-- This breaks down tasks for Claude Code to execute systematically
-- The agents don't write code - they coordinate Claude Code's actions
-
-## Available MCP Tools for Coordination
-
-### Coordination Tools:
-
-- `mcp__snow-flow__swarm_init` - Set up coordination topology for Claude Code
-- `mcp__snow-flow__agent_spawn` - Create cognitive patterns to guide Claude Code
-- `mcp__snow-flow__task_orchestrate` - Break down and coordinate complex tasks
-
-### Monitoring Tools:
-
-- `mcp__snow-flow__swarm_status` - Monitor coordination effectiveness
-- `mcp__snow-flow__agent_list` - View active cognitive patterns
-- `mcp__snow-flow__agent_metrics` - Track coordination performance
-- `mcp__snow-flow__task_status` - Check workflow progress
-- `mcp__snow-flow__task_results` - Review coordination outcomes
-
-### Memory & Neural Tools:
-
-- `mcp__snow-flow__memory_usage` - Persistent memory across sessions
-- `mcp__snow-flow__neural_status` - Neural pattern effectiveness
-- `mcp__snow-flow__neural_train` - Improve coordination patterns
-- `mcp__snow-flow__neural_patterns` - Analyze thinking approaches
-
-### GitHub Integration Tools (NEW!):
-
-- `mcp__snow-flow__github_swarm` - Create specialized GitHub management swarms
-- `mcp__snow-flow__repo_analyze` - Deep repository analysis with AI
-- `mcp__snow-flow__pr_enhance` - AI-powered pull request improvements
-- `mcp__snow-flow__issue_triage` - Intelligent issue classification
-- `mcp__snow-flow__code_review` - Automated code review with swarms
-
-### System Tools:
-
-- `mcp__snow-flow__benchmark_run` - Measure coordination efficiency
-- `mcp__snow-flow__features_detect` - Available capabilities
-- `mcp__snow-flow__swarm_monitor` - Real-time coordination tracking
-
-## Workflow Examples (Coordination-Focused)
-
-### Research Coordination Example
-
-**Context:** Claude Code needs to research a complex topic systematically
-
-**Step 1:** Set up research coordination
-
-- Tool: `mcp__snow-flow__swarm_init`
-- Parameters: `{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}`
-- Result: Creates a mesh topology for comprehensive exploration
-
-**Step 2:** Define research perspectives
-
-- Tool: `mcp__snow-flow__agent_spawn`
-- Parameters: `{"type": "researcher", "name": "Literature Review"}`
-- Tool: `mcp__snow-flow__agent_spawn`
-- Parameters: `{"type": "analyst", "name": "Data Analysis"}`
-- Result: Different cognitive patterns for Claude Code to use
-
-**Step 3:** Coordinate research execution
-
-- Tool: `mcp__snow-flow__task_orchestrate`
-- Parameters: `{"task": "Research neural architecture search papers", "strategy": "adaptive"}`
-- Result: Claude Code systematically searches, reads, and analyzes papers
-
-**What Actually Happens:**
-
-1. The swarm sets up a coordination framework
-2. Each agent MUST use Snow Flow hooks for coordination:
-   - `npx snow-flow hooks pre-task` before starting
-   - `npx snow-flow hooks post-edit` after each file operation
-   - `npx snow-flow hooks notify` to share decisions
-3. Claude Code uses its native Read, WebSearch, and Task tools
-4. The swarm coordinates through shared memory and hooks
-5. Results are synthesized by Claude Code with full coordination history
-
-### Development Coordination Example
-
-**Context:** Claude Code needs to build a complex system with multiple components
-
-**Step 1:** Set up development coordination
-
-- Tool: `mcp__snow-flow__swarm_init`
-- Parameters: `{"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}`
-- Result: Hierarchical structure for organized development
-
-**Step 2:** Define development perspectives
-
-- Tool: `mcp__snow-flow__agent_spawn`
-- Parameters: `{"type": "architect", "name": "System Design"}`
-- Result: Architectural thinking pattern for Claude Code
-
-**Step 3:** Coordinate implementation
-
-- Tool: `mcp__snow-flow__task_orchestrate`
-- Parameters: `{"task": "Implement user authentication with JWT", "strategy": "parallel"}`
-- Result: Claude Code implements features using its native tools
-
-**What Actually Happens:**
-
-1. The swarm creates a development coordination plan
-2. Each agent coordinates using mandatory hooks:
-   - Pre-task hooks for context loading
-   - Post-edit hooks for progress tracking
-   - Memory storage for cross-agent coordination
-3. Claude Code uses Write, Edit, Bash tools for implementation
-4. Agents share progress through Claude Flow memory
-5. All code is written by Claude Code with full coordination
-
-### GitHub Repository Management Example (NEW!)
-
-**Context:** Claude Code needs to manage a complex GitHub repository
-
-**Step 1:** Initialize GitHub swarm
-
-- Tool: `mcp__snow-flow__github_swarm`
-- Parameters: `{"repository": "owner/repo", "agents": 5, "focus": "maintenance"}`
-- Result: Specialized swarm for repository management
-
-**Step 2:** Analyze repository health
-
-- Tool: `mcp__snow-flow__repo_analyze`
-- Parameters: `{"deep": true, "include": ["issues", "prs", "code"]}`
-- Result: Comprehensive repository analysis
-
-**Step 3:** Enhance pull requests
-
-- Tool: `mcp__snow-flow__pr_enhance`
-- Parameters: `{"pr_number": 123, "add_tests": true, "improve_docs": true}`
-- Result: AI-powered PR improvements
-
-## Best Practices for Coordination
-
-### ✅ DO:
-
-- Use MCP tools to coordinate Claude Code's approach to complex tasks
-- Let the swarm break down problems into manageable pieces
-- Use memory tools to maintain context across sessions
-- Monitor coordination effectiveness with status tools
-- Train neural patterns for better coordination over time
-- Leverage GitHub tools for repository management
-
-### ❌ DON'T:
-
-- Expect agents to write code (Claude Code does all implementation)
-- Use MCP tools for file operations (use Claude Code's native tools)
-- Try to make agents execute bash commands (Claude Code handles this)
-- Confuse coordination with execution (MCP coordinates, Claude executes)
-
-## Memory and Persistence
-
-The swarm provides persistent memory that helps Claude Code:
-
-- Remember project context across sessions
-- Track decisions and rationale
-- Maintain consistency in large projects
-- Learn from previous coordination patterns
-- Store GitHub workflow preferences
-
-## Performance Benefits
-
-When using Claude Flow coordination with Claude Code:
-
-- **84.8% SWE-Bench solve rate** - Better problem-solving through coordination
-- **32.3% token reduction** - Efficient task breakdown reduces redundancy
-- **2.8-4.4x speed improvement** - Parallel coordination strategies
-- **27+ neural models** - Diverse cognitive approaches
-- **GitHub automation** - Streamlined repository management
-
-## Claude Code Hooks Integration
-
-Claude Flow includes powerful hooks that automate coordination:
-
-### Pre-Operation Hooks
-
-- **Auto-assign agents** before file edits based on file type
-- **Validate commands** before execution for safety
-- **Prepare resources** automatically for complex operations
-- **Optimize topology** based on task complexity analysis
-- **Cache searches** for improved performance
-- **GitHub context** loading for repository operations
-
-### Post-Operation Hooks
-
-- **Auto-format code** using language-specific formatters
-- **Train neural patterns** from successful operations
-- **Update memory** with operation context
-- **Analyze performance** and identify bottlenecks
-- **Track token usage** for efficiency metrics
-- **Sync GitHub** state for consistency
-
-### Session Management
-
-- **Generate summaries** at session end
-- **Persist state** across Claude Code sessions
-- **Track metrics** for continuous improvement
-- **Restore previous** session context automatically
-- **Export workflows** for reuse
-
-### Advanced Features (v2.0.0!)
-
-- **🚀 Automatic Topology Selection** - Optimal swarm structure for each task
-- **⚡ Parallel Execution** - 2.8-4.4x speed improvements
-- **🧠 Neural Training** - Continuous learning from operations
-- **📊 Bottleneck Analysis** - Real-time performance optimization
-- **🤖 Smart Auto-Spawning** - Zero manual agent management
-- **🛡️ Self-Healing Workflows** - Automatic error recovery
-- **💾 Cross-Session Memory** - Persistent learning & context
-- **🔗 GitHub Integration** - Repository-aware swarms
-
-### Configuration
-
-Hooks are pre-configured in `.claude/settings.json`. Key features:
-
-- Automatic agent assignment for different file types
-- Code formatting on save
-- Neural pattern learning from edits
-- Session state persistence
-- Performance tracking and optimization
-- Intelligent caching and token reduction
-- GitHub workflow automation
-
-See `.claude/commands/` for detailed documentation on all features.
-
-## Integration Tips
-
-1. **Start Simple**: Begin with basic swarm init and single agent
-2. **Scale Gradually**: Add more agents as task complexity increases
-3. **Use Memory**: Store important decisions and context
-4. **Monitor Progress**: Regular status checks ensure effective coordination
-5. **Train Patterns**: Let neural agents learn from successful coordinations
-6. **Enable Hooks**: Use the pre-configured hooks for automation
-7. **GitHub First**: Use GitHub tools for repository management
-
-## 🧠 SWARM ORCHESTRATION PATTERN
-
-### You are the SWARM ORCHESTRATOR. **IMMEDIATELY SPAWN AGENTS IN PARALLEL** to execute tasks
-
-### 🚨 CRITICAL INSTRUCTION: You are the SWARM ORCHESTRATOR
-
-**MANDATORY**: When using swarms, you MUST:
+## Code Style Preferences
+- Use ES modules (import/export) syntax
+- Destructure imports when possible
+- Use TypeScript for all new code
+- Follow existing naming conventions
+- Add JSDoc comments for public APIs
+- Use async/await instead of Promise chains
+- Prefer const/let over var
 
-1. **SPAWN ALL AGENTS IN ONE BATCH** - Use multiple tool calls in a SINGLE message
-2. **EXECUTE TASKS IN PARALLEL** - Never wait for one task before starting another
-3. **USE BATCHTOOL FOR EVERYTHING** - Multiple operations = Single message with multiple tools
-4. **ALL AGENTS MUST USE COORDINATION TOOLS** - Every spawned agent MUST use snow-flow hooks and memory
+## Workflow Guidelines
+- Always run typecheck after making code changes
+- Run tests before committing changes
+- Use meaningful commit messages
+- Create feature branches for new functionality
+- Ensure all tests pass before merging
 
-### 🎯 AGENT COUNT CONFIGURATION
-
-**CRITICAL: Dynamic Agent Count Rules**
-
-1. **Check CLI Arguments First**: If user runs `npx snow-flow --agents 5`, use 5 agents
-2. **Auto-Decide if No Args**: Without CLI args, analyze task complexity:
-   - Simple tasks (1-3 components): 3-4 agents
-   - Medium tasks (4-6 components): 5-7 agents
-   - Complex tasks (7+ components): 8-12 agents
-3. **Agent Type Distribution**: Balance agent types based on task:
-   - Always include 1 coordinator
-   - For code-heavy tasks: more coders
-   - For design tasks: more architects/analysts
-   - For quality tasks: more testers/reviewers
-
-**Example Auto-Decision Logic:**
-
-```javascript
-// If CLI args provided: npx snow-flow --agents 6
-maxAgents = CLI_ARGS.agents || determineAgentCount(task);
-
-function determineAgentCount(task) {
-  // Analyze task complexity
-  if (task.includes(['API', 'database', 'auth', 'tests'])) return 8;
-  if (task.includes(['frontend', 'backend'])) return 6;
-  if (task.includes(['simple', 'script'])) return 3;
-  return 5; // default
-}
-```
-
-## 📋 MANDATORY AGENT COORDINATION PROTOCOL
+## 📊 MANDATORY AGENT COORDINATION PROTOCOL
 
 ### 🔴 CRITICAL: Every Agent MUST Follow This Protocol
 
 When you spawn an agent using the Task tool, that agent MUST:
 
 **1️⃣ BEFORE Starting Work:**
-
 ```bash
-# Check previous work and load context
 npx snow-flow hooks pre-task --description "[agent task]" --auto-spawn-agents false
 npx snow-flow hooks session-restore --session-id "swarm-[id]" --load-memory true
 ```
 
 **2️⃣ DURING Work (After EVERY Major Step):**
-
 ```bash
-# Store progress in memory after each file operation
 npx snow-flow hooks post-edit --file "[filepath]" --memory-key "swarm/[agent]/[step]"
-
-# Store decisions and findings
 npx snow-flow hooks notify --message "[what was done]" --telemetry true
-
-# Check coordination with other agents
-npx snow-flow hooks pre-search --query "[what to check]" --cache-results true
 ```
 
 **3️⃣ AFTER Completing Work:**
-
 ```bash
-# Save all results and learnings
 npx snow-flow hooks post-task --task-id "[task]" --analyze-performance true
 npx snow-flow hooks session-end --export-metrics true --generate-summary true
 ```
@@ -1063,30 +206,18 @@ You are the [Agent Type] agent in a coordinated swarm.
 
 MANDATORY COORDINATION:
 1. START: Run `npx snow-flow hooks pre-task --description "[your task]"`
-2. DURING: After EVERY file operation, run `npx snow-flow hooks post-edit --file "[file]" --memory-key "agent/[step]"`
+2. DURING: After EVERY file operation, run `npx snow-flow hooks post-edit --file "[file]"`
 3. MEMORY: Store ALL decisions using `npx snow-flow hooks notify --message "[decision]"`
-4. END: Run `npx snow-flow hooks post-task --task-id "[task]" --analyze-performance true`
+4. END: Run `npx snow-flow hooks post-task --task-id "[task]"`
 
 Your specific task: [detailed task description]
 
 REMEMBER: Coordinate with other agents by checking memory BEFORE making decisions!
 ```
 
-### ⚡ PARALLEL EXECUTION IS MANDATORY
-
-**THIS IS WRONG ❌ (Sequential - NEVER DO THIS):**
-
-```
-Message 1: Initialize swarm
-Message 2: Spawn agent 1
-Message 3: Spawn agent 2
-Message 4: TodoWrite (single todo)
-Message 5: Create file 1
-Message 6: TodoWrite (another single todo)
-```
-
-**THIS IS CORRECT ✅ (Parallel - ALWAYS DO THIS):**
+## ⚡ PARALLEL EXECUTION IS MANDATORY
 
+**✅ CORRECT (Parallel - ALWAYS DO THIS):**
 ```
 Message 1: [BatchTool]
   // MCP coordination setup
@@ -1094,178 +225,34 @@ Message 1: [BatchTool]
   - mcp__snow-flow__agent_spawn (researcher)
   - mcp__snow-flow__agent_spawn (coder)
   - mcp__snow-flow__agent_spawn (analyst)
-  - mcp__snow-flow__agent_spawn (tester)
-  - mcp__snow-flow__agent_spawn (coordinator)
 
-Message 2: [BatchTool - Claude Code execution]
   // Task agents with full coordination instructions
-  - Task("You are researcher agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Research API patterns")
-  - Task("You are coder agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Implement REST endpoints")
-  - Task("You are analyst agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Analyze performance")
-  - Task("You are tester agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Write comprehensive tests")
-
+  - Task("You are researcher agent. MANDATORY: Run hooks. Task: Research API patterns")
+  - Task("You are coder agent. MANDATORY: Run hooks. Task: Implement REST endpoints")
+  
   // TodoWrite with ALL todos batched
   - TodoWrite { todos: [
       {id: "research", content: "Research API patterns", status: "in_progress", priority: "high"},
       {id: "design", content: "Design database schema", status: "pending", priority: "high"},
       {id: "implement", content: "Build REST endpoints", status: "pending", priority: "high"},
-      {id: "test", content: "Write unit tests", status: "pending", priority: "medium"},
-      {id: "docs", content: "Create API documentation", status: "pending", priority: "low"},
-      {id: "deploy", content: "Setup deployment", status: "pending", priority: "medium"}
+      {id: "test", content: "Write unit tests", status: "pending", priority: "medium"}
     ]}
 
   // File operations in parallel
   - Write "api/package.json"
   - Write "api/server.js"
-  - Write "api/routes/users.js"
   - Bash "mkdir -p api/{routes,models,tests}"
 ```
 
-### 🎯 MANDATORY SWARM PATTERN
-
-When given ANY complex task with swarms:
-
-```
-STEP 1: IMMEDIATE PARALLEL SPAWN (Single Message!)
-[BatchTool]:
-  // IMPORTANT: Check CLI args for agent count, otherwise auto-decide based on task complexity
-  - mcp__snow-flow__swarm_init {
-      topology: "hierarchical",
-      maxAgents: CLI_ARGS.agents || AUTO_DECIDE(task_complexity), // Use CLI args or auto-decide
-      strategy: "parallel"
-    }
-
-  // Spawn agents based on maxAgents count and task requirements
-  // If CLI specifies 3 agents, spawn 3. If no args, auto-decide optimal count (3-12)
-  - mcp__snow-flow__agent_spawn { type: "architect", name: "System Designer" }
-  - mcp__snow-flow__agent_spawn { type: "coder", name: "API Developer" }
-  - mcp__snow-flow__agent_spawn { type: "coder", name: "Frontend Dev" }
-  - mcp__snow-flow__agent_spawn { type: "analyst", name: "DB Designer" }
-  - mcp__snow-flow__agent_spawn { type: "tester", name: "QA Engineer" }
-  - mcp__snow-flow__agent_spawn { type: "researcher", name: "Tech Lead" }
-  - mcp__snow-flow__agent_spawn { type: "coordinator", name: "PM" }
-  - TodoWrite { todos: [multiple todos at once] }
-
-STEP 2: PARALLEL TASK EXECUTION (Single Message!)
-[BatchTool]:
-  - mcp__snow-flow__task_orchestrate { task: "main task", strategy: "parallel" }
-  - mcp__snow-flow__memory_usage { action: "store", key: "init", value: {...} }
-  - Multiple Read operations
-  - Multiple Write operations
-  - Multiple Bash commands
-
-STEP 3: CONTINUE PARALLEL WORK (Never Sequential!)
-```
-
-### 📊 VISUAL TASK TRACKING FORMAT
-
-Use this format when displaying task progress:
-
-```
-📊 Progress Overview
-   ├── Total Tasks: X
-   ├── ✅ Completed: X (X%)
-   ├── 🔄 In Progress: X (X%)
-   ├── ⭕ Todo: X (X%)
-   └── ❌ Blocked: X (X%)
-
-📋 Todo (X)
-   └── 🔴 001: [Task description] [PRIORITY] ▶
-
-🔄 In progress (X)
-   ├── 🟡 002: [Task description] ↳ X deps ▶
-   └── 🔴 003: [Task description] [PRIORITY] ▶
-
-✅ Completed (X)
-   ├── ✅ 004: [Task description]
-   └── ... (more completed tasks)
-
-Priority indicators: 🔴 HIGH/CRITICAL, 🟡 MEDIUM, 🟢 LOW
-Dependencies: ↳ X deps | Actionable: ▶
-```
-
-### 🎯 REAL EXAMPLE: Full-Stack App Development
-
-**Task**: "Build a complete REST API with authentication, database, and tests"
-
-**🚨 MANDATORY APPROACH - Everything in Parallel:**
-
-```javascript
-// ✅ CORRECT: SINGLE MESSAGE with ALL operations
-[BatchTool - Message 1]:
-  // Initialize and spawn ALL agents at once
-  mcp__snow-flow__swarm_init { topology: "hierarchical", maxAgents: 8, strategy: "parallel" }
-  mcp__snow-flow__agent_spawn { type: "architect", name: "System Designer" }
-  mcp__snow-flow__agent_spawn { type: "coder", name: "API Developer" }
-  mcp__snow-flow__agent_spawn { type: "coder", name: "Auth Expert" }
-  mcp__snow-flow__agent_spawn { type: "analyst", name: "DB Designer" }
-  mcp__snow-flow__agent_spawn { type: "tester", name: "Test Engineer" }
-  mcp__snow-flow__agent_spawn { type: "coordinator", name: "Lead" }
-
-  // Update ALL todos at once - NEVER split todos!
-  TodoWrite { todos: [
-    { id: "design", content: "Design API architecture", status: "in_progress", priority: "high" },
-    { id: "auth", content: "Implement authentication", status: "pending", priority: "high" },
-    { id: "db", content: "Design database schema", status: "pending", priority: "high" },
-    { id: "api", content: "Build REST endpoints", status: "pending", priority: "high" },
-    { id: "tests", content: "Write comprehensive tests", status: "pending", priority: "medium" },
-    { id: "docs", content: "Document API endpoints", status: "pending", priority: "low" },
-    { id: "deploy", content: "Setup deployment pipeline", status: "pending", priority: "medium" },
-    { id: "monitor", content: "Add monitoring", status: "pending", priority: "medium" }
-  ]}
-
-  // Start orchestration
-  mcp__snow-flow__task_orchestrate { task: "Build REST API", strategy: "parallel" }
-
-  // Store initial memory
-  mcp__snow-flow__memory_usage { action: "store", key: "project/init", value: { started: Date.now() } }
-
-[BatchTool - Message 2]:
-  // Create ALL directories at once
-  Bash("mkdir -p test-app/{src,tests,docs,config}")
-  Bash("mkdir -p test-app/src/{models,routes,middleware,services}")
-  Bash("mkdir -p test-app/tests/{unit,integration}")
-
-  // Write ALL base files at once
-  Write("test-app/package.json", packageJsonContent)
-  Write("test-app/.env.example", envContent)
-  Write("test-app/README.md", readmeContent)
-  Write("test-app/src/server.js", serverContent)
-  Write("test-app/src/config/database.js", dbConfigContent)
-
-[BatchTool - Message 3]:
-  // Read multiple files for context
-  Read("test-app/package.json")
-  Read("test-app/src/server.js")
-  Read("test-app/.env.example")
-
-  // Run multiple commands
-  Bash("cd test-app && npm install")
-  Bash("cd test-app && npm run lint")
-  Bash("cd test-app && npm test")
-```
-
-### 🚫 NEVER DO THIS (Sequential = WRONG):
-
-```javascript
-// ❌ WRONG: Multiple messages, one operation each
-Message 1: mcp__snow-flow__swarm_init
-Message 2: mcp__snow-flow__agent_spawn (just one agent)
-Message 3: mcp__snow-flow__agent_spawn (another agent)
-Message 4: TodoWrite (single todo)
-Message 5: Write (single file)
-// This is 5x slower and wastes swarm coordination!
-```
-
-### 🔄 MEMORY COORDINATION PATTERN
+## 🔄 MEMORY COORDINATION PATTERN
 
 Every agent coordination step MUST use memory:
 
-```
+```javascript
 // After each major decision or implementation
-mcp__snow-flow__memory_usage
-  action: "store"
-  key: "swarm-{id}/agent-{name}/{step}"
+mcp__snow-flow__memory_usage({
+  action: "store",
+  key: "swarm-{id}/agent-{name}/{step}",
   value: {
     timestamp: Date.now(),
     decision: "what was decided",
@@ -1273,110 +260,129 @@ mcp__snow-flow__memory_usage
     nextSteps: ["step1", "step2"],
     dependencies: ["dep1", "dep2"]
   }
+})
+```
+
+## Snow-Flow MCP Tools (100+ Total)
+
+Snow-Flow provides comprehensive ServiceNow intelligence through 15 specialized MCP servers:
+
+### 🧠 **Graph Memory & Dependency Analysis** (7 tools)
+- `snow_graph_index_artifact` - Index artifacts in Neo4j with relationship mapping
+- `snow_graph_find_related` - Find ALL connections & dependencies of any script/artifact
+- `snow_graph_analyze_impact` - AI-powered impact analysis before making changes
+- `snow_graph_suggest_artifacts` - Intelligent artifact suggestions based on patterns
+- `snow_graph_pattern_analysis` - Advanced pattern recognition across all code
+- `snow_graph_visualize` - Generate visual dependency graphs (Cypher/Mermaid)
+- `snow_graph_export_knowledge` - Export learned patterns and relationships
+
+### 🔄 **Process Mining & Workflow Analysis** (4 tools)
+- `snow_discover_process` - Real process mining from ServiceNow audit logs
+- `snow_analyze_workflow_execution` - Analyze how workflows REALLY work vs design
+- `snow_discover_cross_table_process` - Discover end-to-end processes across tables
+- `snow_monitor_process` - Real-time process monitoring with anomaly detection
+
+### ⚡ **Advanced Analytics & Performance** (6 tools)
+- `snow_batch_api` - 80% API call reduction through intelligent batching
+- `snow_get_table_relationships` - Deep table relationship mapping with visualizations
+- `snow_analyze_query` - Query performance analysis with optimization suggestions
+- `snow_predict_change_impact` - AI-powered change impact prediction (90% accuracy)
+- `snow_detect_code_patterns` - Security & performance anti-pattern detection
+- `snow_generate_documentation` - Auto-generate documentation from code analysis
+
+### 📊 **ServiceNow Operations** (15+ tools)
+- Complete ITIL lifecycle management (Incident, Request, Problem, Change)
+- CMDB and User management with intelligent analysis
+- AI-powered incident analysis and auto-resolution capabilities
+- Pattern recognition and predictive analytics
+- Knowledge base integration with smart suggestions
+
+### 🔧 **Platform Development** (8+ tools)
+- UI component creation (Pages, scripts, policies, actions)
+- Business rule management with dynamic rule creation
+- Client script development and form automation
+- Complete table schema discovery and analysis
+- Field management with dynamic discovery
+- Script include development for reusable code libraries
+
+### 🔗 **Integration** (10+ tools)
+- REST/SOAP endpoint discovery for external system integration
+- Transform map creation and data transformation
+- Import set management and data import automation
+- Web service integration with WSDL-based connections
+- Email configuration and communication integration
+- Comprehensive data source discovery and analysis
+
+### 📈 **Reporting & Analytics** (12+ tools)
+- Dynamic report creation with no hardcoded configurations
+- Interactive ServiceNow dashboard generation
+- KPI management and business metrics tracking
+- Advanced data visualization (charts, graphs, visual analytics)
+- System performance monitoring and analytics
+- Automated report delivery and scheduling
+
+### ⚙️ **Automation** (11+ tools)
+- Scheduled job management with dynamic schedule discovery
+- Event rule creation and automated event handling
+- Smart notification management and delivery
+- SLA definition and service level automation
+- Escalation rules and automated escalation processes
+- Comprehensive workflow activities and process automation
+
+### 🛡️ **Security & Compliance** (12+ tools)
+- Security policy management with dynamic configurations
+- Compliance rule enforcement (SOX, GDPR, HIPAA)
+- Audit trail analysis and security incident detection
+- Access control management and role/permission analysis
+- Proactive vulnerability scanning and assessment
+- Comprehensive security risk assessment and analysis
+
+### 🔄 **XML Flow Generation** (5+ tools)
+- XML-first flow creation to bypass API limitations
+- Direct XML deployment with alternative deployment methods
+- Flow template generation for standardized workflows
+- Natural language mapping with AI-powered flow design
+
+## Available Agents (25+ Total)
+
+### Core Development Agents
+- `coder` - Implementation specialist
+- `reviewer` - Code quality assurance
+- `tester` - Test creation and validation
+- `planner` - Strategic planning
+- `researcher` - Information gathering
 
-// To retrieve coordination data
-mcp__snow-flow__memory_usage
-  action: "retrieve"
-  key: "swarm-{id}/agent-{name}/{step}"
-
-// To check all swarm progress
-mcp__snow-flow__memory_usage
-  action: "list"
-  pattern: "swarm-{id}/*"
-```
-
-### ⚡ PERFORMANCE TIPS
-
-1. **Batch Everything**: Never operate on single files when multiple are needed
-2. **Parallel First**: Always think "what can run simultaneously?"
-3. **Memory is Key**: Use memory for ALL cross-agent coordination
-4. **Monitor Progress**: Use mcp**snow-flow**swarm_monitor for real-time tracking
-5. **Auto-Optimize**: Let hooks handle topology and agent selection
-
-### 🎨 VISUAL SWARM STATUS
-
-When showing swarm status, use this format:
-
-```
-🐝 Swarm Status: ACTIVE
-├── 🏗️ Topology: hierarchical
-├── 👥 Agents: 6/8 active
-├── ⚡ Mode: parallel execution
-├── 📊 Tasks: 12 total (4 complete, 6 in-progress, 2 pending)
-└── 🧠 Memory: 15 coordination points stored
-
-Agent Activity:
-├── 🟢 architect: Designing database schema...
-├── 🟢 coder-1: Implementing auth endpoints...
-├── 🟢 coder-2: Building user CRUD operations...
-├── 🟢 analyst: Optimizing query performance...
-├── 🟡 tester: Waiting for auth completion...
-└── 🟢 coordinator: Monitoring progress...
-```
-
-## 📝 CRITICAL: TODOWRITE AND TASK TOOL BATCHING
-
-### 🚨 MANDATORY BATCHING RULES FOR TODOS AND TASKS
-
-**TodoWrite Tool Requirements:**
-
-1. **ALWAYS** include 5-10+ todos in a SINGLE TodoWrite call
-2. **NEVER** call TodoWrite multiple times in sequence
-3. **BATCH** all todo updates together - status changes, new todos, completions
-4. **INCLUDE** all priority levels (high, medium, low) in one call
-
-**Task Tool Requirements:**
-
-1. **SPAWN** all agents using Task tool in ONE message
-2. **NEVER** spawn agents one by one across multiple messages
-3. **INCLUDE** full task descriptions and coordination instructions
-4. **BATCH** related Task calls together for parallel execution
-
-**Example of CORRECT TodoWrite usage:**
-
-```javascript
-// ✅ CORRECT - All todos in ONE call
-TodoWrite { todos: [
-  { id: "1", content: "Initialize system", status: "completed", priority: "high" },
-  { id: "2", content: "Analyze requirements", status: "in_progress", priority: "high" },
-  { id: "3", content: "Design architecture", status: "pending", priority: "high" },
-  { id: "4", content: "Implement core", status: "pending", priority: "high" },
-  { id: "5", content: "Build features", status: "pending", priority: "medium" },
-  { id: "6", content: "Write tests", status: "pending", priority: "medium" },
-  { id: "7", content: "Add monitoring", status: "pending", priority: "medium" },
-  { id: "8", content: "Documentation", status: "pending", priority: "low" },
-  { id: "9", content: "Performance tuning", status: "pending", priority: "low" },
-  { id: "10", content: "Deploy to production", status: "pending", priority: "high" }
-]}
-```
-
-**Example of WRONG TodoWrite usage:**
-
-```javascript
-// ❌ WRONG - Multiple TodoWrite calls
-Message 1: TodoWrite { todos: [{ id: "1", content: "Task 1", ... }] }
-Message 2: TodoWrite { todos: [{ id: "2", content: "Task 2", ... }] }
-Message 3: TodoWrite { todos: [{ id: "3", content: "Task 3", ... }] }
-// This breaks parallel coordination!
-```
-
-## Claude Flow v2.0.0 Features
-
-Claude Flow extends the base coordination with:
+### Swarm Coordination Agents
+- `hierarchical-coordinator` - Queen-led coordination
+- `mesh-coordinator` - Peer-to-peer networks
+- `adaptive-coordinator` - Dynamic topology
+- `collective-intelligence-coordinator` - Hive-mind intelligence
 
-- **🔗 GitHub Integration** - Deep repository management
-- **🎯 Project Templates** - Quick-start for common projects
-- **📊 Advanced Analytics** - Detailed performance insights
-- **🤖 Custom Agent Types** - Domain-specific coordinators
-- **🔄 Workflow Automation** - Reusable task sequences
-- **🛡️ Enhanced Security** - Safer command execution
+### Specialized Development
+- `backend-dev` - API development
+- `mobile-dev` - React Native development
+- `ml-developer` - Machine learning
+- `system-architect` - High-level design
+- `security-agent` - Security analysis
 
-## Support
+### GitHub & Repository Management
+- `github-modes` - Comprehensive GitHub integration
+- `pr-manager` - Pull request management
+- `code-review-swarm` - Multi-agent code review
 
-- Documentation: https://github.com/groeimetai/snow-flow
-- Issues: https://github.com/groeimetai/snow-flow/issues
-- Examples: https://github.com/groeimetai/snow-flow/tree/main/examples
+### SPARC Methodology Agents
+- `sparc-coord` - SPARC orchestration
+- `sparc-coder` - TDD implementation
+- `specification` - Requirements analysis
+- `architecture` - System design
 
----
+## Important Notes
+- **Use TodoWrite extensively** for all complex task coordination
+- **Leverage Task tool** for parallel agent execution on independent work
+- **Store all important information in Memory** for cross-agent coordination
+- **Use batch file operations** whenever reading/writing multiple files
+- **All swarm operations include automatic batch tool coordination**
+- **Monitor progress** with TodoRead during long-running operations
+- **Enable parallel execution** with --parallel flags for maximum efficiency
 
-Remember: **Snow-Flow coordinates, Claude Code creates!** Start with `mcp__snow-flow__swarm_init` to enhance your development workflow.
+This configuration ensures optimal use of Claude Code's batch tools for swarm orchestration and parallel task execution with full Snow-Flow capabilities.