┌──────────────────────────────────────────┐
│   Lead Agent (Orchestrator)              │
│   - Extended Thinking Mode               │
│   - Task Decomposition                   │
│   - Strategy Planning                    │
│   - Result Synthesis                     │
└────────────┬─────────────────────────────┘
             │
             ├─────> Parallel Subagent Execution
             │
    ┌────────┼────────┬────────┬────────┐
    │        │        │        │        │
    ▼        ▼        ▼        ▼        ▼
┌────────┐ ┌─────┐ ┌──────┐ ┌──────┐ ┌────┐
│Security│ │Code │ │Tester│ │DevOps│ │...│
│Auditor │ │Review│ │Agent │ │Agent │ │   │
└────────┘ └─────┘ └──────┘ └──────┘ └────┘
    │        │        │        │        │
    └────────┴────────┴────────┴────────┘
             │
             ▼
    ┌─────────────────┐
    │ Result Synthesis│
    │ & Aggregation   │
    └─────────────────┘

## Extended Thinking Process:
1. Analyze codebase complexity and scope
2. Determine required agents: security-auditor (primary), code-reviewer (secondary)
3. Plan parallel execution strategy
4. Define result aggregation approach

// Phase 1: Lead Agent Planning (với extended thinking)
Lead Agent (You):
  - Analyze request complexity
  - Decompose vào subtasks: vuln scanning, code review, compliance check
  - Decide: spawn 2 subagents parallel

// Phase 2: Spawn Subagents
Task 1 (Parallel):
  Agent: security-auditor
  Context: {
    projectPath: "./",
    scanDepth: "comprehensive",
    focus: ["authentication", "injection", "secrets"]
  }
  
Task 2 (Parallel):
  Agent: code-reviewer
  Context: {
    focus: "security",
    checkFor: ["OWASP", "CWE", "input-validation"]
  }

// Phase 3: Result Synthesis
Lead Agent:
  - Aggregate results từ 2 agents
  - Deduplicate findings
  - Prioritize by severity
  - Generate unified security report

# Security Review Report (Multi-Agent)

## Executive Summary
[Synthesized từ cả 2 agents]

## Critical Vulnerabilities (Aggregated)
### From security-auditor:
- [Finding 1 với evidence]

### From code-reviewer:
- [Finding 2 với code analysis]

## Confidence Scores
- security-auditor: 95% (deep scan)
- code-reviewer: 90% (static analysis)
- Combined confidence: 92%

## Audit Trail
- Agent 1: security-auditor @ 2025-01-09 20:30:15
- Agent 2: code-reviewer @ 2025-01-09 20:30:18
- Synthesis: lead-agent @ 2025-01-09 20:32:45

code-searcher → code-reviewer → tester → synthesis
  (analysis)    (quality check)  (validation)  (report)

// Sequential pipeline với dependencies

// Step 1: Codebase Analysis
Task.spawn({
  agent: "code-searcher",
  objective: "Analyze codebase structure, patterns, complexity",
  output: "analysis-summary.json"
})

// Step 2: Code Review (depends on Step 1)
Task.spawn({
  agent: "code-reviewer",
  objective: "Review code quality, best practices",
  context: analysis_from_step1,
  output: "review-report.md"
})

// Step 3: Test Validation (depends on Step 2)
Task.spawn({
  agent: "tester",
  objective: "Run test suite, check coverage",
  context: review_findings,
  output: "test-results.json"
})

// Step 4: Synthesis
Lead Agent:
  - Quality Score: calculate from all metrics
  - Technical Debt: aggregate findings
  - Action Items: prioritize recommendations

            planner-researcher (coordinator)
                      |
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
  tester      security-auditor  devops-engineer
  (pre-check)   (validation)    (deployment)

// Coordinator: planner-researcher
Task.spawn({
  agent: "planner-researcher",
  objective: "Create deployment plan và coordinate sub-agents",
  subtasks: [
    {
      agent: "tester",
      task: "Run full test suite + smoke tests",
      blocking: true  // Must pass trước khi deploy
    },
    {
      agent: "security-auditor", 
      task: "Security validation + CVE check",
      blocking: true
    },
    {
      agent: "devops-engineer",
      task: "Execute deployment với rollback plan",
      dependsOn: ["tester", "security-auditor"]
    }
  ]
})

// planner-researcher orchestrates và monitors
// Nếu test fail → abort deployment
// Nếu security issues → fix then retry
// Nếu deployment fail → auto rollback

// Parallel execution cho fast results
const tasks = await Promise.all([
  Task.spawn({
    agent: "devops-engineer",
    focus: "IaC validation, Terraform/K8s configs"
  }),
  Task.spawn({
    agent: "security-auditor",
    focus: "Infrastructure security, IAM policies"
  }),
  Task.spawn({
    agent: "database-specialist",
    focus: "Database configs, backup strategies"
  }),
  Task.spawn({
    agent: "performance-engineer",
    focus: "Resource sizing, cost optimization"
  })
])

