Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V104.0 - GEM-Architect: High Fidelity & Speed Injection)
+# 🧪 backtest_engine.py (V105.0 - GEM-Architect: ULTIMATE SPEED)
 # ============================================================
 
 import asyncio
@@ -21,6 +21,7 @@ try:
     from learning_hub.adaptive_hub import StrategyDNA, AdaptiveHub
     from r2 import R2Service
     import ccxt.async_support as ccxt 
+    import xgboost as xgb # Required for Direct Injection
 except ImportError:
     pass
 
@@ -31,7 +32,6 @@ class HeavyDutyBacktester:
     def __init__(self, data_manager, processor):
         self.dm = data_manager
         self.proc = processor
-        # كثافة الشبكة للدخول
         self.GRID_DENSITY = 6 
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
@@ -53,7 +53,7 @@ class HeavyDutyBacktester:
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V104.0] High-Fidelity 1-Minute Scan (Speed Injected).")
+        print(f"🧪 [Backtest V105.0] Ultimate Speed (Hydra + Legacy V2/V3 Injection).")
 
     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 (Optimized for Hydra Inputs)
+    # 🏎️ VECTORIZED INDICATORS (ALL-IN-ONE)
     # ==============================================================
     def _calculate_indicators_vectorized(self, df):
         # 1. Basic Setup
@@ -121,6 +121,7 @@ class HeavyDutyBacktester:
         df['rsi'] = 100 - (100 / (1 + rs))
         df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
         df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
+        df['ema200'] = df['close'].ewm(span=200, adjust=False).mean() # For V3
         
         # 3. ATR
         high_low = df['high'] - df['low']
@@ -130,20 +131,43 @@ class HeavyDutyBacktester:
         true_range = ranges.max(axis=1)
         df['atr'] = true_range.rolling(14).mean()
         
-        # 4. 🔥 Hydra Specifics (Pre-calc for Speed)
+        # 4. 🔥 Hydra Specifics
         sma20 = df['close'].rolling(20).mean()
         std20 = df['close'].rolling(20).std()
         df['bb_width'] = ((sma20 + 2*std20) - (sma20 - 2*std20)) / sma20
-        
         df['vol_ma20'] = df['volume'].rolling(window=20).mean()
         df['vol_ma50'] = df['volume'].rolling(window=50).mean()
         df['rel_vol'] = df['volume'] / (df['vol_ma50'] + 1e-9)
+
+        # 5. 🕸️ Legacy V2/V3 Specifics (Pre-calc)
+        # Log Returns
+        df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
+        
+        # Fib Position (Rolling Min/Max 50)
+        roll_max = df['high'].rolling(50).max()
+        roll_min = df['low'].rolling(50).min()
+        diff = (roll_max - roll_min).replace(0, 1e-9)
+        df['fib_pos'] = (df['close'] - roll_min) / diff
+        
+        # Trend Slope (EMA change)
+        df['trend_slope'] = (df['ema20'] - df['ema20'].shift(5)) / df['ema20'].shift(5)
+        
+        # Volatility (ATR/Close)
+        df['volatility'] = df['atr'] / df['close']
+        
+        # Fib 618 Distance (For V3/Legacy)
+        fib618 = roll_max - (diff * 0.382)
+        df['dist_fib618'] = (df['close'] - fib618) / df['close']
+
+        # EMA Distances (For V3)
+        df['dist_ema50'] = (df['close'] - df['ema50']) / df['close']
+        df['dist_ema200'] = (df['close'] - df['ema200']) / df['close']
         
         df.fillna(0, inplace=True)
         return df
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (1-Minute Scan)
+    # 🧠 CPU PROCESSING (Full Injection Mode)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -154,7 +178,7 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Analyzing {sym} (1-Min Fidelity)...", flush=True)
+        print(f"   ⚙️ [CPU] Analyzing {sym} (Full Speed Injection)...", flush=True)
         t0 = time.time()
 
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
@@ -162,12 +186,10 @@ class HeavyDutyBacktester:
         df_1m.set_index('datetime', inplace=True)
         df_1m = df_1m.sort_index()
 
+        # --- 1. Pre-Calculate EVERYTHING (Vectorized) ---
         frames = {}
-        numpy_frames = {}
-        time_indices = {}
         agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
         
