foxhunt/WAVE_D_EFFICIENT_IMPLEMENTATION_PLAN.md

Wave D Efficient Implementation Plan

Date: 2025-10-17 Principle: REUSE existing infrastructure, implement ONLY missing components

Research Summary (5 Parallel Agents Complete)

Code Reuse Analysis: 93.1% Existing Infrastructure

Existing Production-Ready Code (10,019+ lines):

• adaptive-strategy/src/regime/mod.rs: 4,800 lines (framework complete)
• adaptive-strategy/src/ensemble/mod.rs: 757 lines (regime-aware)
• adaptive-strategy/src/risk/mod.rs: 1,442 lines (regime-aware position sizing)
• ml/src/features/*: 3,000+ lines (all statistical utilities)

Missing Components (7% new code, ~400 lines):

1. CUSUM structural break detector
2. ADX technical indicator
3. Integration wiring

---

Implementation Strategy: 3 Focused Agents (NOT 20)

Agent D1: CUSUM Detector (TDD, 2 days)

File: adaptive-strategy/src/regime/cusum_detector.rs Reuses: RegimeDetectionModel trait (already exists) Lines: 200-300 Tests: 15 tests (following existing patterns in adaptive-strategy/tests/)

Implementation:

pub struct CUSUMDetector {
    target_mean: f64,
    positive_sum: f64,  // Two-sided CUSUM
    negative_sum: f64,
    drift_threshold: f64,
    detection_threshold: f64,
}

impl RegimeDetectionModel for CUSUMDetector {
    fn detect(&self, features: &[f64]) -> MarketRegime {
        // Use existing MarketRegime::StructuralBreak
    }
}

Reuses:

• MarketRegime enum (add StructuralBreak variant if missing)
• RegimeDetectionModel trait
• Existing test patterns from regime_transition_tests.rs

---

Agent D2: ADX Indicator (TDD, 1 day)

File: ml/src/features/feature_extraction.rs (extend existing) Reuses: ATR implementation (already exists at line 267-300) Lines: 50-80 Tests: 8 tests (following Wave C patterns)

Implementation:

pub fn compute_adx(bars: &VecDeque<OHLCVBar>, period: usize) -> f64 {
    // Reuse compute_atr() for TR calculation
    let atr = compute_atr(bars, period);
    
    // Implement +DI, -DI, DX, ADX
    // Pattern: Same as compute_rsi() at line 132-177
}

Reuses:

• compute_atr() function (lines 267-300)
• VecDeque<OHLCVBar> pattern (same as RSI, ATR, Bollinger)
• Test structure from test_compute_rsi() and test_compute_atr()

---

Agent D3: Integration Wiring (TDD, 1 day)

File: adaptive-strategy/src/regime/mod.rs (extend) Reuses: StrategyAdaptationManager (90% complete) Lines: 100-150 Tests: 12 tests (extend regime_transition_tests.rs)

Tasks:

1. Wire CUSUM detector into RegimeDetector
2. Add ADX to feature extraction pipeline
3. Update StrategyAdaptationManager configuration
4. Extend tests with structural break scenarios

Reuses:

• Entire StrategyAdaptationManager class (no modifications needed)
• RegimeTransitionTracker (no modifications needed)
• DynamicRiskAdjuster (no modifications needed)
• Existing test data generators from tests/common/mod.rs

---

TDD Red-Green-Refactor Workflow

Agent D1 (CUSUM):

Day 1 - Red:

1. Write 15 failing tests in adaptive-strategy/tests/cusum_detector_test.rs
2. Copy test structure from regime_transition_tests.rs
3. Use existing generate_price_series() helper

Day 1-2 - Green:

1. Implement CUSUMDetector struct
2. Implement RegimeDetectionModel trait
3. All 15 tests pass

Day 2 - Refactor:

1. Extract common code to utilities
2. Add documentation
3. Performance benchmark (<100μs target)

Agent D2 (ADX):

Day 1 - Red:

1. Write 8 failing tests in ml/tests/adx_test.rs
2. Follow test_compute_rsi() pattern

Day 1 - Green:

1. Implement compute_adx() function
2. Reuse compute_atr() for TR
3. All 8 tests pass

Day 1 - Refactor:

1. Optimize with existing MonotonicDeque utilities
2. Add to feature extraction pipeline

Agent D3 (Integration):

Day 1 - Red:

1. Write 12 failing integration tests
2. Test structural break detection end-to-end

Day 1 - Green:

1. Wire CUSUM into RegimeDetector
2. Add ADX to feature pipeline
3. All 12 tests pass

Day 1 - Refactor:

1. Update configuration schema
2. Add documentation
3. Performance validation

---

File Organization

New Files (3 total):

adaptive-strategy/src/regime/cusum_detector.rs          (200-300 lines)
adaptive-strategy/tests/cusum_detector_test.rs          (150-200 lines)
ml/tests/adx_test.rs                                     (80-100 lines)

Modified Files (2 total):

ml/src/features/feature_extraction.rs                   (+50-80 lines for ADX)
adaptive-strategy/tests/regime_transition_tests.rs      (+100-150 lines)

Total New Code: ~700 lines (vs 10,000+ reused)

---

Testing Strategy (Following Existing Patterns)

Unit Tests (35 total):

• CUSUM detector: 15 tests (pattern: cusum_test.rs)
• ADX indicator: 8 tests (pattern: test_compute_rsi())
• Integration: 12 tests (pattern: regime_transition_tests.rs)

Test Helpers (Already Exist):

// From tests/common/mod.rs
pub fn generate_price_series() -> Vec<f64>  // Synthetic data
pub fn generate_ohlcv_bars() -> VecDeque<OHLCVBar>  // OHLCV data
pub fn assert_approx_eq(a: f64, b: f64, epsilon: f64)  // Float comparison

Property-Based Tests:

// Already exists in Wave C tests
use proptest::prelude::*;
proptest! {
    #[test]
    fn test_cusum_invariants(data in vec(-10.0..10.0, 100..1000)) {
        // CUSUM >= 0, changepoint detection accuracy
    }
}

---

Performance Targets (Already Met by Existing Code)

Component	Target	Existing Performance	New Code
Autocorrelation	<50μs	✅ <50μs	Reuse
Volatility (3 types)	<100μs	✅ <100μs	Reuse
Rolling Stats	<100μs	✅ O(1) amortized	Reuse
Hurst Exponent	<200μs	✅ <200μs	Reuse
CUSUM	<100μs	🟡 Not implemented	Implement
ADX	<150μs	🟡 Not implemented	Implement
Regime Classification	<200μs	✅ Framework ready	Wire
Total Pipeline	<1.2ms	✅ <1ms (Wave C)	<200μs overhead

---

Timeline: 4 Days (NOT 10-13 hours from original plan)

Day 1: Agent D1 (CUSUM) - Red phase + partial Green Day 2: Agent D1 (CUSUM) - Green + Refactor, Agent D2 (ADX) - Red/Green/Refactor Day 3: Agent D3 (Integration) - Red/Green/Refactor Day 4: E2E testing, validation, documentation

Total: 4 days, 3 agents, ~700 lines new code

---

Success Criteria

Technical:

• ✅ All 35 tests passing (100% pass rate)
• ✅ CUSUM detects structural breaks within 5 bars
• ✅ ADX calculation matches TA-Lib reference (<1% error)
• ✅ Pipeline latency <1.2ms per bar (Wave C 1ms + Wave D 200μs)
• ✅ Zero code duplication (use existing utilities)

Business:

• ✅ Sharpe improvement: 1.0 → 1.5+ (50% gain)
• ✅ Regime classification accuracy >70%
• ✅ No regressions from Wave C (1101/1101 tests still passing)

---

Next Steps

1. Spawn 3 focused agents (D1: CUSUM, D2: ADX, D3: Integration)
2. Follow TDD red-green-refactor strictly
3. Reuse existing test patterns from Wave C and adaptive-strategy
4. No code duplication - use 50+ existing utility functions
5. 4-day delivery with production-ready code

---

Efficiency Gain: 93% code reuse (10,000+ lines) vs original 20-agent plan Development Time: 4 days vs 10-13 hours (more realistic) Code Quality: Production-ready (follows existing patterns)