Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V112.0 - GEM-Architect: Matrix Batch Speed)
+# 🧪 backtest_engine.py (V113.0 - GEM-Architect: Global Pre-Inference)
 # ============================================================
 
 import asyncio
@@ -55,7 +55,7 @@ class HeavyDutyBacktester:
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V112.0] Matrix-Batch Speed (No Loops Inside Signals).")
+        print(f"🧪 [Backtest V113.0] Pre-Inference Velocity Mode (Target: 60s).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -104,7 +104,7 @@ class HeavyDutyBacktester:
         return unique_candles
 
     # ==============================================================
-    # 🏎️ VECTORIZED INDICATORS (ALL LAYERS + LAGS)
+    # 🏎️ VECTORIZED INDICATORS
     # ==============================================================
     def _calculate_indicators_vectorized(self, df, timeframe='1m'):
         df['close'] = df['close'].astype(float)
@@ -118,7 +118,6 @@ class HeavyDutyBacktester:
         df['ema50'] = ta.ema(df['close'], length=50)
         df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
         
-        # Hydra
         if timeframe == '1m':
             sma20 = df['close'].rolling(20).mean()
             std20 = df['close'].rolling(20).std()
@@ -126,14 +125,12 @@ class HeavyDutyBacktester:
             df['vol_ma50'] = df['volume'].rolling(50).mean()
             df['rel_vol'] = df['volume'] / (df['vol_ma50'] + 1e-9)
 
-        # Oracle
         df['slope'] = ta.slope(df['close'], length=7)
         vol_mean = df['volume'].rolling(20).mean()
         vol_std = df['volume'].rolling(20).std()
         df['vol_z'] = (df['volume'] - vol_mean) / (vol_std + 1e-9)
         df['atr_pct'] = df['atr'] / df['close']
 
-        # Sniper
         if timeframe == '1m':
             df['ret'] = df['close'].pct_change()
             df['dollar_vol'] = df['close'] * df['volume']
@@ -159,7 +156,6 @@ class HeavyDutyBacktester:
             s = df['volume'].rolling(500).std()
             df['vol_zscore_50'] = ((df['volume'] - r) / s).fillna(0)
 
-        # Legacy Structure
         df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
         roll_max = df['high'].rolling(50).max()
         roll_min = df['low'].rolling(50).min()
@@ -173,7 +169,7 @@ class HeavyDutyBacktester:
         df['ema200'] = ta.ema(df['close'], length=200)
         df['dist_ema200'] = (df['close'] - df['ema200']) / df['close']
         
-        # ✅ PRE-CALCULATE LAGS FOR V2 (This enables Batch Processing)
+        # Lags for V2
         if timeframe == '1m':
             for lag in [1, 2, 3, 5, 10, 20]:
                 df[f'log_ret_lag_{lag}'] = df['log_ret'].shift(lag).fillna(0)
@@ -185,7 +181,7 @@ class HeavyDutyBacktester:
         return df
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (Matrix Batch Mode)
+    # 🧠 CPU PROCESSING (PRE-INFERENCE OPTIMIZED)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -196,7 +192,7 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Analyzing {sym} (Matrix Batch Mode)...", flush=True)
+        print(f"   ⚙️ [CPU] Analyzing {sym} (Global Pre-Inference)...", flush=True)
         t0 = time.time()
 
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
@@ -207,7 +203,7 @@ class HeavyDutyBacktester:
         frames = {}
         agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
         
-        # 1. Calc 1m with Lags
+        # 1. Calc 1m
         frames['1m'] = self._calculate_indicators_vectorized(df_1m.copy(), timeframe='1m')
         frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
         fast_1m = {col: frames['1m'][col].values for col in frames['1m'].columns}
@@ -221,19 +217,93 @@ class HeavyDutyBacktester:
             frames[tf_str] = resampled
             numpy_htf[tf_str] = {col: resampled[col].values for col in resampled.columns}
 
-        # 3. Create Global Index Maps (The Magic Step for Speed)
-        # Allows instant mapping from 1m index -> 5m/15m index without searching inside loop
-        # Using searchsorted on the whole array once
+        # 3. Global Index Maps
         map_1m_to_1h = np.searchsorted(numpy_htf['1h']['timestamp'], fast_1m['timestamp'])
         map_1m_to_5m = np.searchsorted(numpy_htf['5m']['timestamp'], fast_1m['timestamp'])
         map_1m_to_15m = np.searchsorted(numpy_htf['15m']['timestamp'], fast_1m['timestamp'])
         
-        # Clamp indices to valid range
-        map_1m_to_1h = np.clip(map_1m_to_1h, 0, len(numpy_htf['1h']['timestamp']) - 1)
-        map_1m_to_5m = np.clip(map_1m_to_5m, 0, len(numpy_htf['5m']['timestamp']) - 1)
-        map_1m_to_15m = np.clip(map_1m_to_15m, 0, len(numpy_htf['15m']['timestamp']) - 1)
+        # Clip
+        max_idx_1h = len(numpy_htf['1h']['timestamp']) - 1
+        max_idx_5m = len(numpy_htf['5m']['timestamp']) - 1
+        max_idx_15m = len(numpy_htf['15m']['timestamp']) - 1
+        
+        map_1m_to_1h = np.clip(map_1m_to_1h, 0, max_idx_1h)
+        map_1m_to_5m = np.clip(map_1m_to_5m, 0, max_idx_5m)
+        map_1m_to_15m = np.clip(map_1m_to_15m, 0, max_idx_15m)
+
+        # 4. Load Models
+        hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
+        hydra_cols = getattr(self.proc.guardian_hydra, 'feature_cols', []) if self.proc.guardian_hydra else []
+        legacy_v2 = getattr(self.proc.guardian_legacy, 'model_v2', None)
+        
+        # 5. 🔥 PRE-CALCULATE LEGACY V2 (GLOBAL) 🔥
+        # V2 depends only on structure, not entry price. We can predict for ALL rows at once.
+        global_v2_probs = np.zeros(len(fast_1m['close']))
+        
+        if legacy_v2:
+            print(f"     🚀 Pre-calculating Legacy V2 for entire history...", flush=True)
+            try:
+                # 1m Feats
+                l_log = fast_1m['log_ret']
+                l_rsi = fast_1m['rsi'] / 100.0
+                l_fib = fast_1m['fib_pos']
+                l_vol = fast_1m['volatility']
+                
+                # HTF Feats Mapped to 1m
+                l5_log = numpy_htf['5m']['log_ret'][map_1m_to_5m]
+                l5_rsi = numpy_htf['5m']['rsi'][map_1m_to_5m] / 100.0
+                l5_fib = numpy_htf['5m']['fib_pos'][map_1m_to_5m]
+                l5_trd = numpy_htf['5m']['trend_slope'][map_1m_to_5m]
+                
+                l15_log = numpy_htf['15m']['log_ret'][map_1m_to_15m]
+                l15_rsi = numpy_htf['15m']['rsi'][map_1m_to_15m] / 100.0
+                l15_fib618 = numpy_htf['15m']['dist_fib618'][map_1m_to_15m]
+                l15_trd = numpy_htf['15m']['trend_slope'][map_1m_to_15m]
+                
+                # Lags
+                lag_cols = []
+                for lag in [1, 2, 3, 5, 10, 20]:
+                    lag_cols.append(fast_1m[f'log_ret_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'rsi_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'fib_pos_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'volatility_lag_{lag}'])
+                
+                # Huge Matrix
+                X_GLOBAL_V2 = np.column_stack([
+                    l_log, l_rsi, l_fib, l_vol,
+                    l5_log, l5_rsi, l5_fib, l5_trd,
+                    l15_log, l15_rsi, l15_fib618, l15_trd,
+                    *lag_cols
+                ])
+                
+                # Predict All in One Go
+                dm_glob = xgb.DMatrix(X_GLOBAL_V2)
+                preds_glob = legacy_v2.predict(dm_glob)
+                global_v2_probs = preds_glob[:, 2] if len(preds_glob.shape) > 1 else preds_glob
+                
+            except Exception as e: print(f"V2 Error: {e}")
+
+        # 6. 🔥 PRE-ASSEMBLE HYDRA STATIC (GLOBAL) 🔥
+        # Hydra needs PnL (dynamic), but 90% features are static.
+        global_hydra_static = None
+        if hydra_models:
+            print(f"     🚀 Pre-assembling Hydra features...", flush=True)
+            try:
+                # Map columns that don't depend on PnL
+                h_rsi_1m = fast_1m['rsi']
+                h_rsi_5m = numpy_htf['5m']['rsi'][map_1m_to_5m]
+                h_rsi_15m = numpy_htf['15m']['rsi'][map_1m_to_15m]
+                h_bb = fast_1m['bb_width']
+                h_vol = fast_1m['rel_vol']
+                h_atr = fast_1m['atr']
+                h_close = fast_1m['close']
+                
+                # We store these separate to combine inside loop efficiently
+                # [rsi1, rsi5, rsi15, bb, vol, atr, close]
+                global_hydra_static = np.column_stack([h_rsi_1m, h_rsi_5m, h_rsi_15m, h_bb, h_vol, h_atr, h_close])
+            except: pass
 
-        # 4. L1 Filter
+        # 7. Candidate Filtering
         df_1h = frames['1h'].reindex(frames['5m'].index, method='ffill')
         df_5m = frames['5m'].copy()
         is_valid = (df_1h['rsi'] <= 70) 
@@ -242,41 +312,28 @@ class HeavyDutyBacktester:
         final_valid_indices = [t for t in valid_indices if t >= start_dt]
         
         total_signals = len(final_valid_indices)
-        print(f"     🎯 Candidates: {total_signals}. Running Matrix Models...", flush=True)
+        print(f"     🎯 Candidates: {total_signals}. Running Models...", flush=True)
 
-        # 5. Load Models
-        hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
-        hydra_cols = getattr(self.proc.guardian_hydra, 'feature_cols', []) if self.proc.guardian_hydra else []
-        
-        legacy_v2 = getattr(self.proc.guardian_legacy, 'model_v2', None)
-        legacy_v3 = getattr(self.proc.guardian_legacy, 'model_v3', None)
-        v3_feat_names = getattr(self.proc.guardian_legacy, 'v3_feature_names', [])
-        
         oracle_dir_model = getattr(self.proc.oracle, 'model_direction', None)
         oracle_cols = getattr(self.proc.oracle, 'feature_cols', [])
         sniper_models = getattr(self.proc.sniper, 'models', [])
         sniper_cols = getattr(self.proc.sniper, 'feature_names', [])
 
-        ai_results = [] 
+        ai_results = []
+        
+        # Pre-allocate Hydra time vector (0 to 240)
+        time_vec = np.arange(1, 241)
 
-        # --- 6. Main Simulation Loop (BATCH MODE) ---
+        # --- MAIN LOOP (Optimized Lookups) ---
         for i, current_time in enumerate(final_valid_indices):
-            if i > 0 and i % 1000 == 0:
-                print(f"     ⏳ [{sym}] Processing... {i}/{total_signals}", flush=True)
-
             ts_val = int(current_time.timestamp() * 1000)
-            
-            # Find Entry Index
             idx_1m = np.searchsorted(fast_1m['timestamp'], ts_val)
             
-            # Safety Check
             if idx_1m < 500 or idx_1m >= len(fast_1m['close']) - 245: continue
             
-            # Determine Indices
             idx_1h = map_1m_to_1h[idx_1m]
-            idx_5m = map_1m_to_5m[idx_1m]
             idx_15m = map_1m_to_15m[idx_1m]
-            idx_4h = np.searchsorted(numpy_htf['4h']['timestamp'], ts_val) # Do this once per signal (rare)
+            idx_4h = np.searchsorted(numpy_htf['4h']['timestamp'], ts_val)
             if idx_4h >= len(numpy_htf['4h']['close']): idx_4h = len(numpy_htf['4h']['close']) - 1
 
             # === Oracle (Single Call) ===
@@ -311,138 +368,73 @@ class HeavyDutyBacktester:
                     sniper_score = np.mean(s_preds)
                 except: pass
 
-            # === RISK SIMULATION (MATRIX BATCH) ===
-            # We construct a matrix of 240 rows (4 hours) at once and predict ONCE.
-            # This replaces the minute-by-minute loop.
-            
-            future_len = 240
+            # === RISK SIMULATION (ULTRA FAST) ===
             start_idx = idx_1m + 1
-            end_idx = start_idx + future_len
-            
-            # Slices for 1m data
-            sl_close = fast_1m['close'][start_idx:end_idx]
-            sl_ts = fast_1m['timestamp'][start_idx:end_idx]
-            
-            entry_price = fast_1m['close'][idx_1m]
+            end_idx = start_idx + 240
             
-            # Mapped Indices for HTF slices
-            sl_map_5m = map_1m_to_5m[start_idx:end_idx]
-            sl_map_15m = map_1m_to_15m[start_idx:end_idx]
-            
-            max_hydra_crash = 0.0; hydra_crash_time = 0
+            # 1. LEGACY V2 (Instant Lookup)
             max_legacy_v2 = 0.0; legacy_panic_time = 0
-            
-            # --- A. Hydra Batch ---
-            if hydra_models:
-                sl_atr = fast_1m['atr'][start_idx:end_idx]
-                sl_rsi_1m = fast_1m['rsi'][start_idx:end_idx]
-                sl_bb = fast_1m['bb_width'][start_idx:end_idx]
-                sl_vol = fast_1m['rel_vol'][start_idx:end_idx]
+            if legacy_v2:
+                # Just slice the pre-calculated array!
+                probs_slice = global_v2_probs[start_idx:end_idx]
+                max_legacy_v2 = np.max(probs_slice)
+                panic_indices = np.where(probs_slice > 0.8)[0]
+                if len(panic_indices) > 0:
+                    legacy_panic_time = int(fast_1m['timestamp'][start_idx + panic_indices[0]])
+
+            # 2. HYDRA (Semi-Vectorized)
+            max_hydra_crash = 0.0; hydra_crash_time = 0
+            if hydra_models and global_hydra_static is not None:
+                # Slice Static Feats
+                sl_static = global_hydra_static[start_idx:end_idx] # [rsi1, rsi5, rsi15, bb, vol, atr, close]
                 
-                # HTF Lookups (Using integer array indexing - Fast)
-                sl_rsi_5m = numpy_htf['5m']['rsi'][sl_map_5m]
-                sl_rsi_15m = numpy_htf['15m']['rsi'][sl_map_15m]
+                entry_price = fast_1m['close'][idx_1m]
+                sl_close = sl_static[:, 6]
+                sl_atr = sl_static[:, 5]
                 
-                # Calc Features
+                # Calc Dynamic Feats
                 sl_dist = 1.5 * sl_atr
                 sl_dist = np.where(sl_dist > 0, sl_dist, entry_price * 0.015)
                 
-                # PnL & Max PnL
                 sl_pnl = sl_close - entry_price
                 sl_norm_pnl = sl_pnl / sl_dist
                 
-                # Max PnL needs cumulative max (rolling max from start of trade)
                 sl_cum_max = np.maximum.accumulate(sl_close)
-                # Correction: cum max of trade needs to start from entry price
                 sl_cum_max = np.maximum(sl_cum_max, entry_price)
                 sl_max_pnl_r = (sl_cum_max - entry_price) / sl_dist
                 
                 sl_atr_pct = sl_atr / sl_close
-                sl_time = np.arange(1, future_len + 1)
                 
-                # Stack Matrix: (240, N_Features)
-                # Feature Order Must Match hydra_cols
-                # Map cols manually to speed up
+                # Map to Hydra Cols Order (Hardcoded for max speed)
+                # Cols: rsi_1m, rsi_5m, rsi_15m, bb_width, rel_vol, dist_ema20_1h, atr_pct, norm_pnl_r, max_pnl_r, dists..., time, entry, oracle, l2, target
                 
-                # Create dict of vectors
-                feat_vecs = {
-                    'rsi_1m': sl_rsi_1m, 'rsi_5m': sl_rsi_5m, 'rsi_15m': sl_rsi_15m,
-                    'bb_width': sl_bb, 'rel_vol': sl_vol,
-                    'dist_ema20_1h': np.zeros(future_len),
-                    'atr_pct': sl_atr_pct, 'norm_pnl_r': sl_norm_pnl, 'max_pnl_r': sl_max_pnl_r,
-                    'dist_tp_atr': np.zeros(future_len), 'dist_sl_atr': np.zeros(future_len),
-                    'time_in_trade': sl_time,
-                    'entry_type': np.zeros(future_len), 'oracle_conf': np.full(future_len, oracle_conf),
-                    'l2_score': np.full(future_len, 0.7), 'target_class': np.full(future_len, 3.0)
-                }
+                # Re-assemble only what is needed
+                # (Static 0-4) + (Zeros) + (Dynamic) + (Constants)
                 
-                # Stack
-                X_hydra = np.column_stack([feat_vecs.get(c, np.zeros(future_len)) for c in hydra_cols])
+                # Create arrays for constants
+                zeros = np.zeros(240)
+                oracle_arr = np.full(240, oracle_conf)
+                l2_arr = np.full(240, 0.7)
+                target_arr = np.full(240, 3.0)
+                
+                X_hydra = np.column_stack([
+                    sl_static[:, 0], sl_static[:, 1], sl_static[:, 2], # RSIs
+                    sl_static[:, 3], sl_static[:, 4], # BB, Vol
+                    zeros, # dist_ema
+                    sl_atr_pct, sl_norm_pnl, sl_max_pnl_r,
+                    zeros, zeros, # dists
+                    time_vec, # time
+                    zeros, oracle_arr, l2_arr, target_arr
+                ])
                 
                 try:
-                    # ONE PREDICTION FOR 240 ROWS
                     probs_crash = hydra_models['crash'].predict_proba(X_hydra)[:, 1]
-                    
-                    # Find Max
                     max_hydra_crash = np.max(probs_crash)
-                    
-                    # Find Time
                     crash_indices = np.where(probs_crash > 0.6)[0]
                     if len(crash_indices) > 0:
-                        hydra_crash_time = int(sl_ts[crash_indices[0]])
+                        hydra_crash_time = int(fast_1m['timestamp'][start_idx + crash_indices[0]])
                 except: pass
 
-            # --- B. Legacy V2 Batch ---
-            if legacy_v2:
-                # 1m Feats
-                l_log = fast_1m['log_ret'][start_idx:end_idx]
-                l_rsi = fast_1m['rsi'][start_idx:end_idx] / 100.0
-                l_fib = fast_1m['fib_pos'][start_idx:end_idx]
-                l_vol = fast_1m['volatility'][start_idx:end_idx]
-                
-                # 5m Feats (Mapped)
-                l5_log = numpy_htf['5m']['log_ret'][sl_map_5m]
-                l5_rsi = numpy_htf['5m']['rsi'][sl_map_5m] / 100.0
-                l5_fib = numpy_htf['5m']['fib_pos'][sl_map_5m]
-                l5_trd = numpy_htf['5m']['trend_slope'][sl_map_5m]
-                
-                # 15m Feats (Mapped)
-                l15_log = numpy_htf['15m']['log_ret'][sl_map_15m]
-                l15_rsi = numpy_htf['15m']['rsi'][sl_map_15m] / 100.0
-                l15_fib618 = numpy_htf['15m']['dist_fib618'][sl_map_15m]
-                l15_trd = numpy_htf['15m']['trend_slope'][sl_map_15m]
-                
-                # Lags (Pre-calculated in _calculate_indicators_vectorized)
-                # We just pull them from fast_1m
-                lag_cols = []
-                for lag in [1, 2, 3, 5, 10, 20]:
-                    lag_cols.append(fast_1m[f'log_ret_lag_{lag}'][start_idx:end_idx])
-                    lag_cols.append(fast_1m[f'rsi_lag_{lag}'][start_idx:end_idx])
-                    lag_cols.append(fast_1m[f'fib_pos_lag_{lag}'][start_idx:end_idx])
-                    lag_cols.append(fast_1m[f'volatility_lag_{lag}'][start_idx:end_idx])
-                
-                # Stack All
-                X_v2 = np.column_stack([
-                    l_log, l_rsi, l_fib, l_vol,
-                    l5_log, l5_rsi, l5_fib, l5_trd,
-                    l15_log, l15_rsi, l15_fib618, l15_trd,
-                    *lag_cols
-                ])
-                
-                try:
-                    # PREDICT BATCH
-                    dm_v2 = xgb.DMatrix(X_v2)
-                    preds_v2 = legacy_v2.predict(dm_v2)
-                    # Handle Multiclass
-                    probs_v2 = preds_v2[:, 2] if len(preds_v2.shape) > 1 else preds_v2
-                    
-                    max_legacy_v2 = np.max(probs_v2)
-                    panic_idx = np.where(probs_v2 > 0.8)[0]
-                    if len(panic_idx) > 0 and legacy_panic_time == 0:
-                        legacy_panic_time = int(sl_ts[panic_idx[0]])
-                except: pass
-
-            # --- Store Result ---
             ai_results.append({
                 'timestamp': ts_val, 'symbol': sym, 'close': entry_price,
                 'real_titan': 0.6, 
@@ -459,11 +451,11 @@ class HeavyDutyBacktester:
         dt = time.time() - t0
         if ai_results:
             pd.DataFrame(ai_results).to_pickle(scores_file)
-            print(f"   ✅ [{sym}] Batch-Processed {len(ai_results)} signals in {dt:.2f} seconds.", flush=True)
+            print(f"   ✅ [{sym}] Completed {len(ai_results)} signals in {dt:.2f} seconds.", flush=True)
         else:
             print(f"   ⚠️ [{sym}] No valid signals. Time: {dt:.2f}s", flush=True)
             
-        del frames, fast_1m, numpy_htf
+        del frames, fast_1m, numpy_htf, global_v2_probs, global_hydra_static
         gc.collect()
 
     # ==============================================================
@@ -508,16 +500,13 @@ class HeavyDutyBacktester:
             for ts, group in grouped_by_time:
                 active = list(wallet["positions"].keys())
                 current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
-                
                 for sym in active:
                     if sym in current_prices:
                         curr = current_prices[sym]
                         pos = wallet["positions"][sym]
-                        
                         h_risk = pos.get('risk_hydra_crash', 0)
                         h_time = pos.get('time_hydra_crash', 0)
                         is_crash = (h_risk > hydra_thresh) and (h_time > 0) and (ts >= h_time)
-                        
                         pnl = (curr - pos['entry']) / pos['entry']
                         if is_crash or pnl > 0.04 or pnl < -0.02:
                             wallet['balance'] += pos['size'] * (1 + pnl - (fees_pct*2))
@@ -569,7 +558,6 @@ class HeavyDutyBacktester:
                 'config': config, 'final_balance': final_bal, 'net_profit': net_profit,
                 'total_trades': total_t, 'win_count': win_count, 'loss_count': loss_count,
                 'win_rate': win_rate, 'max_single_win': max_win, 'max_single_loss': max_loss,
-                'max_win_streak': max_win_streak, 'max_loss_streak': max_loss_streak,
                 'max_drawdown': max_drawdown * 100
             })
             
@@ -577,11 +565,9 @@ class HeavyDutyBacktester:
 
     async def run_optimization(self, target_regime="RANGE"):
         await self.generate_truth_data()
-        
         oracle_range = [0.5, 0.6, 0.7]
         sniper_range = [0.4, 0.5, 0.6]
         hydra_range = [0.75, 0.85, 0.95]
-        
         combinations = []
         for o, s, h in itertools.product(oracle_range, sniper_range, hydra_range):
             combinations.append({
@@ -595,7 +581,6 @@ class HeavyDutyBacktester:
         
         print(f"\n🧩 [Phase 2] Optimizing {len(combinations)} Configs (Full Stack) for {target_regime}...")
         best_res = self._worker_optimize(combinations, current_period_files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
-        
         if not best_res: return None, None
         best = sorted(best_res, key=lambda x: x['final_balance'], reverse=True)[0]
         
@@ -618,6 +603,7 @@ class HeavyDutyBacktester:
         print("-" * 60)
         print(f"   ⚙️ Oracle={best['config']['oracle_thresh']} | Sniper={best['config']['sniper_thresh']} | Hydra={best['config']['hydra_thresh']}")
         print("="*60)
+        return best['config'], best
 
 async def run_strategic_optimization_task():
     print("\n🧪 [STRATEGIC BACKTEST] Full Stack Mode...")