-        # --- 1. Pre-Calculate EVERYTHING (Vectorized) ---
         frames['1m'] = df_1m.copy()
         frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
         frames['1m'] = self._calculate_indicators_vectorized(frames['1m'])
@@ -179,25 +201,44 @@ class HeavyDutyBacktester:
             'atr': frames['1m']['atr'].values,
             'bb_width': frames['1m']['bb_width'].values,
             'rel_vol': frames['1m']['rel_vol'].values,
-            'timestamp': frames['1m']['timestamp'].values
+            'timestamp': frames['1m']['timestamp'].values,
+            # Legacy Feats
+            'log_ret': frames['1m']['log_ret'].values,
+            'fib_pos': frames['1m']['fib_pos'].values,
+            'volatility': frames['1m']['volatility'].values,
+            'trend_slope': frames['1m']['trend_slope'].values,
+            'dist_fib618': frames['1m']['dist_fib618'].values,
+            'ema50': frames['1m']['ema50'].values,
+            'ema200': frames['1m']['ema200'].values,
+            'dist_ema50': frames['1m']['dist_ema50'].values,
+            'dist_ema200': frames['1m']['dist_ema200'].values,
         }
         
-        col_order = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
-        numpy_frames['1m'] = frames['1m'][col_order].values 
-        time_indices['1m'] = frames['1m'].index
-
+        # HTF
+        numpy_htf = {} 
         for tf_str, tf_code in [('5m', '5T'), ('15m', '15T'), ('1h', '1h'), ('4h', '4h'), ('1d', '1D')]:
             resampled = df_1m.resample(tf_code).agg(agg_dict).dropna()
-            if tf_str in ['15m', '1h']:
+            if tf_str in ['5m', '15m', '1h']:
                 resampled = self._calculate_indicators_vectorized(resampled)
             resampled['timestamp'] = resampled.index.astype(np.int64) // 10**6
             frames[tf_str] = resampled
-            numpy_frames[tf_str] = resampled[col_order].values
-            time_indices[tf_str] = resampled.index
-
-        ai_results = []
-        
-        # --- L1 Logic (Filter) ---
+            
+            # Store Numpy for HTF lookups
+            numpy_htf[tf_str] = {
+                'close': resampled['close'].values,
+                'rsi': resampled['rsi'].values,
+                'log_ret': resampled['log_ret'].values,
+                'fib_pos': resampled['fib_pos'].values,
+                'trend_slope': resampled['trend_slope'].values,
+                'dist_fib618': resampled['dist_fib618'].values,
+                'ema50': resampled['ema50'].values,
+                'ema200': resampled['ema200'].values,
+                'dist_ema50': resampled['dist_ema50'].values,
+                'dist_ema200': resampled['dist_ema200'].values,
+                'timestamp': resampled['timestamp'].values
+            }
+
+        # --- L1 Filter ---
         df_5m_aligned = frames['5m'].copy()
         df_1h_aligned = frames['1h'].reindex(frames['5m'].index, method='ffill')
         df_15m_aligned = frames['15m'].reindex(frames['5m'].index, method='ffill')
@@ -206,142 +247,185 @@ class HeavyDutyBacktester:
         cond_not_pump = change_4h <= 8.0
         cond_rsi_1h_safe = df_1h_aligned['rsi'] <= 70
         deviation = (df_1h_aligned['close'] - df_1h_aligned['ema20']) / df_1h_aligned['atr']
-        cond_deviation_safe = deviation <= 1.8
-        filters_pass = cond_not_pump & cond_rsi_1h_safe & cond_deviation_safe
+        filters_pass = cond_not_pump & cond_rsi_1h_safe & (deviation <= 1.8)
         
