Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V128.0 - GEM-Architect: Armored Edition)
+# 🧪 backtest_engine.py (V129.0 - GEM-Architect: Sniper Debug Mode)
 # ============================================================
 
 import asyncio
@@ -34,15 +34,17 @@ logging.getLogger('ml_engine').setLevel(logging.WARNING)
 CACHE_DIR = "backtest_real_scores"
 
 # ============================================================
-# 🛡️ GLOBAL SANITIZATION & HELPERS
+# 🛡️ GLOBAL SANITIZATION
 # ============================================================
 
 def sanitize_features(df):
     """
-    Cleans DataFrame from Infinity and NaNs to prevent XGBoost crashes.
+    Cleans DataFrame from Infinity and NaNs.
+    Forces float32 to be friendly with ML models.
     """
     if df is None or df.empty: return df
-    return df.replace([np.inf, -np.inf], np.nan).fillna(0.0)
+    # Replace Infinity with NaN, then fill NaN with 0.0, then convert to float32
+    return df.replace([np.inf, -np.inf], np.nan).fillna(0.0).astype(np.float32)
 
 def _zv(x):
     with np.errstate(divide='ignore', invalid='ignore'):
@@ -103,16 +105,16 @@ def _transform_window_for_pattern(df_window):
     except: return None
 
 def calculate_sniper_features_exact(df):
-    """Sniper Features Calculation with GUARANTEED columns."""
+    """Sniper Features Calculation - EXACT MATCH with Processor."""
     df = df.copy()
     
-    # 1. Base Returns (Explicitly created)
+    # Base Returns
     df['return_1m'] = df['close'].pct_change(1).fillna(0)
-    df['return_3m'] = df['close'].pct_change(3).fillna(0) # Required!
+    df['return_3m'] = df['close'].pct_change(3).fillna(0) 
     df['return_5m'] = df['close'].pct_change(5).fillna(0)
     df['return_15m'] = df['close'].pct_change(15).fillna(0)
 
-    # 2. Liquidity Proxies
+    # Liquidity Proxies
     df['ret'] = df['close'].pct_change().fillna(0)
     df['dollar_vol'] = df['close'] * df['volume']
     df['amihud'] = (df['ret'].abs() / df['dollar_vol'].replace(0, np.nan)).fillna(0)
@@ -138,7 +140,7 @@ def calculate_sniper_features_exact(df):
                      _z_score_rolling(-df['roll_spread']) + _z_score_rolling(-df['rv_gk'].abs()) + 
                      _z_score_rolling(-df['vwap_dev'].abs()) + _z_score_rolling(df['ofi']))
     
-    # 3. Standard Indicators
+    # Standard Indicators
     df['rsi_14'] = ta.rsi(df['close'], 14).fillna(50)
     df['atr'] = ta.atr(df['high'], df['low'], df['close'], 100).fillna(0)
     df['vol_zscore_50'] = _z_score_rolling(df['volume'], 50)
@@ -157,7 +159,9 @@ def calculate_sniper_features_exact(df):
     return sanitize_features(df)
 
 def calculate_titan_features_real(df):
+    """Titan features with strict Infinity handling."""
     df = df.copy()
+    
     df['RSI'] = ta.rsi(df['close'], 14)
     macd = ta.macd(df['close'])
     if macd is not None: 
@@ -189,7 +193,7 @@ def calculate_titan_features_real(df):
     return sanitize_features(df)
 
 # ============================================================
-# 🔧 NEW: LEGACY GUARD VECTORIZED FEATURES (REAL & SAFE)
+# 🔧 LEGACY GUARD (V2 & V3)
 # ============================================================
 def calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m):
     try:
@@ -198,11 +202,9 @@ def calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m):
             res = pd.DataFrame(index=df.index)
             res[f'log_ret_{suffix}'] = np.log(c / c.shift(1).replace(0, np.nan)).fillna(0)
             res[f'rsi_{suffix}'] = (ta.rsi(c, 14) / 100.0).fillna(0.5)
-            
             roll_max = h.rolling(50).max(); roll_min = l.rolling(50).min()
             diff = (roll_max - roll_min).replace(0, 1e-9)
             res[f'fib_pos_{suffix}'] = ((c - roll_min) / diff).fillna(0.5)
-            
             if suffix == '1m':
                 res[f'volatility_{suffix}'] = (ta.atr(h, l, c, 14) / c.replace(0, np.nan)).fillna(0)
             else:
@@ -225,8 +227,7 @@ def calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m):
 
         parts = [f1[FEATS_1M], f5[FEATS_5M], f15[FEATS_15M]]
         lags = [1, 2, 3, 5, 10, 20]
-        for lag in lags:
-            parts.append(f1[FEATS_1M].shift(lag).fillna(0))
+        for lag in lags: parts.append(f1[FEATS_1M].shift(lag).fillna(0))
             
         X_df = pd.concat(parts, axis=1)
         return sanitize_features(X_df).values 
@@ -235,129 +236,84 @@ def calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m):
         return None
 
 def calculate_legacy_v3_vectorized(df_1m, df_5m, df_15m):
-    """
-    Legacy V3 EXACT & SAFE Feature Calculation.
-    Prevents 'NoneType' errors by initializing everything to 0.0.
-    """
+    """Legacy V3 Safe Calc."""
     try:
         def calc_v3_base(df, prefix=""):
             d = df.copy()
-            c = d['close']; h = d['high']; l = d['low']; v = d['volume']
-            
-            # 1. Initialize ALL potential columns with 0.0 (Safety Net)
+            # Initialize All
             targets = ['rsi', 'rsi_slope', 'macd_h', 'macd_h_slope', 'adx', 'dmp', 'dmn', 
                        'trend_net_force', 'ema_20', 'ema_50', 'ema_200', 'dist_ema20', 
                        'dist_ema50', 'dist_ema200', 'slope_ema50', 'atr', 'atr_rel', 
                        'obv', 'obv_slope', 'cmf', 'log_ret', 'mc_skew', 'mc_kurt', 
                        'mc_prob_gain', 'mc_var_95', 'mc_shock']
-            
             for t in targets: d[t] = 0.0
 
-            # 2. Computations (Overwrite if successful)
+            c = d['close']; h = d['high']; l = d['low']; v = d['volume']
             try:
                 d['log_ret'] = np.log(c / c.shift(1).replace(0, np.nan)).fillna(0)
-                
-                rsi = ta.rsi(c, 14)
-                if rsi is not None: 
-                    d['rsi'] = rsi.fillna(50)
-                    d['rsi_slope'] = (d['rsi'] - d['rsi'].shift(3).fillna(50)) / 3
-
+                d['rsi'] = ta.rsi(c, 14).fillna(50)
+                d['rsi_slope'] = (d['rsi'] - d['rsi'].shift(3).fillna(50)) / 3
                 macd = ta.macd(c)
                 if macd is not None:
                     d['macd_h'] = macd.iloc[:, 1].fillna(0)
                     d['macd_h_slope'] = (d['macd_h'] - d['macd_h'].shift(3).fillna(0)) / 3
-
                 adx = ta.adx(h, l, c, 14)
                 if adx is not None:
-                    d['adx'] = adx.iloc[:, 0].fillna(0)
-                    d['dmp'] = adx.iloc[:, 1].fillna(0)
-                    d['dmn'] = adx.iloc[:, 2].fillna(0)
+                    d['adx'] = adx.iloc[:, 0].fillna(0); d['dmp'] = adx.iloc[:, 1].fillna(0); d['dmn'] = adx.iloc[:, 2].fillna(0)
                     d['trend_net_force'] = (d['dmp'] - d['dmn']) * (d['adx'] / 100.0)
-
-                d['ema_20'] = ta.ema(c, 20).fillna(c)
-                d['ema_50'] = ta.ema(c, 50).fillna(c)
-                d['ema_200'] = ta.ema(c, 200).fillna(c)
-                
+                d['ema_20'] = ta.ema(c, 20).fillna(c); d['ema_50'] = ta.ema(c, 50).fillna(c); d['ema_200'] = ta.ema(c, 200).fillna(c)
                 d['dist_ema20'] = (c - d['ema_20']) / d['ema_20'].replace(0, np.nan)
                 d['dist_ema50'] = (c - d['ema_50']) / d['ema_50'].replace(0, np.nan)
                 d['dist_ema200'] = (c - d['ema_200']) / d['ema_200'].replace(0, np.nan)
