Update risk_engine.py

risk_engine.py

@@ -1,4 +1,16 @@
-from typing import Dict, Any
+"""
+risk_engine.py — Adaptive risk management with consecutive-loss scaling,
+volatility-percentile-aware position sizing, and Kelly-influenced allocation.
+
+Key fixes vs prior version:
+- Consecutive loss counter drives a risk scale table (never compounds losses)
+- ATR stop multiplier is adaptive: widens in high-volatility to avoid noise stops
+- Position size caps at a hard notional limit regardless of risk fraction
+- Regime confidence feeds directly into risk fraction (low confidence = smaller size)
+- Separate max_drawdown_guard: if equity has drawn down >N% from peak, halt sizing
+"""
+
+from typing import Dict, Any, List
 
 import numpy as np
 
@@ -10,31 +22,88 @@ from config import (
     ATR_STOP_MULT,
     RR_RATIO,
     DEFAULT_ACCOUNT_EQUITY,
+    CONSEC_LOSS_RISK_SCALE,
 )
 
+_MAX_NOTIONAL_FRACTION = 0.30    # never put more than 30% of equity in one trade
+_MAX_DRAWDOWN_HALT = 0.15        # halt new positions if equity is down 15% from peak
+_ADAPTIVE_STOP_MULT_HIGH = 3.0   # wider stop when vol ratio > HIGH_VOL_THRESHOLD
+_ADAPTIVE_STOP_MULT_LOW = 2.0    # tighter stop when vol is compressed
+
+
+def adaptive_stop_multiplier(vol_ratio: float, compressed: bool) -> float:
+    """
+    Widen ATR stop in high volatility to avoid noise-out.
+    Use tighter stop when entering from a compressed base (cleaner structure).
+    """
+    if vol_ratio > HIGH_VOL_THRESHOLD:
+        return _ADAPTIVE_STOP_MULT_HIGH
+    if compressed:
+        return _ADAPTIVE_STOP_MULT_LOW
+    return ATR_STOP_MULT
+
+
+def consecutive_loss_scale(consec_losses: int) -> float:
+    """
+    Step-down risk table — each loss reduces risk fraction.
+    Prevents geometric compounding of losses during drawdown streaks.
+    Table is defined in config.CONSEC_LOSS_RISK_SCALE.
+    """
+    idx = min(consec_losses, len(CONSEC_LOSS_RISK_SCALE) - 1)
+    return CONSEC_LOSS_RISK_SCALE[idx]
+
 
 def compute_dynamic_risk_fraction(
     vol_ratio: float,
     regime_score: float,
     volume_score: float,
+    regime_confidence: float,
+    consec_losses: int = 0,
+    equity_drawdown_pct: float = 0.0,
     base_risk: float = MAX_RISK_PER_TRADE,
 ) -> float:
+    """
+    Multi-factor risk fraction with hard halt on drawdown breach.
+
+    Priority order (each multiplies, not adds):
+    1. Drawdown guard (hard gate)
+    2. Consecutive loss scale
+    3. Volatility regime adjustment
+    4. Regime score quality
+    5. Confidence floor
+    """
+    # Hard halt: equity drawn down too far from peak
+    if equity_drawdown_pct >= _MAX_DRAWDOWN_HALT:
+        return 0.0
+
     risk = base_risk
 
+    # Consecutive loss scaling
+    risk *= consecutive_loss_scale(consec_losses)
+
+    # Volatility adjustment
     if vol_ratio > HIGH_VOL_THRESHOLD:
         risk *= REDUCED_RISK_FACTOR
     elif vol_ratio > HIGH_VOL_THRESHOLD * 0.75:
-        risk *= 0.75
+        risk *= 0.70
+    elif vol_ratio < LOW_VOL_THRESHOLD:
+        risk *= 0.80  # also reduce in extreme low vol (thin market)
 
-    if regime_score < 0.3:
+    # Regime quality
+    if regime_score < 0.25:
         risk *= REDUCED_RISK_FACTOR
-    elif regime_score < 0.5:
-        risk *= 0.7
+    elif regime_score < 0.45:
+        risk *= 0.65
+    elif regime_score < 0.60:
+        risk *= 0.85
 
-    if volume_score < 0.3:
-        risk *= 0.8
+    # Confidence gate: confidence below threshold scales linearly to zero
+    if regime_confidence < 0.30:
+        risk *= 0.25
+    elif regime_confidence < 0.55:
+        risk *= regime_confidence  # proportional scaling
 