-        bullish_1h = (df_1h_aligned['ema20'] > df_1h_aligned['ema50']) | (df_1h_aligned['close'] > df_1h_aligned['ema20'])
-        rsi_1h_ok = (df_1h_aligned['rsi'] >= 45) & (df_1h_aligned['rsi'] <= 68)
-        close_above_ema_15m = df_15m_aligned['close'] >= df_15m_aligned['ema20']
-        vol_spike_15m = df_15m_aligned['volume'] >= (1.5 * df_15m_aligned['vol_ma20'])
-        is_breakout = filters_pass & bullish_1h & rsi_1h_ok & close_above_ema_15m & vol_spike_15m
-        
-        rsi_oversold = (df_1h_aligned['rsi'] >= 20) & (df_1h_aligned['rsi'] <= 40)
-        price_drop = change_4h <= -2.0
-        is_green = df_15m_aligned['close'] > df_15m_aligned['open']
-        is_reversal = filters_pass & rsi_oversold & price_drop & is_green 
+        is_breakout = filters_pass & ((df_1h_aligned['ema20'] > df_1h_aligned['ema50']) | (df_1h_aligned['close'] > df_1h_aligned['ema20']))
+        is_reversal = filters_pass & (df_1h_aligned['rsi'].between(20, 40)) & (change_4h <= -2.0)
 
         valid_indices = df_5m_aligned[is_breakout | is_reversal].index
         start_dt = df_1m.index[0] + pd.Timedelta(minutes=500)
         final_valid_indices = [t for t in valid_indices if t >= start_dt]
         
-        print(f"     🎯 Found {len(final_valid_indices)} signals. Running 1-Min Simulations...", flush=True)
+        print(f"     🎯 Found {len(final_valid_indices)} signals. Running High-Fidelity Sim...", flush=True)
 
-        # --- Hydra Model Access ---
+        # --- Prepare Models ---
+        # 1. Hydra
         hydra_models = {}
         hydra_cols = []
         if self.proc.guardian_hydra and self.proc.guardian_hydra.initialized:
             hydra_models = self.proc.guardian_hydra.models
             hydra_cols = self.proc.guardian_hydra.feature_cols
-
-        # --- 3. The Main Loop (Every Minute Check) ---
-        for i, current_time in enumerate(final_valid_indices):
-            idx_1m = time_indices['1m'].searchsorted(current_time, side='right') - 1
-            idx_5m = time_indices['5m'].searchsorted(current_time, side='right') - 1
-            idx_15m = time_indices['15m'].searchsorted(current_time, side='right') - 1
-            idx_1h = time_indices['1h'].searchsorted(current_time, side='right') - 1
-            idx_4h = time_indices['4h'].searchsorted(current_time, side='right') - 1
-            idx_1d = time_indices['1d'].searchsorted(current_time, side='right') - 1
             
-            if idx_1m < 500 or idx_4h < 100: continue
+        # 2. Legacy V2/V3 (Direct Access)
+        legacy_v2_model = None
+        legacy_v3_model = None
+        v3_feat_names = []
+        if self.proc.guardian_legacy and self.proc.guardian_legacy.initialized:
+            legacy_v2_model = self.proc.guardian_legacy.model_v2
+            legacy_v3_model = self.proc.guardian_legacy.model_v3
+            v3_feat_names = self.proc.guardian_legacy.v3_feature_names
+
+        # --- 3. The Main Loop ---
+        for i, current_time in enumerate(final_valid_indices):
+            ts_val = int(current_time.timestamp() * 1000)
             
-            ohlcv_1h = numpy_frames['1h'][idx_1h-60+1 : idx_1h+1].tolist()
-            ohlcv_15m = numpy_frames['15m'][idx_15m-60+1 : idx_15m+1].tolist()
+            # Binary Search Indices
+            idx_1m = np.searchsorted(fast_1m['timestamp'], ts_val)
+            idx_5m = np.searchsorted(numpy_htf['5m']['timestamp'], ts_val)
+            idx_15m = np.searchsorted(numpy_htf['15m']['timestamp'], ts_val)
             
-            # Logic Classification (Simplified)
-            sig_type = 'BREAKOUT' if is_breakout[current_time] else 'REVERSAL'
-            l1_score = 100.0 if sig_type == 'REVERSAL' else 20.0
-
-            # 🔥 RISK PROFILING (Every 1 Minute)
-            max_hydra_crash = 0.0
-            max_hydra_giveback = 0.0
-            max_legacy_v2 = 0.0
-            max_legacy_v3 = 0.0
-            
-            hydra_crash_time = 0
-            legacy_panic_time = 0
+            if idx_1m < 500 or idx_1m >= len(fast_1m['close']) - 240: continue
             
             entry_price = fast_1m['close'][idx_1m]
             highest_price = entry_price 
             