-                
-                shift_ema50 = d['ema_50'].shift(5).replace(0, np.nan)
-                d['slope_ema50'] = (d['ema_50'] - d['ema_50'].shift(5).fillna(0)) / shift_ema50
-
-                d['atr'] = ta.atr(h, l, c, 14).fillna(0)
-                d['atr_rel'] = d['atr'] / c.replace(0, np.nan)
-                
-                obv = ta.obv(c, v)
-                if obv is not None:
-                    d['obv'] = obv.fillna(0)
-                    d['obv_slope'] = d['obv'] - d['obv'].shift(5).fillna(0)
-                    
+                d['slope_ema50'] = (d['ema_50'] - d['ema_50'].shift(5).fillna(0)) / d['ema_50'].shift(5).replace(0, np.nan)
+                d['atr'] = ta.atr(h, l, c, 14).fillna(0); d['atr_rel'] = d['atr'] / c.replace(0, np.nan)
+                d['obv'] = ta.obv(c, v).fillna(0); d['obv_slope'] = d['obv'] - d['obv'].shift(5).fillna(0)
                 d['cmf'] = ta.cmf(h, l, c, v, 20).fillna(0)
-
-                # Monte Carlo Proxies
-                window = 30
-                roll = d['log_ret'].rolling(window)
-                d['mc_skew'] = roll.skew().fillna(0)
-                d['mc_kurt'] = roll.kurt().fillna(0)
-                d['mc_prob_gain'] = (d['log_ret'] > 0).rolling(window).mean().fillna(0.5)
+                
+                win = 30; roll = d['log_ret'].rolling(win)
+                d['mc_skew'] = roll.skew().fillna(0); d['mc_kurt'] = roll.kurt().fillna(0)
+                d['mc_prob_gain'] = (d['log_ret'] > 0).rolling(win).mean().fillna(0.5)
                 d['mc_var_95'] = roll.quantile(0.05).fillna(-0.02)
                 d['mc_shock'] = ((d['log_ret'] - roll.mean()) / (roll.std().replace(0, np.nan))).fillna(0)
-            
-            except Exception:
-                # If any specific calculation fails, we stick to 0.0 default
-                pass
+            except: pass
 
             if prefix:
                 d.columns = [f"{col}_{prefix}" if col not in ['timestamp'] else col for col in d.columns]
                 return sanitize_features(d)
             return sanitize_features(d)
 
-        df1 = calc_v3_base(df_1m)
-        df5 = calc_v3_base(df_5m, "5m").reindex(df_1m.index, method='ffill')
+        df1 = calc_v3_base(df_1m); df5 = calc_v3_base(df_5m, "5m").reindex(df_1m.index, method='ffill')
         df15 = calc_v3_base(df_15m, "15m").reindex(df_1m.index, method='ffill')
 
         final_df = pd.DataFrame(index=df_1m.index)
-        
-        # Lags
         for i, col_name in enumerate(["6", "7", "8", "9", "10", "11"], 1):
             final_df[col_name] = df1['log_ret'].shift(i)
 
-        cols_1m = [
-            'rsi', 'rsi_slope', 'macd_h', 'macd_h_slope', 'adx', 'dmp', 'dmn', 'trend_net_force',
-            'ema_20', 'ema_50', 'ema_200', 'dist_ema20', 'dist_ema50', 'dist_ema200', 'slope_ema50',
-            'atr', 'atr_rel', 'obv', 'obv_slope', 'cmf', 'log_ret', 
-            'mc_skew', 'mc_kurt', 'mc_prob_gain', 'mc_var_95', 'mc_shock'
-        ]
+        cols_1m = ['rsi', 'rsi_slope', 'macd_h', 'macd_h_slope', 'adx', 'dmp', 'dmn', 'trend_net_force',
+                   'ema_20', 'ema_50', 'ema_200', 'dist_ema20', 'dist_ema50', 'dist_ema200', 'slope_ema50',
+                   'atr', 'atr_rel', 'obv', 'obv_slope', 'cmf', 'log_ret', 'mc_skew', 'mc_kurt', 
+                   'mc_prob_gain', 'mc_var_95', 'mc_shock']
         for c in cols_1m: final_df[c] = df1[c]
 
