foxhunt/PRODUCTION_READINESS_NEXT_STEPS.md

Production Readiness - Next Steps

Date: 2025-10-20 Current Status: 92% Ready (23/25 checkboxes) Target: 100% Ready (25/25 checkboxes) Time Remaining: 13 hours (9 hours critical + 4 hours validation)

---

Immediate Actions (Critical Path: 9 Hours)

1. Resolve BLOCKER 1: Adaptive Position Sizer Integration (8 hours)

Objective: Wire Wave D regime-adaptive position sizing into Trading Agent Service

Tasks:

A. Implement kelly_criterion_regime_adaptive() (4 hours)

File: /home/jgrusewski/Work/foxhunt/services/trading_agent_service/src/allocation.rs

// Add this function to allocation.rs
pub async fn kelly_criterion_regime_adaptive(
    &self,
    symbol: &str,
    win_rate: f64,
    win_loss_ratio: f64,
    current_regime: MarketRegime,
    regime_confidence: f64,
) -> Result<f64, CommonError> {
    // 1. Calculate base Kelly fraction
    let base_kelly = (win_rate * (1.0 + win_loss_ratio) - 1.0) / win_loss_ratio;

    // 2. Apply quarter-Kelly for safety (0.25x base)
    let conservative_kelly = base_kelly * 0.25;

    // 3. Apply regime-adaptive multiplier
    let regime_multiplier = match current_regime {
        MarketRegime::Trending => {
            // Trending: increase position size (1.2x-1.5x)
            1.0 + (regime_confidence * 0.5)
        },
        MarketRegime::Ranging => {
            // Ranging: reduce position size (0.7x-1.0x)
            1.0 - (regime_confidence * 0.3)
        },
        MarketRegime::Volatile => {
            // Volatile: significantly reduce (0.2x-0.5x)
            0.5 - (regime_confidence * 0.3)
        },
        MarketRegime::Unknown => 1.0, // No adjustment
    };

    // 4. Calculate final adaptive position size
    let adaptive_kelly = conservative_kelly * regime_multiplier;

    // 5. Apply concentration limits (max 20% per position)
    let final_size = adaptive_kelly.min(0.20);

    Ok(final_size)
}

Integration Points:

• Call from calculate_position_sizes() in allocation.rs
• Fetch regime data via get_current_regime_state() (already implemented)
• Log adaptive multiplier to metrics (for Grafana monitoring)

Tests to Add:

#[tokio::test]
async fn test_kelly_regime_adaptive_trending() { ... }

#[tokio::test]
async fn test_kelly_regime_adaptive_ranging() { ... }

#[tokio::test]
async fn test_kelly_regime_adaptive_volatile() { ... }

#[tokio::test]
async fn test_kelly_regime_adaptive_concentration_limits() { ... }

---

B. Implement calculate_regime_adaptive_stop() (3 hours)

File: /home/jgrusewski/Work/foxhunt/services/trading_agent_service/src/orders.rs

// Add this function to orders.rs
pub async fn calculate_regime_adaptive_stop(
    &self,
    symbol: &str,
    entry_price: f64,
    position_side: PositionSide,
    current_regime: MarketRegime,
    regime_confidence: f64,
    atr: f64,
) -> Result<f64, CommonError> {
    // 1. Calculate base stop-loss (2.0x ATR)
    let base_stop_distance = atr * 2.0;

    // 2. Apply regime-adaptive multiplier
    let regime_multiplier = match current_regime {
        MarketRegime::Trending => {
            // Trending: wider stops (2.5x-4.0x ATR)
            2.5 + (regime_confidence * 1.5)
        },
        MarketRegime::Ranging => {
            // Ranging: normal stops (1.5x-2.5x ATR)
            1.5 + (regime_confidence * 1.0)
        },
        MarketRegime::Volatile => {
            // Volatile: tighter stops (1.5x-2.0x ATR)
            1.5 + (regime_confidence * 0.5)
        },
        MarketRegime::Unknown => 2.0, // Default to base stop
    };

    // 3. Calculate adaptive stop distance
    let adaptive_stop_distance = atr * regime_multiplier;

    // 4. Calculate stop price based on position side
    let stop_price = match position_side {
        PositionSide::Long => entry_price - adaptive_stop_distance,
        PositionSide::Short => entry_price + adaptive_stop_distance,
    };

    // 5. Ensure stop price is valid (not negative, reasonable)
    if stop_price <= 0.0 {
        return Err(CommonError::validation(
            "Invalid stop price calculated (negative or zero)"
        ));
    }

    Ok(stop_price)
}

Integration Points:

