# 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`

```rust
// 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**:
```rust
#[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`

```rust
// 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**:
```rust
#[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()`**:
   ```rust
   // 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()`**:
   ```rust
   // 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**:
   ```rust
   // 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)
```bash
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`

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

**Verification**:
```bash
cargo check -p common
# Should compile without errors
```

---

#### C. Refresh SQLX Metadata (45 minutes)
```bash
# 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)
```bash
# 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**:
```sql
-- 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)

```bash
# 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)
```bash
# 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)
```bash
# 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)
```sql
-- 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)