foxhunt/AGENT_WIRE12_SHAREDML_INTEGRATION.md

AGENT WIRE-12: SharedMLStrategy Integration Completeness Analysis

Agent: WIRE-12 Date: 2025-10-19 Status: ⛔ CRITICAL INTEGRATION GAPS IDENTIFIED Mission: Verify SharedMLStrategy uses all 225 features and adaptive components

---

🎯 Executive Summary

CRITICAL FINDING: SharedMLStrategy is NOT the "one single system" it was designed to be. Despite 1,233 lines of production-ready Wave D components (Kelly optimizer, regime detector, adaptive strategies), ZERO of these are integrated into the central orchestrator.

Integration Status: ❌ 0% COMPLETE

Component	Implementation	Integration	Gap Severity
225-Feature Extraction	✅ Complete (FeatureConfig)	❌ NOT used (30 features only)	CRITICAL
Kelly Optimizer	✅ Complete (305 lines)	❌ NOT wired	CRITICAL
Regime Detector	✅ Complete (117 lines)	❌ NOT wired	CRITICAL
Adaptive Position Sizer	✅ Complete (adaptive-strategy/)	❌ NOT wired	CRITICAL
MAMBA-2 Model	✅ Complete	❌ NOT registered	HIGH
PPO Model	✅ Complete	❌ NOT registered	HIGH
TFT Model	✅ Complete	❌ NOT registered	HIGH

Deployment Blocker: This gap renders Wave D UNDEPLOYABLE. The "92% READY" status in deployment checklists is a VANITY METRIC that ignores complete lack of system integration.

---

📋 Detailed Findings

1. ❌ CRITICAL: Hardcoded 30-Feature Extraction (NOT 225)

Evidence from Code:

// File: common/src/ml_strategy.rs:1385
pub fn new(lookback_periods: usize, min_confidence_threshold: f64) -> Self {
    Self {
        models: Arc::new(RwLock::new(models)),
        feature_extractor: Arc::new(RwLock::new(
            MLFeatureExtractor::new(lookback_periods)  // ⛔ HARDCODED 30 FEATURES
        )),
        model_performance: Arc::new(RwLock::new(HashMap::new())),
        min_confidence_threshold,
    }
}

// File: common/src/ml_strategy.rs:146-148
pub fn new(lookback_periods: usize) -> Self {
    Self::with_feature_count(lookback_periods, 30) // Default: 30 features
}

What Should Happen:

// SharedMLStrategy should use FeatureConfig system
use ml::config::{FeatureConfig, WaveLevel};

// In new():
let feature_config = FeatureConfig::from_wave(WaveLevel::WaveD); // 213 features
// OR
let feature_config = FeatureConfig::from_wave(WaveLevel::WaveC); // 201 features

Impact:

• ✅ FeatureConfig system: 811 lines of sophisticated Wave A/B/C/D configuration
• ❌ SharedMLStrategy: Ignores this completely, uses 30 features from Wave A
• ⛔ ML models trained on 225 features will FAIL when given 30-feature input
• ⛔ Backtests using 225 features will DIVERGE from live trading using 30 features

Severity: P0 CRITICAL - Deployment blocker

---

2. ❌ CRITICAL: Kelly Optimizer NOT Instantiated

Current Struct Definition:

// File: common/src/ml_strategy.rs:1352
pub struct SharedMLStrategy {
    models: Arc<RwLock<HashMap<String, Box<dyn MLModelAdapter>>>>,
    feature_extractor: Arc<RwLock<MLFeatureExtractor>>,
    model_performance: Arc<RwLock<HashMap<String, MLModelPerformance>>>,
    min_confidence_threshold: f64,
    // ⛔ NO kelly_optimizer field
    // ⛔ NO regime_detector field
    // ⛔ NO adaptive_position_sizer field
}

What Exists (Unused):

• ml/src/risk/kelly_optimizer.rs - 305 lines of production-ready Kelly implementation
• adaptive-strategy/src/risk/kelly_position_sizer.rs - Advanced Kelly sizer with risk adjustment
• ml/src/risk/kelly_position_sizing_service.rs - Full Kelly service