• Call from create_orders_for_allocation() in orders.rs
• Fetch ATR via calculate_atr() (already exists in common::features::technical_indicators)
• Store stop multiplier in order metadata (for audit logging)

Tests to Add:

#[tokio::test]
async fn test_regime_adaptive_stop_trending() { ... }

#[tokio::test]
async fn test_regime_adaptive_stop_ranging() { ... }

#[tokio::test]
async fn test_regime_adaptive_stop_volatile() { ... }

#[tokio::test]
async fn test_regime_adaptive_stop_validation() { ... }

---

C. Wire Functions into Decision Flow (1 hour)

Files: allocation.rs, orders.rs

1. Update calculate_position_sizes():

   // In allocation.rs, line ~250
   let regime_state = self.get_current_regime_state(symbol).await?;
   let adaptive_size = self.kelly_criterion_regime_adaptive(
       symbol,
       win_rate,
       win_loss_ratio,
       regime_state.regime,
       regime_state.confidence,
   ).await?;
   

2. Update create_orders_for_allocation():

   // In orders.rs, line ~180
   let stop_price = self.calculate_regime_adaptive_stop(
       symbol,
       entry_price,
       position_side,
       regime_state.regime,
       regime_state.confidence,
       atr,
   ).await?;
   

3. Add Metrics Logging:

   // Log adaptive multipliers to Prometheus
   metrics::histogram!("trading_agent.kelly_multiplier", regime_multiplier);
   metrics::histogram!("trading_agent.stop_multiplier", stop_multiplier);
   

Validation:

• Run cargo test -p trading_agent_service --lib
• Verify 8 new tests passing (4 Kelly + 4 Stop-Loss)
• Check logs for adaptive multiplier values

---

2. Resolve BLOCKER 2: Database Persistence Deployment (70 minutes)

Objective: Enable regime state/transition persistence to PostgreSQL

Tasks:

A. Delete Conflicting Migration (5 minutes)

cd /home/jgrusewski/Work/foxhunt
rm migrations/046_rollback_regime_detection.sql

Reason: Migration 046 conflicts with migration 045 (regime detection schema). Migration 045 is already applied and working.

---

B. Export regime_persistence Module (10 minutes)

File: /home/jgrusewski/Work/foxhunt/common/src/lib.rs

// Add this line to common/src/lib.rs (around line 50)
pub mod regime_persistence;

Verification:

cargo check -p common
# Should compile without errors

---

C. Refresh SQLX Metadata (45 minutes)

# 1. Ensure database is running
docker-compose up -d foxhunt-postgres

# 2. Set DATABASE_URL
export DATABASE_URL="postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt"

# 3. Run cargo sqlx prepare for entire workspace
cargo sqlx prepare --workspace

# 4. Verify .sqlx/ directories updated
ls -lh services/trading_agent_service/.sqlx/
# Should show 2 new query files (regime_state, regime_transition)

Expected Output:

Generated query data to `.sqlx` directory; please check this into version control.

---

D. Test Database Persistence (10 minutes)

# Run integration tests
cargo test -p trading_agent_service --test integration_regime_persistence

# Expected: All tests passing
# Test count: ~5 tests (create, read, update, list, delete)

Validation:

-- Verify data in database
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

SELECT COUNT(*) FROM regime_states;
-- Should show rows after test execution

SELECT COUNT(*) FROM regime_transitions;
-- Should show rows after test execution

---

Post-Resolution Validation (4 Hours)

3. Comprehensive Test Suite (2 hours)

# A. Full workspace test suite
cargo test --workspace --lib --no-fail-fast 2>&1 | tee /tmp/final_test_results.log

# Expected: 3,065/3,066 tests passing (99.97% → 100%)
# New tests: +8 (Kelly Regime Adaptive + Dynamic Stop-Loss)

# B. Integration tests
cargo test --workspace --test '*' --no-fail-fast 2>&1 | tee /tmp/final_integration_tests.log

# Expected: 36/36 tests passing (28 existing + 8 new)

# C. Wave D backtest
cargo test -p backtesting_service --test integration_wave_d_backtest -- --nocapture

# Expected: 7/7 tests passing
# Metrics: Sharpe 2.00, Win Rate 60%, Drawdown 15%

---

4. Smoke Testing (2 hours)

A. 5-Minute Paper Trading Session (1 hour)

# Start all services
docker-compose up -d
cargo run -p api_gateway &
cargo run -p trading_service &
cargo run -p trading_agent_service &

# Run TLI commands
tli trade ml start-predictions --interval 30 --symbols ES.FUT
# Let run for 5 minutes