-        cols_5m_map = {'rsi_5m': 'rsi_5m', 'rsi_slope_5m': 'rsi_slope_5m', 'macd_h_5m': 'macd_h_5m',
-                       'mc_prob_gain_5m': 'mc_prob_gain_5m', 'mc_shock_5m': 'mc_shock_5m'}
-        for k, v in cols_5m_map.items(): final_df[k] = df5[v]
-
-        cols_15m_map = {'rsi_15m': 'rsi_15m', 'macd_h_15m': 'macd_h_15m', 
-                        'trend_net_force_15m': 'trend_net_force_15m',
-                        'mc_prob_gain_15m': 'mc_prob_gain_15m', 'dist_ema200_15m': 'dist_ema200_15m'}
-        for k, v in cols_15m_map.items(): final_df[k] = df15[v]
-
-        expected_order = [
-            "6", "7", "8", "9", "10", "11", 
-            "rsi", "rsi_slope", "macd_h", "macd_h_slope", "adx", "dmp", "dmn", "trend_net_force", 
-            "ema_20", "ema_50", "ema_200", "dist_ema20", "dist_ema50", "dist_ema200", "slope_ema50", 
-            "atr", "atr_rel", "obv", "obv_slope", "cmf", "log_ret", 
-            "mc_skew", "mc_kurt", "mc_prob_gain", "mc_var_95", "mc_shock", 
-            "rsi_5m", "rsi_slope_5m", "macd_h_5m", "mc_prob_gain_5m", "mc_shock_5m", 
-            "rsi_15m", "macd_h_15m", "trend_net_force_15m", "mc_prob_gain_15m", "dist_ema200_15m"
-        ]
-        
-        return sanitize_features(final_df.reindex(columns=expected_order, fill_value=0.0))
+        cols_5m = {'rsi_5m': 'rsi_5m', 'rsi_slope_5m': 'rsi_slope_5m', 'macd_h_5m': 'macd_h_5m',
+                   'mc_prob_gain_5m': 'mc_prob_gain_5m', 'mc_shock_5m': 'mc_shock_5m'}
+        for k, v in cols_5m.items(): final_df[k] = df5[v]
 
-    except Exception as e:
-        print(f"Legacy V3 Calc Error: {e}")
-        return None
+        cols_15m = {'rsi_15m': 'rsi_15m', 'macd_h_15m': 'macd_h_15m', 'trend_net_force_15m': 'trend_net_force_15m',
+                    'mc_prob_gain_15m': 'mc_prob_gain_15m', 'dist_ema200_15m': 'dist_ema200_15m'}
+        for k, v in cols_15m.items(): final_df[k] = df15[v]
+
+        expected = ["6", "7", "8", "9", "10", "11", "rsi", "rsi_slope", "macd_h", "macd_h_slope", "adx", "dmp", "dmn", 
+                    "trend_net_force", "ema_20", "ema_50", "ema_200", "dist_ema20", "dist_ema50", "dist_ema200", 
+                    "slope_ema50", "atr", "atr_rel", "obv", "obv_slope", "cmf", "log_ret", "mc_skew", "mc_kurt", 
+                    "mc_prob_gain", "mc_var_95", "mc_shock", "rsi_5m", "rsi_slope_5m", "macd_h_5m", "mc_prob_gain_5m", 
+                    "mc_shock_5m", "rsi_15m", "macd_h_15m", "trend_net_force_15m", "mc_prob_gain_15m", "dist_ema200_15m"]
+        
+        return sanitize_features(final_df.reindex(columns=expected, fill_value=0.0))
+    except: return None
 
 # ============================================================
-# 🧪 THE BACKTESTER CLASS
+# 🧪 THE BACKTESTER
 # ============================================================
 class HeavyDutyBacktester:
     def __init__(self, data_manager, processor):
@@ -369,43 +325,36 @@ class HeavyDutyBacktester:
         self.MAX_SLOTS = 4         
         self.TARGET_COINS = ['SOL/USDT', 'XRP/USDT', 'DOGE/USDT']
         self.force_start_date = None; self.force_end_date = None   
-        
         if os.path.exists(CACHE_DIR):
             for f in glob.glob(os.path.join(CACHE_DIR, "*")): os.remove(f)
         else: os.makedirs(CACHE_DIR)
-            
-        print(f"🧪 [Backtest V128.0] Armored Edition. Checking Engines...")
         self._check_engines()
 
     def _check_engines(self):
         status = []
-        if self.proc.titan and self.proc.titan.model: status.append("Titan(Real)")
-        else: print("❌ Titan Model MISSING")
-        if self.proc.pattern_engine and self.proc.pattern_engine.models: status.append("Patterns(Real)")
-        else: print("⚠️ Pattern Models MISSING")
-        if self.proc.oracle: status.append("Oracle(Real)")
-        if self.proc.sniper: status.append("Sniper(Real)")
-        if self.proc.guardian_hydra: status.append("Hydra(Real)")
-        if self.proc.guardian_legacy: status.append("Legacy(Real)")
+        if self.proc.titan and self.proc.titan.model: status.append("Titan")
+        if self.proc.pattern_engine and self.proc.pattern_engine.models: status.append("Patterns")
+        if self.proc.oracle: status.append("Oracle")
+        if self.proc.sniper: status.append("Sniper")
+        if self.proc.guardian_hydra: status.append("Hydra")
+        if self.proc.guardian_legacy: status.append("Legacy")
         print(f"   ✅ Engines Ready: {', '.join(status)}")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str; self.force_end_date = end_str
 
     def _smart_predict(self, model, X):