-            # Scan next 4 hours (240 minutes), STEP = 1 minute (Live System Fidelity)
-            future_limit = 240
-            end_idx_1m = min(idx_1m + future_limit, len(fast_1m['close']) - 1)
+            max_hydra_crash = 0.0; max_hydra_giveback = 0.0; hydra_crash_time = 0
+            max_legacy_v2 = 0.0; max_legacy_v3 = 0.0; legacy_panic_time = 0
             
-            # Pre-lookup HTF RSIs to avoid heavy lookups every minute
-            rsi_5m_val = frames['5m']['rsi'].asof(current_time)
-            rsi_15m_val = frames['15m']['rsi'].asof(current_time)
+            end_idx_1m = min(idx_1m + 240, len(fast_1m['close']) - 1)
             
             # Loop minute by minute
-            for current_idx_1m in range(idx_1m + 1, end_idx_1m + 1):
-                curr_price = fast_1m['close'][current_idx_1m]
+            for c_idx in range(idx_1m + 1, end_idx_1m + 1):
+                curr_price = fast_1m['close'][c_idx]
                 if curr_price > highest_price: highest_price = curr_price
-                current_ts = int(fast_1m['timestamp'][current_idx_1m])
+                curr_ts = int(fast_1m['timestamp'][c_idx])
                 
-                # 🐉 A. Hydra Injection (Every Minute)
+                # --- A. HYDRA INJECTION ---
                 if hydra_models:
-                    atr_val = fast_1m['atr'][current_idx_1m]
+                    atr_val = fast_1m['atr'][c_idx]
                     sl_dist = 1.5 * atr_val if atr_val > 0 else entry_price * 0.015
-                    
                     pnl_r = (curr_price - entry_price) / sl_dist if sl_dist > 0 else 0
                     max_pnl_r = (highest_price - entry_price) / sl_dist if sl_dist > 0 else 0
                     
+                    # HTF Lookups (Constant or Nearest)
+                    # For speed, we use values at entry or nearest aligned.
+                    # Simple scaling: c_idx maps to c_idx // 5 for 5m approx
+                    c_5m = idx_5m + (c_idx - idx_1m) // 5
+                    c_15m = idx_15m + (c_idx - idx_1m) // 15
+                    if c_5m >= len(numpy_htf['5m']['rsi']): c_5m = len(numpy_htf['5m']['rsi']) - 1
+                    if c_15m >= len(numpy_htf['15m']['rsi']): c_15m = len(numpy_htf['15m']['rsi']) - 1
+
                     row_dict = {
-                        'rsi_1m': fast_1m['rsi'][current_idx_1m],
-                        'rsi_5m': rsi_5m_val,  
-                        'rsi_15m': rsi_15m_val,
-                        'bb_width': fast_1m['bb_width'][current_idx_1m],
-                        'rel_vol': fast_1m['rel_vol'][current_idx_1m],
+                        'rsi_1m': fast_1m['rsi'][c_idx],
+                        'rsi_5m': numpy_htf['5m']['rsi'][c_5m],  
+                        'rsi_15m': numpy_htf['15m']['rsi'][c_15m],
+                        'bb_width': fast_1m['bb_width'][c_idx],
+                        'rel_vol': fast_1m['rel_vol'][c_idx],
                         'dist_ema20_1h': 0.0, 
                         'atr_pct': atr_val / curr_price if curr_price > 0 else 0,
-                        'norm_pnl_r': pnl_r,
-                        'max_pnl_r': max_pnl_r,
-                        'dist_tp_atr': 0.0, 'dist_sl_atr': 0.0,
-                        'time_in_trade': (current_idx_1m - idx_1m),
+                        'norm_pnl_r': pnl_r, 'max_pnl_r': max_pnl_r,
+                        'time_in_trade': (c_idx - idx_1m),
                         'entry_type': 0.0, 'oracle_conf': 0.8, 'l2_score': 0.7, 'target_class': 3.0
                     }
-                    
-                    vec = [row_dict.get(c, 0.0) for c in hydra_cols]
-                    vec_np = np.array(vec).reshape(1, -1)
+                    vec = np.array([row_dict.get(c, 0.0) for c in hydra_cols]).reshape(1, -1)
                     
                     try:
-                        p_crash = hydra_models['crash'].predict_proba(vec_np)[0][1]
+                        p_crash = hydra_models['crash'].predict_proba(vec)[0][1]
                         if p_crash > max_hydra_crash:
                             max_hydra_crash = p_crash