// Lead agent synthesizes
Lead Agent:
  - Aggregate all findings
  - Cross-reference issues (e.g., security + cost)
  - Generate unified infrastructure report
  - Recommend optimization priorities

# Lead agent tự động orchestrate
/ea:security-review

# Workflow tự động:
# 1. Lead agent phân tích request
# 2. Spawn appropriate subagents
# 3. Parallel execution
# 4. Result synthesis

# Specify agents manually
/ea:custom --agents=security-auditor,code-reviewer,tester \
           --mode=parallel \
           --output=comprehensive

# Pipeline mode
/ea:custom --agents=code-searcher→code-reviewer→tester \
           --mode=pipeline

<thinking>
## Task Analysis
- Complexity: HIGH (multi-domain security review)
- Required expertise: Security + Code Quality
- Optimal strategy: Parallel execution với 2 specialized agents

## Agent Selection Reasoning
- security-auditor: Deep vulnerability scanning, OWASP compliance
- code-reviewer: Static analysis, code quality metrics
- Rationale: Complementary capabilities, no overlap

## Execution Plan
1. Spawn both agents parallel (independent subtasks)
2. security-auditor: Focus on auth, injection, secrets
3. code-reviewer: Focus on input validation, error handling
4. Wait for both completions
5. Synthesize results, deduplicate findings
6. Generate unified report với combined confidence scores

## Risk Assessment
- Risk: Potential duplicate findings → Mitigation: Deduplication logic
- Risk: Conflicting recommendations → Mitigation: Prioritize by severity
</thinking>

<execution>
[Spawn subagents và execute...]
</execution>

<synthesis>
[Aggregate results và generate final report]
</synthesis>

✅ Security Review Complete (Multi-Agent)

**Findings** (Aggregated):
- Critical: 2 issues
  - SQL Injection risk @ auth/login.ts:45 (security-auditor, confidence: 95%)
  - Hardcoded API key @ config/env.ts:12 (code-reviewer, confidence: 100%)
  
- High: 5 issues
- Medium: 12 issues

**Coverage**:
- Files scanned: 342
- security-auditor: 100% coverage (15min)
- code-reviewer: 100% coverage (12min)
- Total execution time: 15min (parallel)

**Audit Trail**:
- Workflow: security-review-20250109-203015
- Agents: security-auditor, code-reviewer
- Results: ./reports/security-review-20250109.md

❌ Security check complete
❌ Found some issues
❌ Review done

Lead → [Agent1, Agent2, Agent3] → Synthesis

Agent1 → Agent2 → Agent3 → Final

        Coordinator
         /    |    \
    Agent1  Agent2  Agent3
     /  \     |      / \
   A1.1 A1.2 A2.1  A3.1 A3.2

Agent1 ←→ Agent2
  ↕         ↕
Agent3 ←→ Agent4

// Store context cho agents khác
Task.spawn({
  agent: "context-manager",
  action: "store",
  data: {
    key: "security-findings",
    value: findings,
    sharedWith: ["code-reviewer", "tester"]
  }
})

// Retrieve context
Task.spawn({
  agent: "code-reviewer",
  beforeExecution: {
    retrieveContext: "security-findings"
  }
})

# List active agents
/ea:status

# Output:
# Active Agents:
# - security-auditor: RUNNING (8min 32s)
# - code-reviewer: COMPLETED (12min)
# - tester: QUEUED

# Show workflow history
/ea:history --limit=10

# Output shows:
# - Workflow ID
# - Agents used
# - Execution time
# - Results location

## Agent Performance Report

| Agent | Avg Time | Success Rate | Token Usage |
|-------|----------|--------------|-------------|
| security-auditor | 15min | 98% | ~45K tokens |
| code-reviewer | 12min | 99% | ~38K tokens |
| tester | 8min | 95% | ~25K tokens |

.equilateral/
├── workflows/
│   ├── security-review-20250109-203015.json
│   └── code-quality-20250109-210430.json
├── results/
│   ├── security-review-20250109.md
│   └── code-quality-20250109.md
└── audit/
    ├── agent-logs/
    │   ├── security-auditor-20250109.log
    │   └── code-reviewer-20250109.log
    └── performance-metrics.json

reports/
├── security-review-20250109.md
└── quality-gate-20250109.md

// Yêu cầu external implementation
const AgentOrchestrator = require('./equilateral-core/AgentOrchestrator');
orchestrator.registerAgent(new SecurityScannerAgent());

// Sử dụng agents có sẵn
Task.spawn({
  agent: "security-auditor",
  objective: "Comprehensive security scan"
})