# Monitor regime transitions
tli trade ml regime --symbol ES.FUT
tli trade ml transitions --symbol ES.FUT --limit 10
tli trade ml adaptive-metrics --symbol ES.FUT

Success Criteria:

• ✅ At least 1 regime transition detected
• ✅ Adaptive position sizes in 0.2x-1.5x range
• ✅ Dynamic stop-loss in 1.5x-4.0x ATR range
• ✅ No errors in logs

---

B. Performance Validation (30 minutes)

# Run Wave D feature extraction benchmark
cargo test -p ml --lib test_wave_d_feature_extraction_simulated -- --nocapture

# Expected: <50μs target (current: 9.32ns-116.94ns)

# Run regime detection benchmark
cargo bench -p ml --bench bench_regime_detection

# Expected: <50μs target (current: 9.32ns-92.45ns)

---

C. Database Validation (30 minutes)

-- Connect to database
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

-- Verify regime states logged
SELECT symbol, regime, confidence, created_at
FROM regime_states
ORDER BY created_at DESC
LIMIT 10;

-- Verify regime transitions logged
SELECT symbol, from_regime, to_regime, transition_time
FROM regime_transitions
ORDER BY transition_time DESC
LIMIT 10;

-- Verify adaptive metrics logged
SELECT symbol, kelly_multiplier, stop_multiplier, created_at
FROM adaptive_strategy_metrics
ORDER BY created_at DESC
LIMIT 10;

Success Criteria:

• ✅ Regime states have rows (≥10 after 5-min smoke test)
• ✅ Regime transitions have rows (≥1 transition detected)
• ✅ Adaptive metrics have rows (≥10 decision points logged)

---

Optional: Security Hardening (1 Hour)

5. Enable OCSP Certificate Revocation (1 hour)

File: /home/jgrusewski/Work/foxhunt/services/api_gateway/src/auth/mtls/revocation.rs

Tasks:

1. Uncomment OCSP validation code (already implemented, just commented)
2. Configure OCSP responder URLs in config/default.toml
3. Test revocation cache (already has 100% test coverage)
4. Validate certificate revocation in staging environment

Documentation: See AGENT_S9_OCSP_IMPLEMENTATION.md

---

Final Checklist

Before declaring 100% production readiness:

• ✅ BLOCKER 1 resolved: Kelly Regime Adaptive + Dynamic Stop-Loss implemented
• ✅ BLOCKER 2 resolved: Database Persistence deployed
• ✅ Test suite: 100% pass rate (≥3,065/3,066 tests)
• ✅ Integration tests: 100% pass rate (≥36/36 tests)
• ✅ Wave D backtest: All metrics met (Sharpe 2.00, Win Rate 60%, Drawdown 15%)
• ✅ Smoke test: 5-minute paper trading successful
• ✅ Database: Regime states/transitions persisted
• ✅ Performance: All benchmarks within targets
• ✅ Monitoring: Grafana dashboards configured
• ✅ TLI commands: All 3 new commands operational
• ✅ gRPC endpoints: GetRegimeState + GetRegimeTransitions responding
• ✅ Documentation: CLAUDE.md updated with final status
• ⚪ Optional: OCSP revocation enabled (can defer to Week 2)

---

Timeline Summary

Hour 0-8:    BLOCKER 1 (Adaptive Sizer Integration)
Hour 8-9:    BLOCKER 2 (Database Persistence)
Hour 9-11:   Post-Resolution Testing
Hour 11-13:  Smoke Testing + Performance Validation

Total:       13 hours to 100% production readiness

---

Success Metrics

Before Blocker Resolution:

• Production Readiness: 92% (23/25 checkboxes)
• Test Pass Rate: 99.97% (3,057/3,058)
• Performance: 922x vs. targets

After Blocker Resolution:

• Production Readiness: 100% (25/25 checkboxes)
• Test Pass Rate: 100% (≥3,065/3,066)
• Performance: 922x vs. targets (unchanged)
• Wave D Validated: Sharpe 2.00, Win Rate 60%, Drawdown 15%

---

Contact & Escalation

Primary: Production Readiness Team Escalation: Technical Lead → System Architect → CTO Emergency: 24/7 PagerDuty rotation

Documentation:

• Full Report: PRODUCTION_READINESS_VERIFICATION_REPORT.md
• Exec Summary: PRODUCTION_READINESS_EXEC_SUMMARY.md
• This File: PRODUCTION_READINESS_NEXT_STEPS.md

---

Generated: 2025-10-20 08:12:00 UTC Expected Completion: 2025-10-20 21:12:00 UTC (13 hours) Status: ⚠️ IN PROGRESS → ✅ COMPLETE (after 13 hours)