What's Missing:

// ⛔ NO imports in common/src/ml_strategy.rs
// Expected:
use ml::risk::KellyCriterionOptimizer;
use adaptive_strategy::risk::KellyPositionSizer;

// ⛔ NO instantiation in SharedMLStrategy::new()
// Expected:
kelly_optimizer: Arc::new(KellyCriterionOptimizer::new(config)?),

Impact:

• SharedMLStrategy provides PREDICTIONS ONLY (0.0-1.0 values)
• NO position sizing recommendations (how many contracts/shares to trade)
• Services must manually wire Kelly optimizer themselves (violates "one single system")
• Risk of inconsistent position sizing across backtesting vs. live trading

Severity: P0 CRITICAL - Core value proposition unrealized

---

3. ❌ CRITICAL: Regime Detection NOT Instantiated

What Exists (Unused):

• ml/src/regime_detection.rs - 117 lines of RegimeDetectionEngine
• ml/src/features/regime_cusum.rs - CUSUM changepoint detection
• ml/src/features/regime_adx.rs - ADX trend regime classification
• ml/src/features/regime_transition.rs - Transition matrix
• ml/src/features/regime_adaptive.rs - Adaptive metrics

What's Missing:

// ⛔ NO regime detector in SharedMLStrategy struct
// Expected:
regime_detector: Arc<RegimeDetectionEngine>,

// ⛔ NO regime-based model selection in get_ensemble_prediction()
// Expected:
let regime = self.regime_detector.detect_regime()?;
let active_models = match regime {
    "trending" => &["mamba2", "dqn"],
    "ranging" => &["ppo", "tft"],
    _ => &["dqn"], // default
};

Impact:

• All ML models always active, regardless of market regime
• No adaptive strategy switching based on market conditions
• Expected +25-50% Sharpe improvement from regime detection UNREALIZED

Severity: P0 CRITICAL - Wave D value proposition unrealized

---

4. ❌ CRITICAL: Adaptive Position Sizing NOT Integrated

What Exists (Unused):

• adaptive-strategy/src/risk/kelly_position_sizer.rs - Full adaptive sizer
• adaptive-strategy/src/risk/dynamic_risk_adjuster.rs - Risk scaling (0.2x-1.5x)
• adaptive-strategy/src/risk/concentration_monitor.rs - Concentration limits
• adaptive-strategy/src/risk/volatility_optimizer.rs - Vol-based sizing

What's Missing:

SharedMLStrategy has NO position sizing logic. It only returns:

pub struct MLPrediction {
    pub model_id: String,
    pub prediction_value: f64,  // ⛔ Only this - no position size
    pub confidence: f64,
    pub features: Vec<f64>,
    pub timestamp: DateTime<Utc>,
    pub inference_latency_us: u64,
}

Expected:

pub struct TradeRecommendation {
    pub prediction: MLPrediction,
    pub position_size: f64,          // Contracts/shares to trade
    pub risk_multiplier: f64,        // 0.2x-1.5x based on regime
    pub stop_loss_distance: f64,     // 1.5x-4.0x ATR
    pub kelly_fraction: f64,         // Optimal Kelly sizing
}

Impact:

• Services must implement position sizing manually
• No regime-adaptive position scaling (0.2x crisis, 1.5x trending)
• No dynamic stop-loss adjustment (1.5x-4.0x ATR)
• Risk budget management NOT enforced

Severity: P0 CRITICAL - Adaptive strategies non-functional

---

5. ❌ HIGH: ML Models NOT Registered by Default

Current Default Registration:

// File: common/src/ml_strategy.rs:1380
pub fn new(lookback_periods: usize, min_confidence_threshold: f64) -> Self {
    let mut models: HashMap<String, Box<dyn MLModelAdapter>> = HashMap::new();

    // Add default models
    models.insert(
        "dqn_v1".to_string(),
        Box::new(SimpleDQNAdapter::new("dqn_v1".to_string())),
    );
    // ⛔ ONLY DQN registered - MAMBA-2, PPO, TFT missing

    Self { ... }
}

What's Missing:

• MAMBA-2 adapter (exists, not registered)
• PPO adapter (exists, not registered)
• TFT adapter (exists, not registered)

Impact:

• Services must manually call strategy.add_model() for each model
• Risk of inconsistent model ensembles across services
• Violates "one single system" principle

Severity: P1 HIGH - Inconsistency risk

---

6. ❌ HIGH: Architectural Ambiguity - Duplicate Kelly Implementations

Problem: Two competing Kelly implementations exist:

1. Simple Version: ml/src/risk/kelly_optimizer.rs (305 lines)

   pub struct KellyCriterionOptimizer {
       config: KellyOptimizerConfig,
   }
   

2. Advanced Version: adaptive-strategy/src/risk/kelly_position_sizer.rs

   pub struct KellyPositionSizer {
       kelly_optimizer: KellyCriterionOptimizer,
       risk_adjuster: DynamicRiskAdjuster,
       concentration_monitor: ConcentrationMonitor,
       volatility_optimizer: VolatilityOptimizer,
   }
   

Evidence of Conflict:

// File: adaptive-strategy/src/risk/kelly_position_sizer.rs:12
// REMOVED: use ml::risk::{KellyCriterionOptimizer, KellyOptimizerConfig};
//          ⛔ compilation issues

The advanced implementation tried to use the ml version but FAILED, so code was FORKED/DUPLICATED.

Impact:

• Confusion about which implementation to use
• Maintenance burden (2 implementations to maintain)
• Risk of behavioral divergence between implementations

Severity: P1 HIGH - Architectural governance failure

---

🔍 Code Statistics

Wave D Components (Implemented, Not Integrated)

Component	Lines	Status
feature_config.rs	811	✅ Implemented, ❌ NOT used
kelly_optimizer.rs	305	✅ Implemented, ❌ NOT used
regime_detection.rs	117	✅ Implemented, ❌ NOT used
Total Wasted Code	1,233	Unused production-ready code

SharedMLStrategy Analysis

Metric	Value	Issue
Total lines	2,395	Large file
Feature extraction calls	42	All use 30 features (hardcoded)
FeatureConfig imports	0	⛔ NOT imported
Kelly imports	0	⛔ NOT imported
Regime imports	0	⛔ NOT imported

---

🎭 Architectural Assessment

Design Intent (from CLAUDE.md):

"SharedMLStrategy is 'one single system' used by all services" "Should orchestrate regime detection, Kelly, adaptive sizing"

Current Reality:

SharedMLStrategy is a THIN PREDICTION AGGREGATOR:

✅ What It Does:

• Manages multiple ML model adapters
• Provides ensemble voting (weighted by confidence)
• Tracks model performance metrics

❌ What It Does NOT Do:

• Orchestrate Kelly sizing
• Orchestrate regime detection
• Orchestrate adaptive strategies
• Extract 225 features
• Provide position sizing recommendations

Actual Architecture: DECENTRALIZED

Services (Trading, Backtesting)
    ├─ Manually instantiate SharedMLStrategy (30 features)
    ├─ Manually instantiate KellyOptimizer (if needed)
    ├─ Manually instantiate RegimeDetector (if needed)
    └─ Manually wire components together

Risk: Divergence between services, inconsistent behavior, backtesting ≠ live trading.

---

📊 Impact Analysis

Deceptive "92% Ready" Metric

From WAVE_D_PRODUCTION_DEPLOYMENT_CHECKLIST.md:

Category	Status	Reality
Feature Implementation	✅ 98.3%	Component-level only
Performance	✅ 14-26x targets	Component-level only
E2E Validation	❌ FAIL	System-level FAIL
Rollback Testing	❌ FAIL	System-level FAIL

Insight: Project culture excels at COMPONENT OPTIMIZATION but fails at SYSTEM INTEGRATION.

Deployment Consequences

Blockers:

1. ML models trained on 225 features will CRASH when given 30-feature input
2. Backtests using 225 features will DIVERGE from live trading (30 features)
3. No Kelly sizing = NO position recommendations
4. No regime detection = NO adaptive strategies
5. Wave D value proposition COMPLETELY UNREALIZED