-        """Forces predict_proba and handles shape mismatch"""
         try:
             if hasattr(model, "predict_proba"):
                 raw = model.predict_proba(X)
-                if raw.ndim == 2:
-                    return raw[:, -1] 
+                if raw.ndim == 2: return raw[:, -1] 
                 return raw 
             return model.predict(X)
-        except:
+        except Exception as e:
+            # print(f"⚠️ Predict Error: {e}") # Enable if needed
             return np.zeros(len(X) if hasattr(X, '__len__') else 0)
 
     def _extract_probs(self, raw_preds):
-        """Standardizes output to 1D probability array"""
         if isinstance(raw_preds, list): raw_preds = np.array(raw_preds)
         if raw_preds.ndim == 1: return raw_preds
         elif raw_preds.ndim == 2:
@@ -418,18 +367,15 @@ class HeavyDutyBacktester:
         limit = 1000; duration = limit * 60 * 1000
         tasks = []; curr = start_ms
         while curr < end_ms: tasks.append(curr); curr += duration
-        
         all_c = []; sem = asyncio.Semaphore(20)
         async def _fetch(ts):
             async with sem:
                 try: return await self.dm.exchange.fetch_ohlcv(sym, '1m', since=ts, limit=limit)
                 except: await asyncio.sleep(0.5); return []
-        
         chunk = 50
         for i in range(0, len(tasks), chunk):
             res = await asyncio.gather(*[_fetch(t) for t in tasks[i:i+chunk]])
             for r in res: all_c.extend(r)
-            
         seen = set(); unique = []
         for c in all_c:
             if c[0] not in seen and c[0] >= start_ms and c[0] <= end_ms:
@@ -448,7 +394,6 @@ class HeavyDutyBacktester:
         print(f"   ⚙️ [CPU] Analyzing {sym} (ALL REAL MODELS)...", flush=True)
         t0 = time.time()
 
-        # 1. Base Data
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         for c in ['open', 'high', 'low', 'close', 'volume']: df_1m[c] = df_1m[c].astype(float)
         df_1m['datetime'] = pd.to_datetime(df_1m['timestamp'], unit='ms')
@@ -458,7 +403,7 @@ class HeavyDutyBacktester:
         df_5m = df_1m.resample('5T').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'volume':'sum'}).dropna()
         df_15m = df_1m.resample('15T').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'volume':'sum'}).dropna()
 
-        # 1️⃣ SNIPER & L1 SCORING
+        # 1. Sniper
         df_sniper = calculate_sniper_features_exact(df_1m)
         df_sniper['rel_vol'] = df_sniper['volume'] / (df_sniper['volume'].rolling(50).mean() + 1e-9)
         df_sniper['l1_score'] = (df_sniper['rel_vol'] * 10) + ((df_sniper['atr']/df_sniper['close']) * 1000)
@@ -469,7 +414,7 @@ class HeavyDutyBacktester:
 
         print(f"     🎯 Candidates: {len(df_candidates)}. Running Deep Inference...", flush=True)
 
-        # 2️⃣ PATTERNS
+        # 2. Patterns
         res_patterns = np.full(len(df_candidates), 0.5)
         pattern_models = getattr(self.proc.pattern_engine, 'models', {})
         if pattern_models and '15m' in pattern_models:
@@ -477,24 +422,21 @@ class HeavyDutyBacktester:
                 df_15m_res = df_1m.resample('15T').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'volume':'sum'}).dropna()
                 pat_scores_15m = np.full(len(df_15m_res), 0.5)
                 pat_inputs = []; valid_15m_idxs = []
-                
                 for i in range(200, len(df_15m_res)):
                     window = df_15m_res.iloc[i-200:i]
                     vec = _transform_window_for_pattern(window)
                     if vec is not None:
                         pat_inputs.append(vec); valid_15m_idxs.append(i)
-                
                 if pat_inputs:
                     X_pat = np.array(pat_inputs)
                     pat_preds = self._smart_predict(pattern_models['15m'], xgb.DMatrix(X_pat))
                     pat_scores_15m[valid_15m_idxs] = pat_preds