-                            if p_crash > 0.6 and hydra_crash_time == 0: hydra_crash_time = current_ts
+                            if p_crash > 0.6 and hydra_crash_time == 0: hydra_crash_time = curr_ts
                     except: pass
-                    
                     try:
-                        p_give = hydra_models['giveback'].predict_proba(vec_np)[0][1]
+                        p_give = hydra_models['giveback'].predict_proba(vec)[0][1]
                         if p_give > max_hydra_giveback: max_hydra_giveback = p_give
                     except: pass
 
-                # 🕸️ B. Legacy Check (Every Minute)
-                if self.proc.guardian_legacy:
-                    # Update 5m index based on time (approximate but fast)
-                    curr_5m_idx = idx_5m + (current_idx_1m - idx_1m) // 5
-                    if curr_5m_idx >= len(numpy_frames['5m']): curr_5m_idx = len(numpy_frames['5m']) - 1
-                    
-                    f_1m = numpy_frames['1m'][current_idx_1m-60+1 : current_idx_1m+1].tolist()
-                    f_5m = numpy_frames['5m'][curr_5m_idx-30+1 : curr_5m_idx+1].tolist() 
-                    
-                    legacy_res = self.proc.guardian_legacy.analyze_position(
-                        f_1m, f_5m, ohlcv_15m, entry_price, volume_30m_usd=1000000
-                    )
-                    scores = legacy_res.get('scores', {})
-                    s_v2 = scores.get('v2', 0.0)
-                    s_v3 = scores.get('v3', 0.0)
-                    
-                    if s_v2 > max_legacy_v2: 
-                        max_legacy_v2 = s_v2
-                        if s_v2 > 0.8 and legacy_panic_time == 0: legacy_panic_time = current_ts
+                # --- B. LEGACY INJECTION (V2/V3) ---
+                if legacy_v2_model or legacy_v3_model:
+                    # Update HTF indices
+                    c_5m = idx_5m + (c_idx - idx_1m) // 5
+                    c_15m = idx_15m + (c_idx - idx_1m) // 15
+                    if c_5m >= len(numpy_htf['5m']['close']): c_5m = len(numpy_htf['5m']['close']) - 1
+                    if c_15m >= len(numpy_htf['15m']['close']): c_15m = len(numpy_htf['15m']['close']) - 1
+
+                    # V2 Construction
+                    if legacy_v2_model:
+                        # V2 needs: [1m_feats, 5m_feats, 15m_feats, LAGS...]
+                        # 1m Feats: log_ret, rsi, fib_pos, volatility
+                        f1 = [fast_1m['log_ret'][c_idx], fast_1m['rsi'][c_idx]/100.0, fast_1m['fib_pos'][c_idx], fast_1m['volatility'][c_idx]]
+                        # 5m Feats: log_ret, rsi, fib_pos, trend_slope
+                        f5 = [numpy_htf['5m']['log_ret'][c_5m], numpy_htf['5m']['rsi'][c_5m]/100.0, numpy_htf['5m']['fib_pos'][c_5m], numpy_htf['5m']['trend_slope'][c_5m]]
+                        # 15m Feats: log_ret, rsi, dist_fib618, trend_slope
+                        f15 = [numpy_htf['15m']['log_ret'][c_15m], numpy_htf['15m']['rsi'][c_15m]/100.0, numpy_htf['15m']['dist_fib618'][c_15m], numpy_htf['15m']['trend_slope'][c_15m]]
                         