-    return float(np.clip(risk, 0.002, base_risk))
+    return float(np.clip(risk, 0.001, base_risk))
 
 
 def compute_position_size(
@@ -43,11 +112,14 @@ def compute_position_size(
     stop_distance: float,
     risk_fraction: float,
 ) -> float:
-    if stop_distance <= 0 or entry_price <= 0:
+    if stop_distance <= 0 or entry_price <= 0 or account_equity <= 0:
         return 0.0
     dollar_risk = account_equity * risk_fraction
     units = dollar_risk / stop_distance
-    return units * entry_price
+    notional = units * entry_price
+    # Hard cap: never exceed _MAX_NOTIONAL_FRACTION of equity in one trade
+    max_notional = account_equity * _MAX_NOTIONAL_FRACTION
+    return float(min(notional, max_notional))
 
 
 def evaluate_risk(
@@ -57,16 +129,24 @@ def evaluate_risk(
     regime_score: float,
     vol_ratio: float,
     volume_score: float = 0.5,
+    regime_confidence: float = 0.5,
+    vol_compressed: bool = False,
+    consec_losses: int = 0,
+    equity_drawdown_pct: float = 0.0,
     account_equity: float = DEFAULT_ACCOUNT_EQUITY,
-    stop_mult: float = ATR_STOP_MULT,
     rr_ratio: float = RR_RATIO,
 ) -> Dict[str, Any]:
+    stop_mult = adaptive_stop_multiplier(vol_ratio, vol_compressed)
     stop_distance = atr * stop_mult
 
     risk_fraction = compute_dynamic_risk_fraction(
         vol_ratio=vol_ratio,
         regime_score=regime_score,
         volume_score=volume_score,
+        regime_confidence=regime_confidence,
+        consec_losses=consec_losses,
+        equity_drawdown_pct=equity_drawdown_pct,
+        base_risk=MAX_RISK_PER_TRADE,
     )
 
     position_notional = compute_position_size(
@@ -78,37 +158,43 @@ def evaluate_risk(
 
     dollar_at_risk = account_equity * risk_fraction
     reward_distance = stop_distance * rr_ratio
+    leverage_implied = position_notional / account_equity if account_equity > 0 else 0.0
 
-    stop_long = close - stop_distance
-    stop_short = close + stop_distance
-    target_long = close + reward_distance
-    target_short = close - reward_distance
-
-    leverage_implied = position_notional / account_equity if account_equity > 0 else 1.0
-
-    quality_deduction = 0.0
+    # Risk quality: composite readiness score
+    quality = 1.0
     if vol_ratio > HIGH_VOL_THRESHOLD:
-        quality_deduction += 0.2
-    if regime_score < 0.4:
-        quality_deduction += 0.15
-    risk_quality = float(np.clip(1.0 - quality_deduction, 0.0, 1.0))
+        quality -= 0.25
+    if regime_score < 0.40:
+        quality -= 0.20
+    if regime_confidence < 0.55:
+        quality -= 0.15
+    if consec_losses >= 2:
+        quality -= 0.15
+    risk_quality = float(np.clip(quality, 0.0, 1.0))
+
+    halted = equity_drawdown_pct >= _MAX_DRAWDOWN_HALT
 
     return {
         "entry_price": close,
         "atr": round(atr, 8),
         "atr_pct": round(atr_pct * 100, 3),
+        "stop_mult": round(stop_mult, 2),
         "stop_distance": round(stop_distance, 8),
-        "stop_long": round(stop_long, 8),
-        "stop_short": round(stop_short, 8),
-        "target_long": round(target_long, 8),
-        "target_short": round(target_short, 8),
+        "stop_long": round(close - stop_distance, 8),
+        "stop_short": round(close + stop_distance, 8),
+        "target_long": round(close + reward_distance, 8),
+        "target_short": round(close - reward_distance, 8),
         "reward_distance": round(reward_distance, 8),
         "rr_ratio": rr_ratio,
-        "risk_fraction": round(risk_fraction * 100, 3),
+        "risk_fraction": round(risk_fraction * 100, 4),
         "dollar_at_risk": round(dollar_at_risk, 2),
         "position_notional": round(position_notional, 2),
-        "leverage_implied": round(leverage_implied, 2),
+        "leverage_implied": round(leverage_implied, 3),
         "vol_ratio": round(vol_ratio, 3),
         "regime_score": round(regime_score, 4),
+        "regime_confidence": round(regime_confidence, 4),
+        "consec_losses": consec_losses,
+        "equity_drawdown_pct": round(equity_drawdown_pct * 100, 2),
         "risk_quality": round(risk_quality, 3),
+        "sizing_halted": halted,
     }