-                
                 ts_15m = df_15m_res.index.astype(np.int64) // 10**6
                 map_idxs = np.searchsorted(ts_15m, df_candidates['timestamp'].values) - 1
                 res_patterns = pat_scores_15m[np.clip(map_idxs, 0, len(pat_scores_15m)-1)]
             except Exception as e: print(f"Patterns Error: {e}")
 
-        # 3️⃣ TITAN
+        # 3. Titan
         res_titan = np.full(len(df_candidates), 0.5)
         if self.proc.titan and self.proc.titan.model:
             try:
@@ -502,13 +444,11 @@ class HeavyDutyBacktester:
                 ts_5m = df_5m.index.astype(np.int64) // 10**6
                 map_idxs = np.clip(np.searchsorted(ts_5m, df_candidates['timestamp'].values) - 1, 0, len(df_5m_feat)-1)
                 feats = self.proc.titan.feature_names
-                
                 X_titan_df = sanitize_features(df_5m_feat.iloc[map_idxs].reindex(columns=feats, fill_value=0))
-                X_titan = X_titan_df.values
-                res_titan = self.proc.titan.model.predict(xgb.DMatrix(X_titan, feature_names=feats))
+                res_titan = self.proc.titan.model.predict(xgb.DMatrix(X_titan_df.values, feature_names=feats))
             except Exception as e: print(f"Titan Error: {e}")
 
-        # 4️⃣ SNIPER
+        # 4. Sniper
         res_sniper = np.full(len(df_candidates), 0.5)
         sniper_models = getattr(self.proc.sniper, 'models', [])
         if sniper_models:
@@ -519,7 +459,7 @@ class HeavyDutyBacktester:
                 res_sniper = np.mean(preds, axis=0)
             except Exception as e: print(f"Sniper Error: {e}")
 
-        # 5️⃣ ORACLE
+        # 5. Oracle
         res_oracle = np.full(len(df_candidates), 0.5)
         oracle_model = getattr(self.proc.oracle, 'model_direction', None)
         if oracle_model:
@@ -529,11 +469,10 @@ class HeavyDutyBacktester:
                 if 'sim_titan_score' in X_orc_df: X_orc_df['sim_titan_score'] = res_titan
                 if 'sim_pattern_score' in X_orc_df: X_orc_df['sim_pattern_score'] = res_patterns
                 if 'sim_mc_score' in X_orc_df: X_orc_df['sim_mc_score'] = 0.5
-                
                 res_oracle = self._extract_probs(self._smart_predict(oracle_model, X_orc_df.values))
             except Exception as e: print(f"Oracle Error: {e}")
 
-        # 6️⃣ HYDRA
+        # 6. Hydra
         res_hydra_risk = np.zeros(len(df_candidates))
         hydra_models = getattr(self.proc.guardian_hydra, 'models', {})
         if hydra_models and 'crash' in hydra_models:
@@ -543,71 +482,57 @@ class HeavyDutyBacktester:
                     (df_sniper['close']-df_sniper['close'].rolling(20).mean())/df_sniper['close'],
                     df_sniper['rel_vol'], df_sniper['atr'], df_sniper['close']
                 ]).astype(np.float32)
-                
                 global_hydra_feats = np.nan_to_num(global_hydra_feats, nan=0.0, posinf=0.0, neginf=0.0) 
-
                 window_view = sliding_window_view(global_hydra_feats, 240, axis=0).transpose(0, 2, 1)
                 c_idxs = np.searchsorted(df_sniper.index, df_candidates.index)
                 valid_s = c_idxs + 1
                 valid_mask_h = valid_s < (len(global_hydra_feats) - 240)
                 final_s = valid_s[valid_mask_h]; res_idxs = np.where(valid_mask_h)[0]
-                
                 for i in range(0, len(final_s), 5000):
                     b_idxs = final_s[i:i+5000]; r_idxs = res_idxs[i:i+5000]
                     static = window_view[b_idxs]
-                    
                     B = len(b_idxs)
                     entry = df_sniper['close'].values[b_idxs-1].reshape(B, 1)
                     s_c = static[:, 6, :]; s_atr = static[:, 5, :]
-                    
                     dist = np.maximum(1.5*s_atr, entry*0.015) + 1e-9
                     pnl = (s_c - entry)/dist
                     max_pnl = (np.maximum.accumulate(s_c, axis=1) - entry)/dist
                     atr_p = s_atr/(s_c+1e-9)
-                    
                     zeros = np.zeros((B, 240)); ones = np.ones((B, 240)); t = np.tile(np.arange(1, 241), (B, 1))
                     X = np.stack([
                         static[:,0], static[:,1], static[:,2], static[:,3], static[:,4],
                         zeros, atr_p, pnl, max_pnl, zeros, zeros, t, zeros, ones*0.6, ones*0.7, ones*3
                     ], axis=2).reshape(-1, 16)