Timeline Impact:

• Expected: "Production ready" (per 92% metric)
• Reality: 4-6 weeks integration work required

---

🛠️ Remediation Plan

Phase 1: Critical Integration (P0, 2 weeks)

1.1 Refactor SharedMLStrategy Struct

File: common/src/ml_strategy.rs

Changes:

use ml::config::{FeatureConfig, WaveLevel};
use ml::risk::KellyCriterionOptimizer;
use ml::regime_detection::RegimeDetectionEngine;
use adaptive_strategy::risk::KellyPositionSizer;

pub struct SharedMLStrategy {
    // Existing fields
    models: Arc<RwLock<HashMap<String, Box<dyn MLModelAdapter>>>>,
    model_performance: Arc<RwLock<HashMap<String, MLModelPerformance>>>,
    min_confidence_threshold: f64,

    // NEW: Wave D components
    feature_config: Arc<FeatureConfig>,
    feature_extractor: Arc<RwLock<UnifiedFeatureExtractor>>, // Uses FeatureConfig
    regime_detector: Arc<RwLock<RegimeDetectionEngine>>,
    kelly_sizer: Arc<RwLock<KellyPositionSizer>>,
}

1.2 Update Constructor

pub fn new(
    feature_config: FeatureConfig,
    kelly_config: KellyOptimizerConfig,
    regime_config: RegimeDetectionConfig,
    min_confidence_threshold: f64,
) -> Result<Self> {
    // Register ALL models by default
    let mut models: HashMap<String, Box<dyn MLModelAdapter>> = HashMap::new();
    models.insert("dqn_v1".to_string(), Box::new(SimpleDQNAdapter::new("dqn_v1".to_string())));
    models.insert("mamba2_v1".to_string(), Box::new(MAMBA2Adapter::new("mamba2_v1".to_string())));
    models.insert("ppo_v1".to_string(), Box::new(PPOAdapter::new("ppo_v1".to_string())));
    models.insert("tft_v1".to_string(), Box::new(TFTAdapter::new("tft_v1".to_string())));

    Ok(Self {
        models: Arc::new(RwLock::new(models)),
        feature_config: Arc::new(feature_config),
        feature_extractor: Arc::new(RwLock::new(
            UnifiedFeatureExtractor::new(feature_config.clone())?
        )),
        regime_detector: Arc::new(RwLock::new(
            RegimeDetectionEngine::new(regime_config)?
        )),
        kelly_sizer: Arc::new(RwLock::new(
            KellyPositionSizer::new(kelly_config)?
        )),
        model_performance: Arc::new(RwLock::new(HashMap::new())),
        min_confidence_threshold,
    })
}

1.3 Expand get_ensemble_prediction() → generate_trade_signal()

pub async fn generate_trade_signal(
    &self,
    price: f64,
    volume: f64,
    timestamp: DateTime<Utc>,
) -> Result<TradeRecommendation> {
    // 1. Extract features using FeatureConfig (225 features)
    let features = {
        let mut extractor = self.feature_extractor.write().await;
        extractor.extract_features(price, volume, timestamp)?
    };

    // 2. Detect current regime
    let regime = {
        let mut detector = self.regime_detector.write().await;
        detector.detect_regime(&features)?
    };

    // 3. Select models based on regime
    let active_model_ids = match regime.as_str() {
        "trending" => vec!["mamba2_v1", "dqn_v1"],
        "ranging" => vec!["ppo_v1", "tft_v1"],
        "volatile" => vec!["dqn_v1"],
        _ => vec!["dqn_v1"], // default
    };

    // 4. Get predictions from active models
    let mut predictions = Vec::new();
    let models = self.models.read().await;
    for model_id in active_model_ids {
        if let Some(model) = models.get(model_id) {
            match model.predict(&features) {
                Ok(pred) if pred.confidence >= self.min_confidence_threshold => {
                    predictions.push(pred);
                },
                Ok(_) => {}, // Low confidence, skip
                Err(e) => tracing::warn!("Model {} failed: {}", model_id, e),
            }
        }
    }

    // 5. Calculate ensemble prediction
    let (ensemble_prediction, ensemble_confidence) = self
        .calculate_ensemble_vote(&predictions)
        .ok_or_else(|| MLError::PredictionFailed("No valid predictions".to_string()))?;

    // 6. Calculate Kelly position size
    let position_size = {
        let mut sizer = self.kelly_sizer.write().await;
        sizer.calculate_position_size(
            ensemble_prediction,
            ensemble_confidence,
            &regime,
            price,
            volume,
        )?
    };

    // 7. Return complete trade recommendation
    Ok(TradeRecommendation {
        signal: ensemble_prediction,
        confidence: ensemble_confidence,
        position_size,
        regime,
        features,
        timestamp,
    })
}

