agentic-flow 1.9.0 → 1.9.2

package/.claude/skills/swarm-advanced/SKILL.md

@@ -1,973 +0,0 @@
----
-name: swarm-advanced
-description: Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows
-version: 2.0.0
-category: orchestration
-tags: [swarm, distributed, parallel, research, testing, development, coordination]
-author: Claude Flow Team
----
-
-# Advanced Swarm Orchestration
-
-Master advanced swarm patterns for distributed research, development, and testing workflows. This skill covers comprehensive orchestration strategies using both MCP tools and CLI commands.
-
-## Quick Start
-
-### Prerequisites
-```bash
-# Ensure Claude Flow is installed
-npm install -g claude-flow@alpha
-
-# Add MCP server (if using MCP tools)
-claude mcp add claude-flow npx claude-flow@alpha mcp start
-```
-
-### Basic Pattern
-```javascript
-// 1. Initialize swarm topology
-mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })
-
-// 2. Spawn specialized agents
-mcp__claude-flow__agent_spawn({ type: "researcher", name: "Agent 1" })
-
-// 3. Orchestrate tasks
-mcp__claude-flow__task_orchestrate({ task: "...", strategy: "parallel" })
-```
-
-## Core Concepts
-
-### Swarm Topologies
-
-**Mesh Topology** - Peer-to-peer communication, best for research and analysis
-- All agents communicate directly
-- High flexibility and resilience
-- Use for: Research, analysis, brainstorming
-
-**Hierarchical Topology** - Coordinator with subordinates, best for development
-- Clear command structure
-- Sequential workflow support
-- Use for: Development, structured workflows
-
-**Star Topology** - Central coordinator, best for testing
-- Centralized control and monitoring
-- Parallel execution with coordination
-- Use for: Testing, validation, quality assurance
-
-**Ring Topology** - Sequential processing chain
-- Step-by-step processing
-- Pipeline workflows
-- Use for: Multi-stage processing, data pipelines
-
-### Agent Strategies
-
-**Adaptive** - Dynamic adjustment based on task complexity
-**Balanced** - Equal distribution of work across agents
-**Specialized** - Task-specific agent assignment
-**Parallel** - Maximum concurrent execution
-
-## Pattern 1: Research Swarm
-
-### Purpose
-Deep research through parallel information gathering, analysis, and synthesis.
-
-### Architecture
-```javascript
-// Initialize research swarm
-mcp__claude-flow__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 6,
-  "strategy": "adaptive"
-})
-
-// Spawn research team
-const researchAgents = [
-  {
-    type: "researcher",
-    name: "Web Researcher",
-    capabilities: ["web-search", "content-extraction", "source-validation"]
-  },
-  {
-    type: "researcher",
-    name: "Academic Researcher",
-    capabilities: ["paper-analysis", "citation-tracking", "literature-review"]
-  },
-  {
-    type: "analyst",
-    name: "Data Analyst",
-    capabilities: ["data-processing", "statistical-analysis", "visualization"]
-  },
-  {
-    type: "analyst",
-    name: "Pattern Analyzer",
-    capabilities: ["trend-detection", "correlation-analysis", "outlier-detection"]
-  },
-  {
-    type: "documenter",
-    name: "Report Writer",
-    capabilities: ["synthesis", "technical-writing", "formatting"]
-  }
-]
-
-// Spawn all agents
-researchAgents.forEach(agent => {
-  mcp__claude-flow__agent_spawn({
-    type: agent.type,
-    name: agent.name,
-    capabilities: agent.capabilities
-  })
-})
-```
-
-### Research Workflow
-
-#### Phase 1: Information Gathering
-```javascript
-// Parallel information collection
-mcp__claude-flow__parallel_execute({
-  "tasks": [
-    {
-      "id": "web-search",
-      "command": "search recent publications and articles"
-    },
-    {
-      "id": "academic-search",
-      "command": "search academic databases and papers"
-    },
-    {
-      "id": "data-collection",
-      "command": "gather relevant datasets and statistics"
-    },
-    {
-      "id": "expert-search",
-      "command": "identify domain experts and thought leaders"
-    }
-  ]
-})
-
-// Store research findings in memory
-mcp__claude-flow__memory_usage({
-  "action": "store",
-  "key": "research-findings-" + Date.now(),
-  "value": JSON.stringify(findings),
-  "namespace": "research",
-  "ttl": 604800 // 7 days
-})
-```
-
-#### Phase 2: Analysis and Validation
-```javascript
-// Pattern recognition in findings
-mcp__claude-flow__pattern_recognize({
-  "data": researchData,
-  "patterns": ["trend", "correlation", "outlier", "emerging-pattern"]
-})
-
-// Cognitive analysis
-mcp__claude-flow__cognitive_analyze({
-  "behavior": "research-synthesis"
-})
-
-// Quality assessment
-mcp__claude-flow__quality_assess({
-  "target": "research-sources",
-  "criteria": ["credibility", "relevance", "recency", "authority"]
-})
-
-// Cross-reference validation
-mcp__claude-flow__neural_patterns({
-  "action": "analyze",
-  "operation": "fact-checking",
-  "metadata": { "sources": sourcesArray }
-})
-```
-
-#### Phase 3: Knowledge Management
-```javascript
-// Search existing knowledge base
-mcp__claude-flow__memory_search({
-  "pattern": "topic X",
-  "namespace": "research",
-  "limit": 20
-})
-
-// Create knowledge graph connections
-mcp__claude-flow__neural_patterns({
-  "action": "learn",
-  "operation": "knowledge-graph",
-  "metadata": {
-    "topic": "X",
-    "connections": relatedTopics,
-    "depth": 3
-  }
-})
-
-// Store connections for future use
-mcp__claude-flow__memory_usage({
-  "action": "store",
-  "key": "knowledge-graph-X",
-  "value": JSON.stringify(knowledgeGraph),
-  "namespace": "research/graphs",
-  "ttl": 2592000 // 30 days
-})
-```
-
-#### Phase 4: Report Generation
-```javascript
-// Orchestrate report generation
-mcp__claude-flow__task_orchestrate({
-  "task": "generate comprehensive research report",
-  "strategy": "sequential",
-  "priority": "high",
-  "dependencies": ["gather", "analyze", "validate", "synthesize"]
-})
-
-// Monitor research progress
-mcp__claude-flow__swarm_status({
-  "swarmId": "research-swarm"
-})
-
-// Generate final report
-mcp__claude-flow__workflow_execute({
-  "workflowId": "research-report-generation",
-  "params": {
-    "findings": findings,
-    "format": "comprehensive",
-    "sections": ["executive-summary", "methodology", "findings", "analysis", "conclusions", "references"]
-  }
-})
-```
-
-### CLI Fallback
-```bash
-# Quick research swarm
-npx claude-flow swarm "research AI trends in 2025" \
-  --strategy research \
-  --mode distributed \
-  --max-agents 6 \
-  --parallel \
-  --output research-report.md
-```
-
-## Pattern 2: Development Swarm
-
-### Purpose
-Full-stack development through coordinated specialist agents.
-
-### Architecture
-```javascript
-// Initialize development swarm with hierarchy
-mcp__claude-flow__swarm_init({
-  "topology": "hierarchical",
-  "maxAgents": 8,
-  "strategy": "balanced"
-})
-
-// Spawn development team
-const devTeam = [
-  { type: "architect", name: "System Architect", role: "coordinator" },
-  { type: "coder", name: "Backend Developer", capabilities: ["node", "api", "database"] },
-  { type: "coder", name: "Frontend Developer", capabilities: ["react", "ui", "ux"] },
-  { type: "coder", name: "Database Engineer", capabilities: ["sql", "nosql", "optimization"] },
-  { type: "tester", name: "QA Engineer", capabilities: ["unit", "integration", "e2e"] },
-  { type: "reviewer", name: "Code Reviewer", capabilities: ["security", "performance", "best-practices"] },
-  { type: "documenter", name: "Technical Writer", capabilities: ["api-docs", "guides", "tutorials"] },
-  { type: "monitor", name: "DevOps Engineer", capabilities: ["ci-cd", "deployment", "monitoring"] }
-]
-
-// Spawn all team members
-devTeam.forEach(member => {
-  mcp__claude-flow__agent_spawn({
-    type: member.type,
-    name: member.name,
-    capabilities: member.capabilities,
-    swarmId: "dev-swarm"
-  })
-})
-```
-
-### Development Workflow
-
-#### Phase 1: Architecture and Design
-```javascript
-// System architecture design
-mcp__claude-flow__task_orchestrate({
-  "task": "design system architecture for REST API",
-  "strategy": "sequential",
-  "priority": "critical",
-  "assignTo": "System Architect"
-})
-
-// Store architecture decisions
-mcp__claude-flow__memory_usage({
-  "action": "store",
-  "key": "architecture-decisions",
-  "value": JSON.stringify(architectureDoc),
-  "namespace": "development/design"
-})
-```
-
-#### Phase 2: Parallel Implementation
-```javascript
-// Parallel development tasks
-mcp__claude-flow__parallel_execute({
-  "tasks": [
-    {
-      "id": "backend-api",
-      "command": "implement REST API endpoints",
-      "assignTo": "Backend Developer"
-    },
-    {
-      "id": "frontend-ui",
-      "command": "build user interface components",
-      "assignTo": "Frontend Developer"
-    },
-    {
-      "id": "database-schema",
-      "command": "design and implement database schema",
-      "assignTo": "Database Engineer"
-    },
-    {
-      "id": "api-documentation",
-      "command": "create API documentation",
-      "assignTo": "Technical Writer"
-    }
-  ]
-})
-
-// Monitor development progress
-mcp__claude-flow__swarm_monitor({
-  "swarmId": "dev-swarm",
-  "interval": 5000
-})
-```
-
-#### Phase 3: Testing and Validation
-```javascript
-// Comprehensive testing
-mcp__claude-flow__batch_process({
-  "items": [
-    { type: "unit", target: "all-modules" },
-    { type: "integration", target: "api-endpoints" },
-    { type: "e2e", target: "user-flows" },
-    { type: "performance", target: "critical-paths" }
-  ],
-  "operation": "execute-tests"
-})
-
-// Quality assessment
-mcp__claude-flow__quality_assess({
-  "target": "codebase",
-  "criteria": ["coverage", "complexity", "maintainability", "security"]
-})
-```
-
-#### Phase 4: Review and Deployment
-```javascript
-// Code review workflow
-mcp__claude-flow__workflow_execute({
-  "workflowId": "code-review-process",
-  "params": {
-    "reviewers": ["Code Reviewer"],
-    "criteria": ["security", "performance", "best-practices"]
-  }
-})
-
-// CI/CD pipeline
-mcp__claude-flow__pipeline_create({
-  "config": {
-    "stages": ["build", "test", "security-scan", "deploy"],
-    "environment": "production"
-  }
-})
-```
-
-### CLI Fallback
-```bash
-# Quick development swarm
-npx claude-flow swarm "build REST API with authentication" \
-  --strategy development \
-  --mode hierarchical \
-  --monitor \
-  --output sqlite
-```
-
-## Pattern 3: Testing Swarm
-
-### Purpose
-Comprehensive quality assurance through distributed testing.
-
-### Architecture
-```javascript
-// Initialize testing swarm with star topology
-mcp__claude-flow__swarm_init({
-  "topology": "star",
-  "maxAgents": 7,
-  "strategy": "parallel"
-})
-
-// Spawn testing team
-const testingTeam = [
-  {
-    type: "tester",
-    name: "Unit Test Coordinator",
-    capabilities: ["unit-testing", "mocking", "coverage", "tdd"]
-  },
-  {
-    type: "tester",
-    name: "Integration Tester",
-    capabilities: ["integration", "api-testing", "contract-testing"]
-  },
-  {
-    type: "tester",
-    name: "E2E Tester",
-    capabilities: ["e2e", "ui-testing", "user-flows", "selenium"]
-  },
-  {
-    type: "tester",
-    name: "Performance Tester",
-    capabilities: ["load-testing", "stress-testing", "benchmarking"]
-  },
-  {
-    type: "monitor",
-    name: "Security Tester",
-    capabilities: ["security-testing", "penetration-testing", "vulnerability-scanning"]
-  },
-  {
-    type: "analyst",
-    name: "Test Analyst",
-    capabilities: ["coverage-analysis", "test-optimization", "reporting"]
-  },
-  {
-    type: "documenter",
-    name: "Test Documenter",
-    capabilities: ["test-documentation", "test-plans", "reports"]
-  }
-]
-
-// Spawn all testers
-testingTeam.forEach(tester => {
-  mcp__claude-flow__agent_spawn({
-    type: tester.type,
-    name: tester.name,
-    capabilities: tester.capabilities,
-    swarmId: "testing-swarm"
-  })
-})
-```
-
-### Testing Workflow
-
-#### Phase 1: Test Planning
-```javascript
-// Analyze test coverage requirements
-mcp__claude-flow__quality_assess({
-  "target": "test-coverage",
-  "criteria": [
-    "line-coverage",
-    "branch-coverage",
-    "function-coverage",
-    "edge-cases"
-  ]
-})
-
-// Identify test scenarios
-mcp__claude-flow__pattern_recognize({
-  "data": testScenarios,
-  "patterns": [
-    "edge-case",
-    "boundary-condition",
-    "error-path",
-    "happy-path"
-  ]
-})
-
-// Store test plan
-mcp__claude-flow__memory_usage({
-  "action": "store",
-  "key": "test-plan-" + Date.now(),
-  "value": JSON.stringify(testPlan),
-  "namespace": "testing/plans"
-})
-```
-
-#### Phase 2: Parallel Test Execution
-```javascript
-// Execute all test suites in parallel
-mcp__claude-flow__parallel_execute({
-  "tasks": [
-    {
-      "id": "unit-tests",
-      "command": "npm run test:unit",
-      "assignTo": "Unit Test Coordinator"
-    },
-    {
-      "id": "integration-tests",
-      "command": "npm run test:integration",
-      "assignTo": "Integration Tester"
-    },
-    {
-      "id": "e2e-tests",
-      "command": "npm run test:e2e",
-      "assignTo": "E2E Tester"
-    },
-    {
-      "id": "performance-tests",
-      "command": "npm run test:performance",
-      "assignTo": "Performance Tester"
-    },
-    {
-      "id": "security-tests",
-      "command": "npm run test:security",
-      "assignTo": "Security Tester"
-    }
-  ]
-})
-
-// Batch process test suites
-mcp__claude-flow__batch_process({
-  "items": testSuites,
-  "operation": "execute-test-suite"
-})
-```
-
-#### Phase 3: Performance and Security
-```javascript
-// Run performance benchmarks
-mcp__claude-flow__benchmark_run({
-  "suite": "comprehensive-performance"
-})
-
-// Bottleneck analysis
-mcp__claude-flow__bottleneck_analyze({
-  "component": "application",
-  "metrics": ["response-time", "throughput", "memory", "cpu"]
-})
-
-// Security scanning
-mcp__claude-flow__security_scan({
-  "target": "application",
-  "depth": "comprehensive"
-})
-
-// Vulnerability analysis
-mcp__claude-flow__error_analysis({
-  "logs": securityScanLogs
-})
-```
-
-#### Phase 4: Monitoring and Reporting
-```javascript
-// Real-time test monitoring
-mcp__claude-flow__swarm_monitor({
-  "swarmId": "testing-swarm",
-  "interval": 2000
-})
-
-// Generate comprehensive test report
-mcp__claude-flow__performance_report({
-  "format": "detailed",
-  "timeframe": "current-run"
-})
-
-// Get test results
-mcp__claude-flow__task_results({
-  "taskId": "test-execution-001"
-})
-
-// Trend analysis
-mcp__claude-flow__trend_analysis({
-  "metric": "test-coverage",
-  "period": "30d"
-})
-```
-
-### CLI Fallback
-```bash
-# Quick testing swarm
-npx claude-flow swarm "test application comprehensively" \
-  --strategy testing \
-  --mode star \
-  --parallel \
-  --timeout 600
-```
-
-## Pattern 4: Analysis Swarm
-
-### Purpose
-Deep code and system analysis through specialized analyzers.
-
-### Architecture
-```javascript
-// Initialize analysis swarm
-mcp__claude-flow__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 5,
-  "strategy": "adaptive"
-})
-
-// Spawn analysis specialists
-const analysisTeam = [
-  {
-    type: "analyst",
-    name: "Code Analyzer",
-    capabilities: ["static-analysis", "complexity-analysis", "dead-code-detection"]
-  },
-  {
-    type: "analyst",
-    name: "Security Analyzer",
-    capabilities: ["security-scan", "vulnerability-detection", "dependency-audit"]
-  },
-  {
-    type: "analyst",
-    name: "Performance Analyzer",
-    capabilities: ["profiling", "bottleneck-detection", "optimization"]
-  },
-  {
-    type: "analyst",
-    name: "Architecture Analyzer",
-    capabilities: ["dependency-analysis", "coupling-detection", "modularity-assessment"]
-  },
-  {
-    type: "documenter",
-    name: "Analysis Reporter",
-    capabilities: ["reporting", "visualization", "recommendations"]
-  }
-]
-
-// Spawn all analysts
-analysisTeam.forEach(analyst => {
-  mcp__claude-flow__agent_spawn({
-    type: analyst.type,
-    name: analyst.name,
-    capabilities: analyst.capabilities
-  })
-})
-```
-
-### Analysis Workflow
-```javascript
-// Parallel analysis execution
-mcp__claude-flow__parallel_execute({
-  "tasks": [
-    { "id": "analyze-code", "command": "analyze codebase structure and quality" },
-    { "id": "analyze-security", "command": "scan for security vulnerabilities" },
-    { "id": "analyze-performance", "command": "identify performance bottlenecks" },
-    { "id": "analyze-architecture", "command": "assess architectural patterns" }
-  ]
-})
-
-// Generate comprehensive analysis report
-mcp__claude-flow__performance_report({
-  "format": "detailed",
-  "timeframe": "current"
-})
-
-// Cost analysis
-mcp__claude-flow__cost_analysis({
-  "timeframe": "30d"
-})
-```
-
-## Advanced Techniques
-
-### Error Handling and Fault Tolerance
-
-```javascript
-// Setup fault tolerance for all agents
-mcp__claude-flow__daa_fault_tolerance({
-  "agentId": "all",
-  "strategy": "auto-recovery"
-})
-
-// Error handling pattern
-try {
-  await mcp__claude-flow__task_orchestrate({
-    "task": "complex operation",
-    "strategy": "parallel",
-    "priority": "high"
-  })
-} catch (error) {
-  // Check swarm health
-  const status = await mcp__claude-flow__swarm_status({})
-
-  // Analyze error patterns
-  await mcp__claude-flow__error_analysis({
-    "logs": [error.message]
-  })
-
-  // Auto-recovery attempt
-  if (status.healthy) {
-    await mcp__claude-flow__task_orchestrate({
-      "task": "retry failed operation",
-      "strategy": "sequential"
-    })
-  }
-}
-```
-
-### Memory and State Management
-
-```javascript
-// Cross-session persistence
-mcp__claude-flow__memory_persist({
-  "sessionId": "swarm-session-001"
-})
-
-// Namespace management for different swarms
-mcp__claude-flow__memory_namespace({
-  "namespace": "research-swarm",
-  "action": "create"
-})
-
-// Create state snapshot
-mcp__claude-flow__state_snapshot({
-  "name": "development-checkpoint-1"
-})
-
-// Restore from snapshot if needed
-mcp__claude-flow__context_restore({
-  "snapshotId": "development-checkpoint-1"
-})
-
-// Backup memory stores
-mcp__claude-flow__memory_backup({
-  "path": "/workspaces/claude-code-flow/backups/swarm-memory.json"
-})
-```
-
-### Neural Pattern Learning
-
-```javascript
-// Train neural patterns from successful workflows
-mcp__claude-flow__neural_train({
-  "pattern_type": "coordination",
-  "training_data": JSON.stringify(successfulWorkflows),
-  "epochs": 50
-})
-
-// Adaptive learning from experience
-mcp__claude-flow__learning_adapt({
-  "experience": {
-    "workflow": "research-to-report",
-    "success": true,
-    "duration": 3600,
-    "quality": 0.95
-  }
-})
-
-// Pattern recognition for optimization
-mcp__claude-flow__pattern_recognize({
-  "data": workflowMetrics,
-  "patterns": ["bottleneck", "optimization-opportunity", "efficiency-gain"]
-})
-```
-
-### Workflow Automation
-
-```javascript
-// Create reusable workflow
-mcp__claude-flow__workflow_create({
-  "name": "full-stack-development",
-  "steps": [
-    { "phase": "design", "agents": ["architect"] },
-    { "phase": "implement", "agents": ["backend-dev", "frontend-dev"], "parallel": true },
-    { "phase": "test", "agents": ["tester", "security-tester"], "parallel": true },
-    { "phase": "review", "agents": ["reviewer"] },
-    { "phase": "deploy", "agents": ["devops"] }
-  ],
-  "triggers": ["on-commit", "scheduled-daily"]
-})
-
-// Setup automation rules
-mcp__claude-flow__automation_setup({
-  "rules": [
-    {
-      "trigger": "file-changed",
-      "pattern": "*.js",
-      "action": "run-tests"
-    },
-    {
-      "trigger": "PR-created",
-      "action": "code-review-swarm"
-    }
-  ]
-})
-
-// Event-driven triggers
-mcp__claude-flow__trigger_setup({
-  "events": ["code-commit", "PR-merge", "deployment"],
-  "actions": ["test", "analyze", "document"]
-})
-```
-
-### Performance Optimization
-
-```javascript
-// Topology optimization
-mcp__claude-flow__topology_optimize({
-  "swarmId": "current-swarm"
-})
-
-// Load balancing
-mcp__claude-flow__load_balance({
-  "swarmId": "development-swarm",
-  "tasks": taskQueue
-})
-
-// Agent coordination sync
-mcp__claude-flow__coordination_sync({
-  "swarmId": "development-swarm"
-})
-
-// Auto-scaling
-mcp__claude-flow__swarm_scale({
-  "swarmId": "development-swarm",
-  "targetSize": 12
-})
-```
-
-### Monitoring and Metrics
-
-```javascript
-// Real-time swarm monitoring
-mcp__claude-flow__swarm_monitor({
-  "swarmId": "active-swarm",
-  "interval": 3000
-})
-
-// Collect comprehensive metrics
-mcp__claude-flow__metrics_collect({
-  "components": ["agents", "tasks", "memory", "performance"]
-})
-
-// Health monitoring
-mcp__claude-flow__health_check({
-  "components": ["swarm", "agents", "neural", "memory"]
-})
-
-// Usage statistics
-mcp__claude-flow__usage_stats({
-  "component": "swarm-orchestration"
-})
-
-// Trend analysis
-mcp__claude-flow__trend_analysis({
-  "metric": "agent-performance",
-  "period": "7d"
-})
-```
-
-## Best Practices
-
-### 1. Choosing the Right Topology
-
-- **Mesh**: Research, brainstorming, collaborative analysis
-- **Hierarchical**: Structured development, sequential workflows
-- **Star**: Testing, validation, centralized coordination
-- **Ring**: Pipeline processing, staged workflows
-
-### 2. Agent Specialization
-
-- Assign specific capabilities to each agent
-- Avoid overlapping responsibilities
-- Use coordination agents for complex workflows
-- Leverage memory for agent communication
-
-### 3. Parallel Execution
-
-- Identify independent tasks for parallelization
-- Use sequential execution for dependent tasks
-- Monitor resource usage during parallel execution
-- Implement proper error handling
-
-### 4. Memory Management
-
-- Use namespaces to organize memory
-- Set appropriate TTL values
-- Create regular backups
-- Implement state snapshots for checkpoints
-
-### 5. Monitoring and Optimization
-
-- Monitor swarm health regularly
-- Collect and analyze metrics
-- Optimize topology based on performance
-- Use neural patterns to learn from success
-
-### 6. Error Recovery
-
-- Implement fault tolerance strategies
-- Use auto-recovery mechanisms
-- Analyze error patterns
-- Create fallback workflows
-
-## Real-World Examples
-
-### Example 1: AI Research Project
-```javascript
-// Research AI trends, analyze findings, generate report
-mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })
-// Spawn: 2 researchers, 2 analysts, 1 synthesizer, 1 documenter
-// Parallel gather → Analyze patterns → Synthesize → Report
-```
-
-### Example 2: Full-Stack Application
-```javascript
-// Build complete web application with testing
-mcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 8 })
-// Spawn: 1 architect, 2 devs, 1 db engineer, 2 testers, 1 reviewer, 1 devops
-// Design → Parallel implement → Test → Review → Deploy
-```
-
-### Example 3: Security Audit
-```javascript
-// Comprehensive security analysis
-mcp__claude-flow__swarm_init({ topology: "star", maxAgents: 5 })
-// Spawn: 1 coordinator, 1 code analyzer, 1 security scanner, 1 penetration tester, 1 reporter
-// Parallel scan → Vulnerability analysis → Penetration test → Report
-```
-
-### Example 4: Performance Optimization
-```javascript
-// Identify and fix performance bottlenecks
-mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 4 })
-// Spawn: 1 profiler, 1 bottleneck analyzer, 1 optimizer, 1 tester
-// Profile → Identify bottlenecks → Optimize → Validate
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**Issue**: Swarm agents not coordinating properly
-**Solution**: Check topology selection, verify memory usage, enable monitoring
-
-**Issue**: Parallel execution failing
-**Solution**: Verify task dependencies, check resource limits, implement error handling
-
-**Issue**: Memory persistence not working
-**Solution**: Verify namespaces, check TTL settings, ensure backup configuration
-
-**Issue**: Performance degradation
-**Solution**: Optimize topology, reduce agent count, analyze bottlenecks
-
-## Related Skills
-
-- `sparc-methodology` - Systematic development workflow
-- `github-integration` - Repository management and automation
-- `neural-patterns` - AI-powered coordination optimization
-- `memory-management` - Cross-session state persistence
-
-## References
-
-- [Claude Flow Documentation](https://github.com/ruvnet/claude-flow)
-- [Swarm Orchestration Guide](https://github.com/ruvnet/claude-flow/wiki/swarm)
-- [MCP Tools Reference](https://github.com/ruvnet/claude-flow/wiki/mcp)
-- [Performance Optimization](https://github.com/ruvnet/claude-flow/wiki/performance)
-
----
-
-**Version**: 2.0.0
-**Last Updated**: 2025-10-19
-**Skill Level**: Advanced
-**Estimated Learning Time**: 2-3 hours