Verify All

---
description: Run complete verification suite with parallel sub-agents. Validates all components, runs tests, and ensures Phase 1 requirements are met. Runs continuously until all checks pass.
---

# Verify All Command

This command orchestrates a comprehensive verification of the entire DEX arbitrage detection system using specialized sub-agents running in parallel.

## What This Command Does

1. **Parallel Agent Verification** - Launch specialized agents for each component
2. **Continuous Iteration** - Run until all checks pass
3. **Test Execution** - Run all unit, integration, and validation tests
4. **Metrics Validation** - Ensure non-zero event flow
5. **Performance Verification** - Validate sub-100ms latency

## Verification Phases

### Phase 1: Component Verification (Parallel)

Launch these agents simultaneously:

```markdown
**Agent 1: graph-validator**
- Verify graph structure correctness
- Ensure start tokens always present
- Validate exchange rate accuracy
- Check copy-on-write snapshots

**Agent 2: bellman-ford-verifier**
- Verify algorithm correctness
- Test negative cycle detection
- Verify NO pool reuse in paths
- Validate path construction

**Agent 3: event-pipeline-validator**
- Verify WebSocket connection
- Validate Sync event subscription
- Check event parsing
- Ensure events reach graph

**Agent 4: metrics-analyzer**
- Analyze current metrics
- Identify zero-value issues
- Detect anomalies
- Recommend fixes

Phase 2: Test Execution

# Run all unit tests with coverage
go test -v -coverprofile=coverage.out ./...

# Run integration tests
go test -v -tags=integration -timeout=5m ./...

# Run benchmarks for performance
go test -v -bench=. -benchmem ./...

Phase 3: Validation Criteria Check

| Criterion | Required | Verification Method |
|-----------|----------|---------------------|
| Unit test coverage | ≥80% | go test -cover |
| Integration tests pass | 100% | go test -tags=integration |
| Events processed | >0 | Metrics check |
| Detections run | >0 | Metrics check |
| Start tokens present | Always | Graph inspection |
| No pool reuse | Verified | Test suite |
| Detection latency | <100ms | Benchmark |

Orchestration Workflow

┌─────────────────────────────────────────────────────────────────┐
│                     /verify-all Started                          │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│              Phase 1: Parallel Component Verification            │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│   │    Graph     │  │  Bellman-    │  │    Event     │          │
│   │  Validator   │  │    Ford      │  │   Pipeline   │          │
│   │              │  │  Verifier    │  │  Validator   │          │
│   └──────────────┘  └──────────────┘  └──────────────┘          │
│          │                 │                 │                   │
│          ▼                 ▼                 ▼                   │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │              Collect All Results                          │  │
│   └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                 Phase 2: Test Execution                          │
├─────────────────────────────────────────────────────────────────┤
│   1. Unit tests with coverage                                   │
│   2. Integration tests                                          │
│   3. Benchmarks                                                 │
│   4. Race detection                                             │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                 Phase 3: Criteria Check                          │
├─────────────────────────────────────────────────────────────────┤
│   ┌─────────────────────────────────────────────────────────┐   │
│   │  All criteria met?                                      │   │
│   │                                                         │   │
│   │  YES ──────────▶ ✅ VERIFICATION COMPLETE               │   │
│   │                                                         │   │
│   │  NO ───────────▶ 🔄 Generate fixes, iterate            │   │
│   └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
                              │
                              │ (if NO)
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Iteration Loop                                │
├─────────────────────────────────────────────────────────────────┤
│   1. Identify failing criteria                                  │
│   2. Generate specific fixes                                    │
│   3. Apply fixes                                                │
│   4. Re-run verification                                        │
│   5. Repeat until all pass (max 10 iterations)                  │
└─────────────────────────────────────────────────────────────────┘

How to Use

User: /verify-all

Claude: Starting comprehensive verification of DEX arbitrage system...

## Phase 1: Launching Parallel Verification Agents

### 🚀 Agent 1: graph-validator
[Running graph structure validation...]
[Checking start token prese