Effort: 3-4 days Risk: Medium (requires refactor across all services)

---

Phase 2: Service Integration (P0, 1 week)

Update all services to use new SharedMLStrategy API:

2.1 Trading Service

File: services/trading_service/src/paper_trading_executor.rs

Before:

let ml_strategy = SharedMLStrategy::new(20, 0.6);

After:

let feature_config = FeatureConfig::from_wave(WaveLevel::WaveD); // 213 features
let kelly_config = KellyOptimizerConfig::default();
let regime_config = RegimeDetectionConfig::default();

let ml_strategy = SharedMLStrategy::new(
    feature_config,
    kelly_config,
    regime_config,
    0.6, // min confidence
)?;

2.2 Backtesting Service

File: services/backtesting_service/src/ml_strategy_engine.rs

Same changes as Trading Service.

2.3 ML Training Service

Update training pipeline to use 225 features from FeatureConfig.

Effort: 2-3 days Risk: Low (API changes are straightforward)

---

Phase 3: Consolidate Risk Management (P1, 3 days)

3.1 Move KellyPositionSizer to Common

Action: Move adaptive-strategy/src/risk/kelly_position_sizer.rs → common/src/risk/

Rationale: Make it accessible to all services without adaptive-strategy dependency.

3.2 Deprecate Simple Kelly Implementation

Action: Remove ml/src/risk/kelly_optimizer.rs (the simple version)

Rationale: Eliminate duplicate implementations, use advanced version only.

Effort: 1 day Risk: Low (simple version not used)

---

Phase 4: Testing & Validation (P0, 1 week)

4.1 E2E Integration Tests

File: tests/e2e/wave_d_integration_test.rs

Test Cases:

1. ✅ SharedMLStrategy extracts 213 features (Wave D)
2. ✅ Regime detector detects regime and selects appropriate models
3. ✅ Kelly sizer returns position size recommendations
4. ✅ Adaptive position scaling works (0.2x crisis, 1.5x trending)
5. ✅ Backtesting uses same feature extraction as live trading

4.2 Performance Validation

Metrics:

• E2E latency: <5ms (current: PENDING)
• Memory usage: <500MB (current: PENDING)
• Throughput: >10K predictions/sec (current: PENDING)

Effort: 3-4 days Risk: Medium (may uncover additional integration issues)

---

📅 Timeline Estimate

Phase	Duration	Dependencies	Risk
Phase 1: Refactor SharedMLStrategy	3-4 days	None	Medium
Phase 2: Service Integration	2-3 days	Phase 1	Low
Phase 3: Consolidate Risk Mgmt	1 day	Phase 1	Low
Phase 4: Testing & Validation	3-4 days	Phase 2	Medium
Total	9-12 days	(2 weeks)	Medium

Additional Buffer: +2-3 days for unexpected issues Total Estimate: 2-3 weeks to production readiness

---

🚨 Quick Wins (Can Do Today)

1. Make Integration Gaps Explicit (30 min)

Action: Add placeholder fields to SharedMLStrategy struct:

pub struct SharedMLStrategy {
    // Existing fields...

    // TODO(WIRE-12): Integration required - see AGENT_WIRE12_SHAREDML_INTEGRATION.md
    kelly_sizer: Option<Box<dyn KellySizer>>,
    regime_detector: Option<Box<dyn RegimeDetector>>,
}

Benefit: Makes missing integration a compile-time concern, documents intent.

2. Enforce Feature Configuration (1 hour)