-                    
                     X = np.nan_to_num(X, nan=0.0, posinf=0.0, neginf=0.0)
                     preds = hydra_models['crash'].predict_proba(X)[:, 1].reshape(B, 240)
                     res_hydra_risk[r_idxs] = np.max(preds, axis=1)
             except: pass
 
-        # 7️⃣ REAL LEGACY GUARD
+        # 7. Legacy
         res_legacy_v2 = np.zeros(len(df_candidates))
         res_legacy_v3 = np.zeros(len(df_candidates))
-        
         if self.proc.guardian_legacy:
             try:
                 X_v2_full = calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m)
                 v3_df_full = calculate_legacy_v3_vectorized(df_1m, df_5m, df_15m)
-                
                 all_indices = np.arange(len(df_1m))
                 cand_indices = all_indices[valid_mask]
                 max_len = len(df_1m)
                 cand_indices = cand_indices[cand_indices < max_len]
-                
                 if len(cand_indices) > 0:
                     if self.proc.guardian_legacy.model_v2 and X_v2_full is not None:
                         subset_v2 = X_v2_full[cand_indices]
                         preds_v2 = self.proc.guardian_legacy.model_v2.predict(xgb.DMatrix(subset_v2))
                         if len(preds_v2.shape) > 1: res_legacy_v2[:len(cand_indices)] = preds_v2[:, 2] 
                         else: res_legacy_v2[:len(cand_indices)] = preds_v2
-
                     if self.proc.guardian_legacy.model_v3 and v3_df_full is not None:
                         subset_v3_df = v3_df_full.iloc[cand_indices]
                         preds_v3 = self.proc.guardian_legacy.model_v3.predict(xgb.DMatrix(subset_v3_df))
                         res_legacy_v3[:len(cand_indices)] = preds_v3
+            except Exception as e: print(f"Legacy Error: {e}")
 
-            except Exception as e:
-                print(f"❌ Legacy Guard Error: {e}")
-
-        # 8️⃣ FINAL ASSEMBLY
+        # 8. Assembly
         print(f"     📊 [Stats] Titan:{res_titan.mean():.2f} | Patterns:{res_patterns.mean():.2f} | Sniper:{res_sniper.mean():.2f} | Oracle:{res_oracle.mean():.2f}")
-        
         ai_df = pd.DataFrame({
             'timestamp': df_candidates['timestamp'],
             'symbol': sym,
@@ -620,7 +545,6 @@ class HeavyDutyBacktester:
             'risk_legacy_v2': res_legacy_v2,    
             'risk_legacy_v3': res_legacy_v3     
         })
-
         dt = time.time() - t0
         if not ai_df.empty:
             ai_df.to_pickle(scores_file)
@@ -647,7 +571,6 @@ class HeavyDutyBacktester:
         if not data: return []
         df = pd.concat(data).sort_values('timestamp')
         
-        # Arrays
         ts = df['timestamp'].values; close = df['close'].values.astype(float)
         sym = df['symbol'].values; sym_map = {s:i for i,s in enumerate(np.unique(sym))}
         sym_id = np.array([sym_map[s] for s in sym])
@@ -655,9 +578,7 @@ class HeavyDutyBacktester:
         oracle = df['oracle_conf'].values; sniper = df['sniper_score'].values
         hydra = df['risk_hydra_crash'].values; titan = df['real_titan'].values
         l1 = df['l1_score'].values
-        
-        legacy_v2 = df['risk_legacy_v2'].values 
-        legacy_v3 = df['risk_legacy_v3'].values 
+        legacy_v2 = df['risk_legacy_v2'].values; legacy_v3 = df['risk_legacy_v3'].values 
         
         N = len(ts)
         print(f"     🚀 [System] Testing {len(combinations_batch)} configs on {N} candles...", flush=True)
@@ -666,38 +587,30 @@ class HeavyDutyBacktester:
         for cfg in combinations_batch:
             pos = {}; log = [] 
             bal = initial_capital; alloc = 0.0
-            
             mask = (l1 >= cfg['l1_thresh']) & (oracle >= cfg['oracle_thresh']) & (sniper >= cfg['sniper_thresh'])
             
             for i in range(N):
                 s = sym_id[i]; p = close[i]
-                
-                # Exit
                 if s in pos:
                     entry = pos[s][0]; h_r = pos[s][1]; titan_entry = pos[s][3]
