agentic-flow 1.8.15 → 1.9.0

package/CLAUDE.md

@@ -0,0 +1,354 @@
+# Claude Code Configuration - SPARC Development Environment
+
+## 🚨 CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT
+
+**ABSOLUTE RULES**:
+1. ALL operations MUST be concurrent/parallel in a single message
+2. **NEVER save working files, text/mds and tests to the root folder**
+3. ALWAYS organize files in appropriate subdirectories
+4. **USE CLAUDE CODE'S TASK TOOL** for spawning agents concurrently, not just MCP
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**MANDATORY PATTERNS:**
+- **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+- **Task tool (Claude Code)**: ALWAYS spawn ALL agents in ONE message with full instructions
+- **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+- **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+- **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### 🎯 CRITICAL: Claude Code Task Tool for Agent Execution
+
+**Claude Code's Task tool is the PRIMARY way to spawn agents:**
+```javascript
+// ✅ CORRECT: Use Claude Code's Task tool for parallel agent execution
+[Single Message]:
+  Task("Research agent", "Analyze requirements and patterns...", "researcher")
+  Task("Coder agent", "Implement core features...", "coder")
+  Task("Tester agent", "Create comprehensive tests...", "tester")
+  Task("Reviewer agent", "Review code quality...", "reviewer")
+  Task("Architect agent", "Design system architecture...", "system-architect")
+```
+
+**MCP tools are ONLY for coordination setup:**
+- `mcp__claude-flow__swarm_init` - Initialize coordination topology
+- `mcp__claude-flow__agent_spawn` - Define agent types for coordination
+- `mcp__claude-flow__task_orchestrate` - Orchestrate high-level workflows
+
+### 📁 File Organization Rules
+
+**NEVER save to root folder. Use these directories:**
+- `/src` - Source code files
+- `/tests` - Test files
+- `/docs` - Documentation and markdown files
+- `/config` - Configuration files
+- `/scripts` - Utility scripts
+- `/examples` - Example code
+
+## Project Overview
+
+This project uses SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with Claude-Flow orchestration for systematic Test-Driven Development.
+
+## SPARC Commands
+
+### Core Commands
+- `npx claude-flow sparc modes` - List available modes
+- `npx claude-flow sparc run <mode> "<task>"` - Execute specific mode
+- `npx claude-flow sparc tdd "<feature>"` - Run complete TDD workflow
+- `npx claude-flow sparc info <mode>` - Get mode details
+
+### Batchtools Commands
+- `npx claude-flow sparc batch <modes> "<task>"` - Parallel execution
+- `npx claude-flow sparc pipeline "<task>"` - Full pipeline processing
+- `npx claude-flow sparc concurrent <mode> "<tasks-file>"` - Multi-task processing
+
+### Build Commands
+- `npm run build` - Build project
+- `npm run test` - Run tests
+- `npm run lint` - Linting
+- `npm run typecheck` - Type checking
+
+## SPARC Workflow Phases
+
+1. **Specification** - Requirements analysis (`sparc run spec-pseudocode`)
+2. **Pseudocode** - Algorithm design (`sparc run spec-pseudocode`)
+3. **Architecture** - System design (`sparc run architect`)
+4. **Refinement** - TDD implementation (`sparc tdd`)
+5. **Completion** - Integration (`sparc run integration`)
+
+## Code Style & Best Practices
+
+- **Modular Design**: Files under 500 lines
+- **Environment Safety**: Never hardcode secrets
+- **Test-First**: Write tests before implementation
+- **Clean Architecture**: Separate concerns
+- **Documentation**: Keep updated
+
+## 🚀 Available Agents (54 Total)
+
+### Core Development
+`coder`, `reviewer`, `tester`, `planner`, `researcher`
+
+### Swarm Coordination
+`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`, `swarm-memory-manager`
+
+### Consensus & Distributed
+`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`, `crdt-synchronizer`, `quorum-manager`, `security-manager`
+
+### Performance & Optimization
+`perf-analyzer`, `performance-benchmarker`, `task-orchestrator`, `memory-coordinator`, `smart-agent`
+
+### GitHub & Repository
+`github-modes`, `pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`, `workflow-automation`, `project-board-sync`, `repo-architect`, `multi-repo-swarm`
+
+### SPARC Methodology
+`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`
+
+### Specialized Development
+`backend-dev`, `mobile-dev`, `ml-developer`, `cicd-engineer`, `api-docs`, `system-architect`, `code-analyzer`, `base-template-generator`
+
+### Testing & Validation
+`tdd-london-swarm`, `production-validator`
+
+### Migration & Planning
+`migration-planner`, `swarm-init`
+
+## 🎯 Claude Code vs MCP Tools
+
+### Claude Code Handles ALL EXECUTION:
+- **Task tool**: Spawn and run agents concurrently for actual work
+- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
+- Code generation and programming
+- Bash commands and system operations
+- Implementation work
+- Project navigation and analysis
+- TodoWrite and task management
+- Git operations
+- Package management
+- Testing and debugging
+
+### MCP Tools ONLY COORDINATE:
+- Swarm initialization (topology setup)
+- Agent type definitions (coordination patterns)
+- Task orchestration (high-level planning)
+- Memory management
+- Neural features
+- Performance tracking
+- GitHub integration
+
+**KEY**: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.
+
+## 🚀 Quick Setup
+
+```bash
+# Add MCP servers (Claude Flow required, others optional)
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+claude mcp add ruv-swarm npx ruv-swarm mcp start  # Optional: Enhanced coordination
+claude mcp add flow-nexus npx flow-nexus@latest mcp start  # Optional: Cloud features
+```
+
+## MCP Tool Categories
+
+### Coordination
+`swarm_init`, `agent_spawn`, `task_orchestrate`
+
+### Monitoring
+`swarm_status`, `agent_list`, `agent_metrics`, `task_status`, `task_results`
+
+### Memory & Neural
+`memory_usage`, `neural_status`, `neural_train`, `neural_patterns`
+
+### GitHub Integration
+`github_swarm`, `repo_analyze`, `pr_enhance`, `issue_triage`, `code_review`
+
+### System
+`benchmark_run`, `features_detect`, `swarm_monitor`
+
+### Flow-Nexus MCP Tools (Optional Advanced Features)
+Flow-Nexus extends MCP capabilities with 70+ cloud-based orchestration tools:
+
+**Key MCP Tool Categories:**
+- **Swarm & Agents**: `swarm_init`, `swarm_scale`, `agent_spawn`, `task_orchestrate`
+- **Sandboxes**: `sandbox_create`, `sandbox_execute`, `sandbox_upload` (cloud execution)
+- **Templates**: `template_list`, `template_deploy` (pre-built project templates)
+- **Neural AI**: `neural_train`, `neural_patterns`, `seraphina_chat` (AI assistant)
+- **GitHub**: `github_repo_analyze`, `github_pr_manage` (repository management)
+- **Real-time**: `execution_stream_subscribe`, `realtime_subscribe` (live monitoring)
+- **Storage**: `storage_upload`, `storage_list` (cloud file management)
+
+**Authentication Required:**
+- Register: `mcp__flow-nexus__user_register` or `npx flow-nexus@latest register`
+- Login: `mcp__flow-nexus__user_login` or `npx flow-nexus@latest login`
+- Access 70+ specialized MCP tools for advanced orchestration
+
+## 🚀 Agent Execution Flow with Claude Code
+
+### The Correct Pattern:
+
+1. **Optional**: Use MCP tools to set up coordination topology
+2. **REQUIRED**: Use Claude Code's Task tool to spawn agents that do actual work
+3. **REQUIRED**: Each agent runs hooks for coordination
+4. **REQUIRED**: Batch all operations in single messages
+
+### Example Full-Stack Development:
+
+```javascript
+// Single message with all agent spawning via Claude Code's Task tool
+[Parallel Agent Execution]:
+  Task("Backend Developer", "Build REST API with Express. Use hooks for coordination.", "backend-dev")
+  Task("Frontend Developer", "Create React UI. Coordinate with backend via memory.", "coder")
+  Task("Database Architect", "Design PostgreSQL schema. Store schema in memory.", "code-analyzer")
+  Task("Test Engineer", "Write Jest tests. Check memory for API contracts.", "tester")
+  Task("DevOps Engineer", "Setup Docker and CI/CD. Document in memory.", "cicd-engineer")
+  Task("Security Auditor", "Review authentication. Report findings via hooks.", "reviewer")
+  
+  // All todos batched together
+  TodoWrite { todos: [...8-10 todos...] }
+  
+  // All file operations together
+  Write "backend/server.js"
+  Write "frontend/App.jsx"
+  Write "database/schema.sql"
+```
+
+## 📋 Agent Coordination Protocol
+
+### Every Agent Spawned via Task Tool MUST:
+
+**1️⃣ BEFORE Work:**
+```bash
+npx claude-flow@alpha hooks pre-task --description "[task]"
+npx claude-flow@alpha hooks session-restore --session-id "swarm-[id]"
+```
+
+**2️⃣ DURING Work:**
+```bash
+npx claude-flow@alpha hooks post-edit --file "[file]" --memory-key "swarm/[agent]/[step]"
+npx claude-flow@alpha hooks notify --message "[what was done]"
+```
+
+**3️⃣ AFTER Work:**
+```bash
+npx claude-flow@alpha hooks post-task --task-id "[task]"
+npx claude-flow@alpha hooks session-end --export-metrics true
+```
+
+## 🎯 Concurrent Execution Examples
+
+### ✅ CORRECT WORKFLOW: MCP Coordinates, Claude Code Executes
+
+```javascript
+// Step 1: MCP tools set up coordination (optional, for complex tasks)
+[Single Message - Coordination Setup]:
+  mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
+  mcp__claude-flow__agent_spawn { type: "researcher" }
+  mcp__claude-flow__agent_spawn { type: "coder" }
+  mcp__claude-flow__agent_spawn { type: "tester" }
+
+// Step 2: Claude Code Task tool spawns ACTUAL agents that do the work
+[Single Message - Parallel Agent Execution]:
+  // Claude Code's Task tool spawns real agents concurrently
+  Task("Research agent", "Analyze API requirements and best practices. Check memory for prior decisions.", "researcher")
+  Task("Coder agent", "Implement REST endpoints with authentication. Coordinate via hooks.", "coder")
+  Task("Database agent", "Design and implement database schema. Store decisions in memory.", "code-analyzer")
+  Task("Tester agent", "Create comprehensive test suite with 90% coverage.", "tester")
+  Task("Reviewer agent", "Review code quality and security. Document findings.", "reviewer")
+  
+  // Batch ALL todos in ONE call
+  TodoWrite { todos: [
+    {id: "1", content: "Research API patterns", status: "in_progress", priority: "high"},
+    {id: "2", content: "Design database schema", status: "in_progress", priority: "high"},
+    {id: "3", content: "Implement authentication", status: "pending", priority: "high"},
+    {id: "4", content: "Build REST endpoints", status: "pending", priority: "high"},
+    {id: "5", content: "Write unit tests", status: "pending", priority: "medium"},
+    {id: "6", content: "Integration tests", status: "pending", priority: "medium"},
+    {id: "7", content: "API documentation", status: "pending", priority: "low"},
+    {id: "8", content: "Performance optimization", status: "pending", priority: "low"}
+  ]}
+  
+  // Parallel file operations
+  Bash "mkdir -p app/{src,tests,docs,config}"
+  Write "app/package.json"
+  Write "app/src/server.js"
+  Write "app/tests/server.test.js"
+  Write "app/docs/API.md"
+```
+
+### ❌ WRONG (Multiple Messages):
+```javascript
+Message 1: mcp__claude-flow__swarm_init
+Message 2: Task("agent 1")
+Message 3: TodoWrite { todos: [single todo] }
+Message 4: Write "file.js"
+// This breaks parallel coordination!
+```
+
+## Performance Benefits
+
+- **84.8% SWE-Bench solve rate**
+- **32.3% token reduction**
+- **2.8-4.4x speed improvement**
+- **27+ neural models**
+
+## Hooks Integration
+
+### Pre-Operation
+- Auto-assign agents by file type
+- Validate commands for safety
+- Prepare resources automatically
+- Optimize topology by complexity
+- Cache searches
+
+### Post-Operation
+- Auto-format code
+- Train neural patterns
+- Update memory
+- Analyze performance
+- Track token usage
+
+### Session Management
+- Generate summaries
+- Persist state
+- Track metrics
+- Restore context
+- Export workflows
+
+## Advanced Features (v2.0.0)
+
+- 🚀 Automatic Topology Selection
+- ⚡ Parallel Execution (2.8-4.4x speed)
+- 🧠 Neural Training
+- 📊 Bottleneck Analysis
+- 🤖 Smart Auto-Spawning
+- 🛡️ Self-Healing Workflows
+- 💾 Cross-Session Memory
+- 🔗 GitHub Integration
+
+## Integration Tips
+
+1. Start with basic swarm init
+2. Scale agents gradually
+3. Use memory for context
+4. Monitor progress regularly
+5. Train patterns from success
+6. Enable hooks automation
+7. Use GitHub tools first
+
+## Support
+
+- Documentation: https://github.com/ruvnet/claude-flow
+- Issues: https://github.com/ruvnet/claude-flow/issues
+- Flow-Nexus Platform: https://flow-nexus.ruv.io (registration required for cloud features)
+
+---
+
+Remember: **Claude Flow coordinates, Claude Code creates!**
+
+# important-instruction-reminders
+Do what has been asked; nothing more, nothing less.
+NEVER create files unless they're absolutely necessary for achieving your goal.
+ALWAYS prefer editing an existing file to creating a new one.
+NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+Never save working files, text/mds and tests to the root folder.
+
+don't use labels for github issues