Action: Change constructor signature to require FeatureConfig:

pub fn new(
    feature_config: FeatureConfig,  // ⬅️ Force explicit choice
    min_confidence_threshold: f64,
) -> Self {
    // ...
}

Benefit: Breaks hardcoded 30-feature dependency, forces services to choose Wave level.

3. Promote Warnings to Errors (15 min)

Action: Add to common/Cargo.toml and ml/Cargo.toml:

[lints.rust]
dead_code = "deny"
missing_debug_implementations = "deny"

Benefit: Enforces code health, prevents unused code accumulation.

---

🎯 Success Criteria

Definition of Done:

1. ✅ SharedMLStrategy uses FeatureConfig system (NOT hardcoded 30 features)
2. ✅ SharedMLStrategy instantiates and uses KellyPositionSizer
3. ✅ SharedMLStrategy instantiates and uses RegimeDetectionEngine
4. ✅ All 4 ML models (DQN, MAMBA-2, PPO, TFT) registered by default
5. ✅ generate_trade_signal() returns TradeRecommendation (with position size)
6. ✅ E2E tests pass (feature extraction, regime detection, Kelly sizing)
7. ✅ Backtesting uses identical feature extraction as live trading
8. ✅ Single canonical Kelly implementation (duplicates removed)

Acceptance Tests:

#[tokio::test]
async fn test_shared_ml_strategy_uses_225_features() {
    let config = FeatureConfig::from_wave(WaveLevel::WaveD);
    let strategy = SharedMLStrategy::new(config, ...)?;

    let recommendation = strategy
        .generate_trade_signal(100.0, 1000.0, Utc::now())
        .await?;

    assert_eq!(recommendation.features.len(), 213); // Wave D
    assert!(recommendation.position_size > 0.0);
    assert!(!recommendation.regime.is_empty());
}

---

📚 References

Key Files Analyzed:

1. common/src/ml_strategy.rs (2,395 lines)

   • Line 1352: SharedMLStrategy struct definition (missing fields)
   • Line 1385: Constructor with hardcoded 30 features
   • Line 146: MLFeatureExtractor::new() hardcoded to 30

2. ml/src/config/feature_config.rs (811 lines)

   • Line 678: wave_c_features() - 201 features
   • Line 688: wave_d_features() - 213 features
   • Complete Wave A/B/C/D configuration system (NOT used by SharedMLStrategy)

3. ml/src/risk/kelly_optimizer.rs (305 lines)

   • Line 54: KellyCriterionOptimizer implementation (NOT used)

4. ml/src/regime_detection.rs (117 lines)

   • Line 30: RegimeDetectionEngine implementation (NOT used)

5. adaptive-strategy/src/risk/kelly_position_sizer.rs

   • Advanced Kelly sizer with risk adjustment (NOT integrated)
   • Line 12: Comment showing attempted import failed (compilation issues)

Related Documentation:

• CLAUDE.md: Lines 1-50 (architectural intent)
• WAVE_D_PRODUCTION_DEPLOYMENT_CHECKLIST.md: Lines 201-205 (E2E blockers)
• ML_TRAINING_ROADMAP.md: 225-feature retraining plan

---

🔚 Conclusion

SharedMLStrategy is NOT the "one single system" it was designed to be.

Despite 1,233 lines of production-ready Wave D code (Kelly optimizer, regime detector, adaptive strategies), ZERO of these components are integrated into the central orchestrator.

The system exhibits a dangerous pattern:

• ✅ Component Excellence: Each piece is well-implemented and tested
• ❌ System Failure: Pieces are NOT wired together
• 📊 Deceptive Metrics: "92% ready" ignores complete lack of integration

Immediate Action Required:

1. Refactor SharedMLStrategy to use FeatureConfig (2-3 days)
2. Integrate Kelly sizer and regime detector (2-3 days)
3. Update all services to use new API (2-3 days)
4. Add E2E integration tests (3-4 days)

Timeline: 2-3 weeks to true production readiness.

Priority: P0 CRITICAL - Deployment blocker.

---

Agent WIRE-12 Signing Off "The components are ready. The system is not."