-                    if s_v3 > max_legacy_v3: max_legacy_v3 = s_v3
+                        vec_v2 = f1 + f5 + f15
+                        
+                        # Add Lags (1, 2, 3, 5, 10, 20)
+                        lags = [1, 2, 3, 5, 10, 20]
+                        for lag in lags:
+                            l_idx = c_idx - lag
+                            if l_idx >= 0:
+                                lag_row = [fast_1m['log_ret'][l_idx], fast_1m['rsi'][l_idx]/100.0, fast_1m['fib_pos'][l_idx], fast_1m['volatility'][l_idx]]
+                                vec_v2.extend(lag_row)
+                            else:
+                                vec_v2.extend([0.0, 0.5, 0.5, 0.0])
+                        
+                        try:
+                            # XGB Predict
+                            dm = xgb.DMatrix(np.array(vec_v2).reshape(1, -1))
+                            pred = legacy_v2_model.predict(dm)
+                            p_v2 = float(pred[0][2]) if len(pred.shape)>1 else float(pred[0])
+                            
+                            if p_v2 > max_legacy_v2:
+                                max_legacy_v2 = p_v2
+                                if p_v2 > 0.8 and legacy_panic_time == 0: legacy_panic_time = curr_ts
+                        except: pass
+
+                    # V3 Construction (DataFrame)
+                    if legacy_v3_model and v3_feat_names:
+                        # V3 uses a DataFrame with specific column names
+                        # We reconstruct the dict
+                        # Feats: rsi, dist_ema50, dist_ema200, log_ret (for 1m, 5m, 15m)
+                        v3_dict = {}
+                        # 1m
+                        v3_dict['rsi'] = fast_1m['rsi'][c_idx]
+                        v3_dict['dist_ema50'] = fast_1m['dist_ema50'][c_idx]
+                        v3_dict['dist_ema200'] = fast_1m['dist_ema200'][c_idx]
+                        v3_dict['log_ret'] = fast_1m['log_ret'][c_idx]
+                        # 5m
+                        v3_dict['rsi_5m'] = numpy_htf['5m']['rsi'][c_5m]
+                        v3_dict['dist_ema50_5m'] = numpy_htf['5m']['dist_ema50'][c_5m]
+                        v3_dict['dist_ema200_5m'] = numpy_htf['5m']['dist_ema200'][c_5m]
+                        v3_dict['log_ret_5m'] = numpy_htf['5m']['log_ret'][c_5m]
+                        # 15m
+                        v3_dict['rsi_15m'] = numpy_htf['15m']['rsi'][c_15m]
+                        v3_dict['dist_ema50_15m'] = numpy_htf['15m']['dist_ema50'][c_15m]
+                        v3_dict['dist_ema200_15m'] = numpy_htf['15m']['dist_ema200'][c_15m]
+                        v3_dict['log_ret_15m'] = numpy_htf['15m']['log_ret'][c_15m]
+                        
+                        # Build ordered DF
+                        try:
+                            df_v3 = pd.DataFrame(columns=v3_feat_names)
+                            # Fill efficiently
+                            vals = [v3_dict.get(n, 0.0) for n in v3_feat_names]
+                            df_v3.loc[0] = vals
+                            df_v3 = df_v3.astype(float)
+                            
+                            dm_v3 = xgb.DMatrix(df_v3)
+                            pred_v3 = legacy_v3_model.predict(dm_v3)
+                            p_v3 = float(pred_v3[0])
+                            
+                            if p_v3 > max_legacy_v3: max_legacy_v3 = p_v3
+                        except: pass
 
             ts_aligned = int(current_time.timestamp() // 60) * 60 * 1000
+            # Logic Classification
+            sig_type = 'BREAKOUT' if is_breakout[current_time] else 'REVERSAL'
+            l1_score = 100.0 if sig_type == 'REVERSAL' else 20.0
+            
             ai_results.append({
                 'timestamp': ts_aligned, 'symbol': sym, 'close': entry_price,
-                'real_titan': 0.5, 
-                'signal_type': sig_type, 'l1_score': l1_score,
+                'real_titan': 0.5, 'signal_type': sig_type, 'l1_score': l1_score,
                 'risk_hydra_crash': max_hydra_crash,
                 'time_hydra_crash': hydra_crash_time,
                 'risk_legacy_v2': max_legacy_v2,
@@ -619,7 +703,6 @@ async def run_strategic_optimization_task():
     await dm.initialize()
     await proc.initialize()
     
-    # ✅ Activate Silent Mode for Hydra during Backtest
     if proc.guardian_hydra:
         proc.guardian_hydra.set_silent_mode(True)
         print("   🔇 [Hydra] Silent Mode: ACTIVATED for Backtest.")
@@ -640,7 +723,6 @@ async def run_strategic_optimization_task():
             best_config, best_stats = await optimizer.run_optimization(target_regime=target)
             if best_config and best_stats:
                 hub.submit_challenger(target, best_config, best_stats)
-        
         await hub._save_state_to_r2()
         hub._inject_current_parameters()
         print(f"✅ [System] ALL DNA Updated & Saved Successfully.")