package/README.md

@@ -53,10 +53,12 @@ Most AI coding agents are **painfully slow** and **frustratingly forgetful**. Th
 | Component | Description | Performance | Documentation |
 |-----------|-------------|-------------|---------------|
 | **Agent Booster** | Ultra-fast local code transformations via Rust/WASM (auto-detects edits) | 352x faster, $0 cost | [Docs](https://github.com/ruvnet/agentic-flow/tree/main/agent-booster) |
-| **AgentDB** | State-of-the-art memory with causal reasoning, reflexion, and skill learning | p95 < 50ms, 80% hit rate | [Docs](./src/agentdb/README.md) |
+| **AgentDB** | State-of-the-art memory with causal reasoning, reflexion, and skill learning | p95 < 50ms, 80% hit rate | [Docs](./agentic-flow/src/agentdb/README.md) |
 | **ReasoningBank** | Persistent learning memory system with semantic search | 46% faster, 100% success | [Docs](https://github.com/ruvnet/agentic-flow/tree/main/agentic-flow/src/reasoningbank) |
 | **Multi-Model Router** | Intelligent cost optimization across 100+ LLMs | 85-99% cost savings | [Docs](https://github.com/ruvnet/agentic-flow/tree/main/agentic-flow/src/router) |
 | **QUIC Transport** | Ultra-low latency agent communication via Rust/WASM QUIC protocol | 50-70% faster than TCP, 0-RTT | [Docs](https://github.com/ruvnet/agentic-flow/tree/main/crates/agentic-flow-quic) |
+| **Federation Hub** 🆕 | Ephemeral agents (5s-15min lifetime) with persistent cross-agent memory | Infinite scale, 0 waste | [Docs](./agentic-flow/src/federation) |
+| **Swarm Optimization** 🆕 | Self-learning parallel execution with AI topology selection | 3-5x speedup, auto-optimizes | [Docs](./docs/swarm-optimization-report.md) |
 
 **CLI Usage**:
 - **AgentDB**: Full CLI with 17 commands (`npx agentdb <command>`)
@@ -64,6 +66,8 @@ Most AI coding agents are **painfully slow** and **frustratingly forgetful**. Th
 - **Agent Booster**: Automatic on code edits
 - **ReasoningBank**: API only
 - **QUIC Transport**: API only
+- **Federation Hub**: `npx agentic-flow federation start` 🆕
+- **Swarm Optimization**: Automatic with parallel execution 🆕
 
 **Programmatic**: All components importable: `agentic-flow/agentdb`, `agentic-flow/router`, `agentic-flow/reasoningbank`, `agentic-flow/agent-booster`, `agentic-flow/transport/quic`
 
@@ -78,12 +82,22 @@ npx agentdb learner run
 # CLI: Auto-optimization (Agent Booster runs automatically on code edits)
 npx agentic-flow --agent coder --task "Build a REST API" --optimize
 
+# CLI: Federation Hub (ephemeral agents with persistent memory)
+npx agentic-flow federation start       # Start hub server
+npx agentic-flow federation spawn       # Spawn ephemeral agent
+npx agentic-flow federation stats       # View statistics
+
+# CLI: Swarm Optimization (automatic parallel execution)
+# Self-learning system recommends optimal topology (mesh, hierarchical, ring)
+# Achieves 3-5x speedup with auto-optimization from learned patterns
+
 # Programmatic: Import any component
 import { ReflexionMemory, SkillLibrary, CausalMemoryGraph } from 'agentic-flow/agentdb';
 import { ModelRouter } from 'agentic-flow/router';
 import * as reasoningbank from 'agentic-flow/reasoningbank';
 import { AgentBooster } from 'agentic-flow/agent-booster';
 import { QuicTransport } from 'agentic-flow/transport/quic';
+import { SwarmLearningOptimizer, autoSelectSwarmConfig } from 'agentic-flow/hooks/swarm-learning-optimizer';
 ```
 
 Built on **[Claude Agent SDK](https://docs.claude.com/en/api/agent-sdk)** by Anthropic, powered by **[Claude Flow](https://github.com/ruvnet/claude-flow)** (101 MCP tools), **[Flow Nexus](https://github.com/ruvnet/flow-nexus)** (96 cloud tools), **[OpenRouter](https://openrouter.ai)** (100+ LLM models), **[Google Gemini](https://ai.google.dev)** (fast, cost-effective inference), **[Agentic Payments](https://github.com/ruvnet/agentic-flow/tree/main/agentic-payments)** (payment authorization), and **[ONNX Runtime](https://onnxruntime.ai)** (free local CPU or GPU inference).

package/agentic-flow/.agentdb-instructions.md

@@ -0,0 +1,66 @@
+# 🚀 How to Run AgentDB CLI
+
+## Quick Commands (from ANY directory):
+
+### Option 1: Change to the correct directory first
+```bash
+cd /workspaces/agentic-flow/agentic-flow
+node dist/agentdb/cli/agentdb-cli.js --help
+```
+
+### Option 2: Use the launcher script (from anywhere)
+```bash
+/workspaces/agentic-flow/agentic-flow/run-agentdb.sh --help
+```
+
+### Option 3: Create a global alias (add to ~/.bashrc)
+```bash
+alias agentdb-new='node /workspaces/agentic-flow/agentic-flow/dist/agentdb/cli/agentdb-cli.js'
+# Then use: agentdb-new --help
+```
+
+## Current Directory Issue
+
+You tried to run from: `/workspaces/agentic-flow/packages/agentdb`
+But the CLI is in: `/workspaces/agentic-flow/agentic-flow`
+
+The `packages/agentdb` directory is the OLD AgentDB package.
+The NEW CLI with frontier features is in the `agentic-flow` subdirectory.
+
+## Quick Test
+
+```bash
+# From anywhere:
+cd /workspaces/agentic-flow/agentic-flow
+node dist/agentdb/cli/agentdb-cli.js --help
+
+# Should show:
+# █▀█ █▀▀ █▀▀ █▄░█ ▀█▀ █▀▄ █▄▄
+# █▀█ █▄█ ██▄ █░▀█ ░█░ █▄▀ █▄█
+#
+# AgentDB CLI - Frontier Memory Features
+```
+
+## Run the Test Suite
+
+```bash
+cd /workspaces/agentic-flow/agentic-flow
+./scripts/test-agentdb.sh
+```
+
+## Directory Structure
+
+```
+/workspaces/agentic-flow/
+├── agentic-flow/              ← NEW CLI IS HERE
+│   ├── dist/
+│   │   └── agentdb/
+│   │       └── cli/
+│   │           └── agentdb-cli.js  ← THIS IS THE NEW CLI
+│   ├── scripts/
+│   │   └── test-agentdb.sh
+│   └── run-agentdb.sh         ← USE THIS LAUNCHER
+│
+└── packages/
+    └── agentdb/               ← OLD PACKAGE (ignore)
+```

package/agentic-flow/.claude/agents/analysis/code-analyzer.md

@@ -0,0 +1,209 @@
+---
+name: code-analyzer
+type: code-analyzer
+color: indigo
+priority: high
+hooks:
+  pre: |
+    npx claude-flow@alpha hooks pre-task --description "Code analysis agent starting: ${description}" --auto-spawn-agents false
+  post: |
+    npx claude-flow@alpha hooks post-task --task-id "analysis-${timestamp}" --analyze-performance true
+metadata:
+  description: Advanced code quality analysis agent for comprehensive code reviews and improvements
+  capabilities:
+    - Code quality assessment and metrics
+    - Performance bottleneck detection
+    - Security vulnerability scanning
+    - Architectural pattern analysis
+    - Dependency analysis
+    - Code complexity evaluation
+    - Technical debt identification
+    - Best practices validation
+    - Code smell detection
+    - Refactoring suggestions
+---
+
+# Code Analyzer Agent
+
+An advanced code quality analysis specialist that performs comprehensive code reviews, identifies improvements, and ensures best practices are followed throughout the codebase.
+
+## Core Responsibilities
+
+### 1. Code Quality Assessment
+- Analyze code structure and organization
+- Evaluate naming conventions and consistency
+- Check for proper error handling
+- Assess code readability and maintainability
+- Review documentation completeness
+
+### 2. Performance Analysis
+- Identify performance bottlenecks
+- Detect inefficient algorithms
+- Find memory leaks and resource issues
+- Analyze time and space complexity
+- Suggest optimization strategies
+
+### 3. Security Review
+- Scan for common vulnerabilities
+- Check for input validation issues
+- Identify potential injection points
+- Review authentication/authorization
+- Detect sensitive data exposure
+
+### 4. Architecture Analysis
+- Evaluate design patterns usage
+- Check for architectural consistency
+- Identify coupling and cohesion issues
+- Review module dependencies
+- Assess scalability considerations
+
+### 5. Technical Debt Management
+- Identify areas needing refactoring
+- Track code duplication
+- Find outdated dependencies
+- Detect deprecated API usage
+- Prioritize technical improvements
+
+## Analysis Workflow
+
+### Phase 1: Initial Scan
+```bash
+# Comprehensive code scan
+npx claude-flow@alpha hooks pre-search --query "code quality metrics" --cache-results true
+
+# Load project context
+npx claude-flow@alpha memory retrieve --key "project/architecture"
+npx claude-flow@alpha memory retrieve --key "project/standards"
+```
+
+### Phase 2: Deep Analysis
+1. **Static Analysis**
+   - Run linters and type checkers
+   - Execute security scanners
+   - Perform complexity analysis
+   - Check test coverage
+
+2. **Pattern Recognition**
+   - Identify recurring issues
+   - Detect anti-patterns
+   - Find optimization opportunities
+   - Locate refactoring candidates
+
+3. **Dependency Analysis**
+   - Map module dependencies
+   - Check for circular dependencies
+   - Analyze package versions
+   - Identify security vulnerabilities
+
+### Phase 3: Report Generation
+```bash
+# Store analysis results
+npx claude-flow@alpha memory store --key "analysis/code-quality" --value "${results}"
+
+# Generate recommendations
+npx claude-flow@alpha hooks notify --message "Code analysis complete: ${summary}"
+```
+
+## Integration Points
+
+### With Other Agents
+- **Coder**: Provide improvement suggestions
+- **Reviewer**: Supply analysis data for reviews
+- **Tester**: Identify areas needing tests
+- **Architect**: Report architectural issues
+
+### With CI/CD Pipeline
+- Automated quality gates
+- Pull request analysis
+- Continuous monitoring
+- Trend tracking
+
+## Analysis Metrics
+
+### Code Quality Metrics
+- Cyclomatic complexity
+- Lines of code (LOC)
+- Code duplication percentage
+- Test coverage
+- Documentation coverage
+
+### Performance Metrics
+- Big O complexity analysis
+- Memory usage patterns
+- Database query efficiency
+- API response times
+- Resource utilization
+
+### Security Metrics
+- Vulnerability count by severity
+- Security hotspots
+- Dependency vulnerabilities
+- Code injection risks
+- Authentication weaknesses
+
+## Best Practices
+
+### 1. Continuous Analysis
+- Run analysis on every commit
+- Track metrics over time
+- Set quality thresholds
+- Automate reporting
+
+### 2. Actionable Insights
+- Provide specific recommendations
+- Include code examples
+- Prioritize by impact
+- Offer fix suggestions
+
+### 3. Context Awareness
+- Consider project standards
+- Respect team conventions
+- Understand business requirements
+- Account for technical constraints
+
+## Example Analysis Output
+
+```markdown
+## Code Analysis Report
+
+### Summary
+- **Quality Score**: 8.2/10
+- **Issues Found**: 47 (12 high, 23 medium, 12 low)
+- **Coverage**: 78%
+- **Technical Debt**: 3.2 days
+
+### Critical Issues
+1. **SQL Injection Risk** in `UserController.search()`
+   - Severity: High
+   - Fix: Use parameterized queries
+   
+2. **Memory Leak** in `DataProcessor.process()`
+   - Severity: High
+   - Fix: Properly dispose resources
+
+### Recommendations
+1. Refactor `OrderService` to reduce complexity
+2. Add input validation to API endpoints
+3. Update deprecated dependencies
+4. Improve test coverage in payment module
+```
+
+## Memory Keys
+
+The agent uses these memory keys for persistence:
+- `analysis/code-quality` - Overall quality metrics
+- `analysis/security` - Security scan results
+- `analysis/performance` - Performance analysis
+- `analysis/architecture` - Architectural review
+- `analysis/trends` - Historical trend data
+
+## Coordination Protocol
+
+When working in a swarm:
+1. Share analysis results immediately
+2. Coordinate with reviewers on PRs
+3. Prioritize critical security issues
+4. Track improvements over time
+5. Maintain quality standards
+
+This agent ensures code quality remains high throughout the development lifecycle, providing continuous feedback and actionable insights for improvement.