-                    
                     crash_hydra = (h_r > cfg['hydra_thresh']) 
                     panic_legacy = (legacy_v2[i] > cfg['legacy_thresh']) or (legacy_v3[i] > cfg['legacy_thresh'])
-                    
                     pnl = (p - entry)/entry
                     
                     if crash_hydra or panic_legacy or pnl > 0.04 or pnl < -0.02:
                         realized = pnl - fees_pct*2
                         bal += pos[s][2] * (1 + realized)
                         alloc -= pos[s][2]
-                        
                         is_consensus = (titan_entry > 0.55)
                         log.append({'pnl': realized, 'consensus': is_consensus})
                         del pos[s]
                 
-                # Entry
                 if len(pos) < max_slots and mask[i]:
                     if s not in pos and bal >= 5.0:
                         size = min(10.0, bal * 0.98)
                         pos[s] = (p, hydra[i], size, titan[i])
                         bal -= size; alloc += size
             
-            # Metrics
             final_bal = bal + alloc
             profit = final_bal - initial_capital
             tot = len(log)
@@ -721,25 +634,19 @@ class HeavyDutyBacktester:
 
     async def run_optimization(self, target_regime="RANGE"):
         await self.generate_truth_data()
-        
-        # Grid
         oracle_r = np.linspace(0.3, 0.7, 3); sniper_r = np.linspace(0.2, 0.6, 3)
         hydra_r = [0.8, 0.9]; l1_r = [5.0, 10.0]
         
         combos = []
         for o, s, h, l1 in itertools.product(oracle_r, sniper_r, hydra_r, l1_r):
             combos.append({
-                'w_titan': 0.4, 'w_struct': 0.3,
-                'thresh': l1, 'l1_thresh': l1, 
+                'w_titan': 0.4, 'w_struct': 0.3, 'thresh': l1, 'l1_thresh': l1, 
                 'oracle_thresh': o, 'sniper_thresh': s, 'hydra_thresh': h, 'legacy_thresh': 0.95
             })
             
         files = glob.glob(os.path.join(CACHE_DIR, "*.pkl"))
         results_list = self._worker_optimize(combos, files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
-        
-        if not results_list:
-            print("⚠️ [Warning] No trades generated in any config.")
-            return None, {'net_profit': 0.0, 'win_rate': 0.0}
+        if not results_list: return None, {'net_profit': 0.0, 'win_rate': 0.0}
 
         results_list.sort(key=lambda x: x['net_profit'], reverse=True)
         best = results_list[0]
@@ -751,7 +658,6 @@ class HeavyDutyBacktester:
         print("-" * 60)
         print(f"   📊 Total Trades:    {best['total_trades']}")
         print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
-        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}%")
         print("-" * 60)
         print(f"   🧠 CONSENSUS ANALYTICS:")
         print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}%")
@@ -759,18 +665,15 @@ class HeavyDutyBacktester:
         print(f"   💎 High-Consensus Avg PnL:   {best['high_consensus_avg_pnl']:.2f}%")
         print("-" * 60)
         print(f"   ⚙️ Oracle={best['config']['oracle_thresh']:.2f} | Sniper={best['config']['sniper_thresh']:.2f} | Hydra={best['config']['hydra_thresh']:.2f}")
-        print(f"   ⚖️ Weights: Titan={best['config']['w_titan']:.2f} | Patterns={best['config']['w_struct']:.2f} | L1={best['config']['thresh']}")
         print("="*60)
         return best['config'], best
 
 async def run_strategic_optimization_task():
     print("\n🧪 [STRATEGIC BACKTEST] Full Spectrum Mode...")
     r2 = R2Service(); dm = DataManager(None, None, r2); proc = MLProcessor(dm)
-    
     try:
         await dm.initialize(); await proc.initialize()
         if proc.guardian_hydra: proc.guardian_hydra.set_silent_mode(True)
-
         hub = AdaptiveHub(r2); await hub.initialize()
         opt = HeavyDutyBacktester(dm, proc)
         
@@ -785,10 +688,8 @@ async def run_strategic_optimization_task():
             opt.set_date_range(s["start"], s["end"])
             best_cfg, best_stats = await opt.run_optimization(s["regime"])
             if best_cfg: hub.submit_challenger(s["regime"], best_cfg, best_stats)
-        
         await hub._save_state_to_r2()
         print("✅ [System] DNA Updated.")
-
     finally:
         print("🔌 [System] Closing connections...")
         await dm.close()