Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V159.0 - GEM-Architect: Hyper-Speed Jump Logic)
+# 🧪 backtest_engine.py (V160.0 - GEM-Architect: Gov + L1 Update)
 # ============================================================
 
 import asyncio
@@ -13,7 +13,7 @@ import glob
 import gc 
 import sys
 import traceback
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 from typing import Dict, Any, List
 
 # محاولة استيراد المكتبات
@@ -60,7 +60,7 @@ class HeavyDutyBacktester:
         self.proc = processor
         
         # 🎛️ الكثافة (Density): عدد الخطوات في النطاق
-        self.GRID_DENSITY = 3 # 3 is enough for quick checks, 5 for deep dive
+        self.GRID_DENSITY = 3 
         
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
@@ -68,32 +68,31 @@ class HeavyDutyBacktester:
         
         # 🎛️ CONTROL PANEL - DYNAMIC RANGES
         self.GRID_RANGES = {
-            'TITAN':  np.linspace(0.10, 0.50, self.GRID_DENSITY),
-            'ORACLE': np.linspace(0.40, 0.80, self.GRID_DENSITY),
+            'TITAN':  np.linspace(0.20, 0.50, self.GRID_DENSITY),
+            'ORACLE': np.linspace(0.50, 0.80, self.GRID_DENSITY),
             'SNIPER': np.linspace(0.30, 0.70, self.GRID_DENSITY),
-            'PATTERN': np.linspace(0.10, 0.50, self.GRID_DENSITY),
-            'L1_SCORE': [10.0],
-            # Guardians
-            'HYDRA_CRASH':    np.linspace(0.60, 0.85, self.GRID_DENSITY), 
-            'HYDRA_GIVEBACK': np.linspace(0.60, 0.85, self.GRID_DENSITY),       
-            'LEGACY_V2':      np.linspace(0.85, 0.98, self.GRID_DENSITY),            
+            'GOV_SCORE': np.linspace(50.0, 80.0, self.GRID_DENSITY), # ✅ Added Governance Threshold
         }
         
         self.TARGET_COINS = [
-    'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT', 'LINK/USDT',
-    'TON/USDT', 'INJ/USDT', 'APT/USDT', 'OP/USDT', 'ARB/USDT', 'SUI/USDT',
-    'SEI/USDT', 'MINA/USDT', 'MATIC/USDT', 'NEAR/USDT', 'RUNE/USDT', 'API3/USDT',
-    'FLOKI/USDT', 'BABYDOGE/USDT', 'SHIB/USDT', 'TRX/USDT', 'DOT/USDT', 'UNI/USDT',
-    'ONDO/USDT', 'SNX/USDT', 'HBAR/USDT', 'XLM/USDT', 'AGIX/USDT', 'IMX/USDT',
-    'LRC/USDT', 'KCS/USDT', 'ICP/USDT', 'SAND/USDT', 'AXS/USDT', 'APE/USDT',
-    'GMT/USDT', 'CHZ/USDT', 'CFX/USDT', 'LDO/USDT', 'FET/USDT', 'RPL/USDT',
-    'MNT/USDT', 'RAY/USDT', 'CAKE/USDT', 'SRM/USDT', 'PENDLE/USDT', 'ATOM/USDT'
-]
-        self.force_start_date = None 
-        self.force_end_date = None   
+            'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT', 'LINK/USDT',
+            'TON/USDT', 'INJ/USDT', 'APT/USDT', 'OP/USDT', 'ARB/USDT', 'SUI/USDT',
+            'SEI/USDT', 'MINA/USDT', 'MATIC/USDT', 'NEAR/USDT', 'RUNE/USDT', 'API3/USDT',
+            'FLOKI/USDT', 'BABYDOGE/USDT', 'SHIB/USDT', 'TRX/USDT', 'DOT/USDT', 'UNI/USDT',
+            'ONDO/USDT', 'SNX/USDT', 'HBAR/USDT', 'XLM/USDT', 'AGIX/USDT', 'IMX/USDT',
+            'LRC/USDT', 'KCS/USDT', 'ICP/USDT', 'SAND/USDT', 'AXS/USDT', 'APE/USDT',
+            'GMT/USDT', 'CHZ/USDT', 'CFX/USDT', 'LDO/USDT', 'FET/USDT', 'RPL/USDT',
+            'MNT/USDT', 'RAY/USDT', 'CAKE/USDT', 'SRM/USDT', 'PENDLE/USDT', 'ATOM/USDT'
+        ]
+        
+        # ✅ DATE SETTINGS
+        self.USE_FIXED_DATES = False  # Set to True to use force_start_date
+        self.LOOKBACK_DAYS = 30       # Default lookback
+        self.force_start_date = "2024-01-01" 
+        self.force_end_date = "2024-02-01"   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V159.0] Hyper-Speed Jump Engine (CPU Optimized).")
+        print(f"🧪 [Backtest V160.0] Hyper-Speed Jump Engine (Gov + L1 Update).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -132,14 +131,14 @@ class HeavyDutyBacktester:
         return df.values.tolist()
 
     # ----------------------------------------------------------------------
-    # 🏎️ VECTORIZED INDICATORS
+    # 🏎️ VECTORIZED INDICATORS (Enhanced for L1 & Gov)
     # ----------------------------------------------------------------------
     def _calculate_indicators_vectorized(self, df, timeframe='1m'):
         if df.empty: return df
         cols = ['close', 'high', 'low', 'volume', 'open']
         for c in cols: df[c] = df[c].astype(np.float64)
         
-        # EMAs
+        # Basic EMAs (Required for L1 & Gov)
         df['ema9'] = df['close'].ewm(span=9, adjust=False).mean()
         df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
         df['ema21'] = df['close'].ewm(span=21, adjust=False).mean()
@@ -150,12 +149,20 @@ class HeavyDutyBacktester:
             df['RSI'] = ta.rsi(df['close'], length=14).fillna(50)
             df['ATR'] = ta.atr(df['high'], df['low'], df['close'], length=14).fillna(0)
             bb = ta.bbands(df['close'], length=20, std=2.0)
-            df['bb_width'] = bb.iloc[:, 3].fillna(0) if bb is not None else 0.0
+            if bb is not None:
+                df['lower_bb'] = bb.iloc[:, 0].fillna(0)
+                df['upper_bb'] = bb.iloc[:, 2].fillna(0)
+                df['bb_width'] = bb.iloc[:, 3].fillna(0) 
+            else:
+                df['lower_bb'] = 0; df['upper_bb'] = 0; df['bb_width'] = 0
+
             macd = ta.macd(df['close'])
             if macd is not None:
                 df['MACD'] = macd.iloc[:, 0].fillna(0)
+                df['MACD_s'] = macd.iloc[:, 2].fillna(0) # Signal line
                 df['MACD_h'] = macd.iloc[:, 1].fillna(0)
-            else: df['MACD'] = 0; df['MACD_h'] = 0
+            else: df['MACD'] = 0; df['MACD_h'] = 0; df['MACD_s'] = 0
+            
             df['ADX'] = ta.adx(df['high'], df['low'], df['close'], length=14).iloc[:, 0].fillna(0)
             df['CCI'] = ta.cci(df['high'], df['low'], df['close'], length=20).fillna(0)
             df['MFI'] = ta.mfi(df['high'], df['low'], df['close'], df['volume'], length=14).fillna(50)
@@ -164,6 +171,11 @@ class HeavyDutyBacktester:
             df['vwap'] = vwap.fillna(df['close']) if vwap is not None else df['close']
 
         c = df['close'].values
+        # Distances for L1 Logic
+        df['dist_ema50'] = (df['ema50'] - c) / df['ema50'] # Positive if price below ema50
+        df['dist_upper'] = (df['upper_bb'] - c) / c
+        
+        # Features for models
         df['EMA_9_dist'] = (c / df['ema9'].values) - 1
         df['EMA_21_dist'] = (c / df['ema21'].values) - 1
         df['EMA_50_dist'] = (c / df['ema50'].values) - 1
@@ -177,47 +189,9 @@ class HeavyDutyBacktester:
         df['rel_vol'] = df['volume'] / (df['volume'].rolling(50).mean() + 1e-9)
         df['log_ret'] = np.concatenate([[0], np.diff(np.log(c + 1e-9))])
         
-        roll_min = df['low'].rolling(50).min(); roll_max = df['high'].rolling(50).max()
-        df['fib_pos'] = (c - roll_min) / (roll_max - roll_min + 1e-9)
-        df['volatility'] = df['ATR_pct']
-        
-        e20 = df['ema20'].values
-        e20_s = np.roll(e20, 5); e20_s[:5] = e20[0]
-        df['trend_slope'] = (e20 - e20_s) / (e20_s + 1e-9)
-        
-        fib618 = roll_max - ((roll_max - roll_min) * 0.382)
-        df['dist_fib618'] = (c - fib618) / (c + 1e-9)
-        df['dist_ema50'] = df['EMA_50_dist']
-        df['dist_ema200'] = df['EMA_200_dist']
-
         if timeframe == '1m':
             df['return_1m'] = df['log_ret']
-            df['rsi_14'] = df['RSI']
-            e9 = df['ema9'].values; e9_s = np.roll(e9, 1); e9_s[0] = e9[0]
-            df['ema_9_slope'] = (e9 - e9_s) / (e9_s + 1e-9)
-            df['ema_21_dist'] = df['EMA_21_dist']
-            
             df['atr_z'] = _z_roll_np(df['ATR'].values, 100)
-            df['vol_zscore_50'] = _z_roll_np(df['volume'].values, 50)
-            rng = df['high'].values - df['low'].values
-            df['candle_range'] = _z_roll_np(rng, 500)
-            df['close_pos_in_range'] = (c - df['low'].values) / (rng + 1e-9)
-            
-            dollar_vol = c * df['volume'].values
-            amihud = np.abs(df['log_ret']) / (dollar_vol + 1e-9)
-            df['amihud'] = _z_roll_np(amihud, 500)
-            
-            sign = np.sign(np.diff(c, prepend=c[0]))
-            signed_vol = sign * df['volume'].values
-            ofi = pd.Series(signed_vol).rolling(30).sum().fillna(0).values
-            df['ofi'] = _z_roll_np(ofi, 500)
-            df['vwap_dev'] = _z_roll_np(c - df['vwap'].values, 500)
-            
-            for lag in [1, 2, 3, 5, 10, 20]:
-                df[f'log_ret_lag_{lag}'] = df['log_ret'].shift(lag).fillna(0)
-                df[f'rsi_lag_{lag}'] = df['RSI'].shift(lag).fillna(50)/100.0
-                df[f'fib_pos_lag_{lag}'] = df['fib_pos'].shift(lag).fillna(0.5)
-                df[f'volatility_lag_{lag}'] = df['volatility'].shift(lag).fillna(0)
 
         df.fillna(0, inplace=True)
         return df
@@ -260,19 +234,87 @@ class HeavyDutyBacktester:
             if tf not in numpy_htf or 'timestamp' not in numpy_htf[tf]: return np.zeros(len(arr_ts_1m), dtype=int)
             return np.clip(np.searchsorted(numpy_htf[tf]['timestamp'], arr_ts_1m), 0, len(numpy_htf[tf]['timestamp']) - 1)
         
-        map_5m = get_map('5m'); map_15m = get_map('15m'); map_1h = get_map('1h'); map_4h = get_map('4h')
+        map_1h = get_map('1h'); map_15m = get_map('15m')
+
+        # ============================================================
+        # ✅ 2. NEW L1 LOGIC (Vectorized Implementation of DataManager)
+        # ============================================================
+        # Logic is applied on 1H frame, mapped to 1m
+        h1_rsi = numpy_htf['1h']['RSI'][map_1h]
+        h1_close = numpy_htf['1h']['close'][map_1h]
+        h1_ema20 = numpy_htf['1h']['ema20'][map_1h]
+        h1_ema50 = numpy_htf['1h']['ema50'][map_1h]
+        h1_ema200 = numpy_htf['1h']['ema200'][map_1h]
+        h1_lower_bb = numpy_htf['1h']['lower_bb'][map_1h]
+        h1_upper_bb = numpy_htf['1h']['upper_bb'][map_1h]
+        h1_bb_width = numpy_htf['1h']['bb_width'][map_1h]
+        
+        # TYPE 1: SAFE_BOTTOM
+        # (rsi < 45) & (close <= lower_bb * 1.05) & (dist_from_ema50 > 0.015)
+        dist_from_ema50 = (h1_ema50 - h1_close) / h1_ema50
+        mask_safe_bottom = (h1_rsi < 45) & (h1_close <= h1_lower_bb * 1.05) & (dist_from_ema50 > 0.015)
+        
+        # TYPE 2: ACCUMULATION_SQUEEZE
+        # (45 <= rsi <= 60) & (bb_width < 0.12) & (close > ema20 * 0.995)
+        mask_acc_squeeze = (h1_rsi >= 45) & (h1_rsi <= 60) & (h1_bb_width < 0.12) & (h1_close > h1_ema20 * 0.995)
+        
+        # TYPE 3: MOMENTUM_LAUNCH
+        # (60 < rsi < 80) & (close > ema50) & (close > ema200) & (dist_to_upper < 0.08)
+        dist_to_upper = (h1_upper_bb - h1_close) / h1_close
+        mask_mom_launch = (h1_rsi > 60) & (h1_rsi < 80) & (h1_close > h1_ema50) & (h1_close > h1_ema200) & (dist_to_upper < 0.08)
 
+        # Combine Masks (Any Valid L1)
+        valid_l1_mask = mask_safe_bottom | mask_acc_squeeze | mask_mom_launch
+        
+        # ============================================================
+        # ✅ 4. GOVERNANCE PROXY (Vectorized Scoring)
+        # ============================================================
+        # Mimics governance_engine.py logic (Simplified for speed)
+        gov_points = np.zeros(len(arr_ts_1m), dtype=np.float32)
+        
+        # Trend (30%)
+        # EMA9 > EMA21 on 15m
+        m15_ema9 = numpy_htf['15m']['ema9'][map_15m]
+        m15_ema21 = numpy_htf['15m']['ema21'][map_15m]
+        m15_ema50 = numpy_htf['15m']['ema50'][map_15m]
+        m15_close = numpy_htf['15m']['close'][map_15m]
+        
+        gov_points += np.where(m15_ema9 > m15_ema21, 15.0, 0.0)
+        gov_points += np.where(m15_ema21 > m15_ema50, 10.0, 0.0)
+        gov_points += np.where(m15_close > numpy_htf['15m']['ema200'][map_15m], 5.0, 0.0)
+        
+        # Momentum (30%)
+        m15_rsi = numpy_htf['15m']['RSI'][map_15m]
+        m15_macd = numpy_htf['15m']['MACD'][map_15m]
+        m15_macd_s = numpy_htf['15m']['MACD_s'][map_15m]
+        
+        gov_points += np.where((m15_rsi > 45) & (m15_rsi < 70), 15.0, 0.0)
+        gov_points += np.where(m15_macd > m15_macd_s, 15.0, 0.0)
+        
+        # Volatility & Volume (20%)
+        m15_bbw = numpy_htf['15m']['bb_width'][map_15m]
+        gov_points += np.where((m15_bbw > 0.02) & (m15_bbw < 0.15), 10.0, 0.0) # Not too tight, not too wide
+        gov_points += np.where(numpy_htf['15m']['rel_vol'][map_15m] > 1.0, 10.0, 0.0)
+        
+        # Structure (20%)
+        # Price above VWAP
+        gov_points += np.where(m15_close > numpy_htf['15m']['vwap'][map_15m], 20.0, 0.0)
+        
+        # Final Governance Score (0-100)
+        gov_scores_final = np.clip(gov_points, 0, 100)
+        
+        # ============================================================
+        # 🤖 AI MODELS PREDICTIONS
+        # ============================================================
         titan_model = getattr(self.proc.titan, 'model', None)
         oracle_dir = 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', [])
-        hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
-        legacy_v2 = getattr(self.proc.guardian_legacy, 'model_v2', None)
-        
-        # --- BATCH PREDICTIONS ---
+
         global_titan_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
         if titan_model:
+            # (Titan prediction logic kept same as original for stability)
             titan_cols = [
                 '5m_open', '5m_high', '5m_low', '5m_close', '5m_volume', '5m_RSI', '5m_MACD', '5m_MACD_h', 
                 '5m_CCI', '5m_ADX', '5m_EMA_9_dist', '5m_EMA_21_dist', '5m_EMA_50_dist', '5m_EMA_200_dist', 
@@ -284,6 +326,12 @@ class HeavyDutyBacktester:
                 '1d_RSI', '1d_EMA_200_dist', '1d_Trend_Strong'
             ]
             try:
+                # Need map_5m and map_4h here strictly for Titan
+                def get_map_local(tf):
+                    if tf not in numpy_htf: return np.zeros(len(arr_ts_1m), dtype=int)
+                    return np.clip(np.searchsorted(numpy_htf[tf]['timestamp'], arr_ts_1m), 0, len(numpy_htf[tf]['timestamp']) - 1)
+                map_5m = get_map_local('5m'); map_4h = get_map_local('4h')
+                
                 t_vecs = []
                 for col in titan_cols:
                     parts = col.split('_', 1); tf = parts[0]; feat = parts[1]
@@ -300,6 +348,8 @@ class HeavyDutyBacktester:
         global_oracle_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
         if oracle_dir:
             try:
+                # Need map_4h for Oracle too
+                map_4h = locals().get('map_4h', get_map('4h'))
                 o_vecs = []
                 for col in oracle_cols:
                     if col.startswith('1h_'): o_vecs.append(numpy_htf['1h'].get(col[3:], np.zeros(len(arr_ts_1m)))[map_1h])
@@ -328,47 +378,13 @@ class HeavyDutyBacktester:
                 global_sniper_scores = _revive_score_distribution(np.mean(preds, axis=0))
             except: pass
 
-        global_v2_scores = np.zeros(len(arr_ts_1m), dtype=np.float32)
-        if legacy_v2:
-            try:
-                l_log = fast_1m['log_ret']; l_rsi = fast_1m['RSI'] / 100.0; l_fib = fast_1m['fib_pos']; l_vol = fast_1m['volatility']
-                l5_log = numpy_htf['5m']['log_ret'][map_5m]; l5_rsi = numpy_htf['5m']['RSI'][map_5m] / 100.0; l5_fib = numpy_htf['5m']['fib_pos'][map_5m]; l5_trd = numpy_htf['5m']['trend_slope'][map_5m]
-                l15_log = numpy_htf['15m']['log_ret'][map_15m]; l15_rsi = numpy_htf['15m']['RSI'][map_15m] / 100.0; l15_fib618 = numpy_htf['15m']['dist_fib618'][map_15m]; l15_trd = numpy_htf['15m']['trend_slope'][map_15m]
-                lags = []
-                for lag in [1, 2, 3, 5, 10, 20]:
-                    lags.extend([fast_1m[f'log_ret_lag_{lag}'], fast_1m[f'rsi_lag_{lag}'], fast_1m[f'fib_pos_lag_{lag}'], fast_1m[f'volatility_lag_{lag}']])
-                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, *lags])
-                preds = legacy_v2.predict(xgb.DMatrix(X_V2))
-                global_v2_scores = preds[:, 2] if len(preds.shape) > 1 else preds
-                global_v2_scores = global_v2_scores.flatten() 
-            except: pass
-
-        global_hydra_crash = np.zeros(len(arr_ts_1m), dtype=np.float32)
-        global_hydra_give = np.zeros(len(arr_ts_1m), dtype=np.float32)
-        if hydra_models:
-            try:
-                zeros = np.zeros(len(arr_ts_1m))
-                h_static = np.column_stack([
-                    fast_1m['RSI'], numpy_htf['5m']['RSI'][map_5m], numpy_htf['15m']['RSI'][map_15m],
-                    fast_1m['bb_width'], fast_1m['rel_vol'], fast_1m['atr'], fast_1m['close']
-                ])
-                X_H = np.column_stack([
-                    h_static[:,0], h_static[:,1], h_static[:,2], h_static[:,3], h_static[:,4],
-                    zeros, fast_1m['ATR_pct'], zeros, zeros, zeros, zeros, zeros, zeros,
-                    global_oracle_scores, np.full(len(arr_ts_1m), 0.7), np.full(len(arr_ts_1m), 3.0)
-                ])
-                
-                probs_c = hydra_models['crash'].predict_proba(X_H)[:, 1]
-                global_hydra_crash = probs_c.astype(np.float32)
-                
-                probs_g = hydra_models['giveback'].predict_proba(X_H)[:, 1]
-                global_hydra_give = probs_g.astype(np.float32)
-            except: pass
-
-        # Filter
-        rsi_1h = numpy_htf['1h'].get('RSI', np.zeros(len(arr_ts_1m)))[map_1h]
-        # Keep candles where at least minimal promise exists (reduces size)
-        is_candidate_mask = (rsi_1h <= 70) & (global_titan_scores > 0.3) & (global_oracle_scores > 0.3)
+        # ✅ 3. DISABLE GUARDIANS IN BACKTEST (Requested Update)
+        # We skip Hydra and Legacy V2 predictions to save time and because user requested.
+        
+        # Filter (Refined with new L1)
+        # Keep candles where L1 is Valid OR Scores are very high
+        is_candidate_mask = valid_l1_mask | ((global_titan_scores > 0.6) & (global_oracle_scores > 0.6))
+        
         candidate_indices = np.where(is_candidate_mask)[0]
         end_limit = len(arr_ts_1m) - 60
         candidate_indices = candidate_indices[candidate_indices < end_limit]
@@ -383,12 +399,8 @@ class HeavyDutyBacktester:
             'real_titan': global_titan_scores[candidate_indices],
             'oracle_conf': global_oracle_scores[candidate_indices],
             'sniper_score': global_sniper_scores[candidate_indices],
-            'pattern_score': np.full(len(candidate_indices), 0.5), 
-            'risk_hydra_crash': global_hydra_crash[candidate_indices],
-            'risk_hydra_giveback': global_hydra_give[candidate_indices],
-            'risk_legacy_v2': global_v2_scores[candidate_indices],
-            'time_hydra_crash': np.zeros(len(candidate_indices), dtype=int),
-            'l1_score': 50.0
+            'gov_score': gov_scores_final[candidate_indices], # ✅ New Gov Score
+            'l1_valid': valid_l1_mask[candidate_indices].astype(int) # ✅ New L1 Flag
         })
 
         dt = time.time() - t0
@@ -398,18 +410,28 @@ class HeavyDutyBacktester:
         gc.collect()
 
     async def generate_truth_data(self):
-        if self.force_start_date:
-            dt_s = datetime.strptime(self.force_start_date, "%Y-%m-%d").replace(tzinfo=timezone.utc)
-            dt_e = datetime.strptime(self.force_end_date, "%Y-%m-%d").replace(tzinfo=timezone.utc)
-            ms_s = int(dt_s.timestamp()*1000); ms_e = int(dt_e.timestamp()*1000)
-            print(f"\n🚜 [Phase 1] Processing Era: {self.force_start_date} -> {self.force_end_date}")
-            for sym in self.TARGET_COINS:
-                c = await self._fetch_all_data_fast(sym, ms_s, ms_e)
-                if c: await self._process_data_in_memory(sym, c, ms_s, ms_e)
+        # ✅ DATE LOGIC: Dynamic or Fixed
+        if self.USE_FIXED_DATES:
+            start_date_str = self.force_start_date
+            end_date_str = self.force_end_date
+            print(f"\n🚜 [Phase 1] Using FIXED dates: {start_date_str} -> {end_date_str}")
+        else:
+            now = datetime.now(timezone.utc)
+            end_date_str = now.strftime("%Y-%m-%d")
+            start_date_str = (now - timedelta(days=self.LOOKBACK_DAYS)).strftime("%Y-%m-%d")
+            print(f"\n🚜 [Phase 1] Using DYNAMIC dates (Last {self.LOOKBACK_DAYS} days): {start_date_str} -> {end_date_str}")
+
+        dt_s = datetime.strptime(start_date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+        dt_e = datetime.strptime(end_date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+        ms_s = int(dt_s.timestamp()*1000); ms_e = int(dt_e.timestamp()*1000)
+        
+        for sym in self.TARGET_COINS:
+            c = await self._fetch_all_data_fast(sym, ms_s, ms_e)
+            if c: await self._process_data_in_memory(sym, c, ms_s, ms_e)
 
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
-        """🚀 HYPER-SPEED JUMP LOGIC (NO LOOPING OVER IDLE CANDLES)"""
+        """🚀 HYPER-SPEED JUMP LOGIC (NO GUARDIANS, ADDED GOV)"""
         print(f"     ⏳ [System] Loading {len(scores_files)} datasets...", flush=True)
         data = []
         for f in scores_files:
@@ -418,7 +440,7 @@ class HeavyDutyBacktester:
         if not data: return []
         df = pd.concat(data).sort_values('timestamp').reset_index(drop=True)
         
-        # Pre-load arrays for max speed
+        # Pre-load arrays
         ts = df['timestamp'].values
         close = df['close'].values.astype(float)
         sym = df['symbol'].values
@@ -427,74 +449,47 @@ class HeavyDutyBacktester:
         oracle = df['oracle_conf'].values
         sniper = df['sniper_score'].values
         titan = df['real_titan'].values
-        pattern = df['pattern_score'].values
-        l1 = df['l1_score'].values
-        hydra = df['risk_hydra_crash'].values
-        hydra_give = df['risk_hydra_giveback'].values
-        legacy = df['risk_legacy_v2'].values
+        gov_s = df['gov_score'].values # ✅ Loaded Gov Score
+        l1_v = df['l1_valid'].values   # ✅ Loaded L1 Valid Flag
         
         N = len(ts)
         print(f"     🚀 [System] Testing {len(combinations_batch)} configs on {N} candidates...", flush=True)
         
         res = []
         for cfg in combinations_batch:
-            # 1. Vectorized Entry Mask (The Speed Secret)
-            # Instead of checking every candle, we calculate ALL valid entries at once
-            entry_mask = (l1 >= cfg['L1_SCORE']) & \
+            # ✅ Updated Entry Mask: Requires Valid L1 & Gov Score
+            entry_mask = (l1_v == 1) & \
+                         (gov_s >= cfg['GOV_SCORE']) & \
                          (oracle >= cfg['ORACLE']) & \
                          (sniper >= cfg['SNIPER']) & \
-                         (titan >= cfg['TITAN']) & \
-                         (pattern >= cfg.get('PATTERN', 0.10))
+                         (titan >= cfg['TITAN'])
             
-            # Get only the indices where entry is possible
             valid_entry_indices = np.where(entry_mask)[0]
             
-            # Extract thresholds locally to avoid dictionary lookups in inner loop
-            h_crash_thresh = cfg['HYDRA_CRASH']
-            h_give_thresh = cfg['HYDRA_GIVEBACK']
-            leg_thresh = cfg['LEGACY_V2']
-            
             # Simulation State
             pos = {} # sym_id -> (entry_price, size)
             bal = float(initial_capital)
             alloc = 0.0
             log = []
             
-            # Iterate ONLY on relevant indices (Jump!)
-            # But we must respect time. So we iterate valid indices, 
-            # and check exits for OPEN positions at that time step? 
-            # Problem: If we jump, we miss exits between entries.
-            # Fix: We must iterate all rows for exits, but we can skip logic if no pos.
-            # OR: Since df is filtered candidates only, gaps exist.
-            # We assume candidates are frequent enough or we only check exits on candidate candles.
-            # *Refinement*: The dataframe `df` only contains ~30k candidates out of 100k candles.
-            # Exiting only on candidate candles is an approximation, but acceptable for optimization speed.
-            
             for i in range(N):
                 s = sym_id[i]; p = float(close[i])
                 
-                # A. Check Exits (If holding this symbol)
+                # A. Check Exits (Standard TP/SL Logic only)
                 if s in pos:
                     entry_p, size_val = pos[s]
                     pnl = (p - entry_p) / entry_p
                     
-                    # Guardian Logic (Local vars)
-                    is_guard = (hydra[i] > h_crash_thresh) or \
-                               (hydra_give[i] > h_give_thresh) or \
-                               (legacy[i] > leg_thresh)
-                    
-                    # VETO (Price Confirmation)
-                    confirmed = is_guard and (pnl < -0.0015)
-                    
-                    if confirmed or (pnl > 0.04) or (pnl < -0.02):
+                    # Exit Rules (Standard Backtest)
+                    if (pnl > 0.04) or (pnl < -0.02):
                         realized = pnl - (fees_pct * 2)
                         bal += size_val * (1.0 + realized)
                         alloc -= size_val
                         del pos[s]
                         log.append({'pnl': realized})
-                        continue # Can't buy same candle we sold
+                        continue 
 
-                # B. Check Entries (Only if mask is True)
+                # B. Check Entries
                 if entry_mask[i] and len(pos) < max_slots:
                     if s not in pos and bal >= 5.0:
                         size = min(10.0, bal * 0.98)
@@ -515,7 +510,6 @@ class HeavyDutyBacktester:
             gross_l = abs(sum([x['pnl'] for x in losing]))
             profit_factor = (gross_p / gross_l) if gross_l > 0 else 99.9
             
-            # Simple streaks
             max_win_s = 0; max_loss_s = 0; curr_w = 0; curr_l = 0
             for t in log:
                 if t['pnl'] > 0: curr_w +=1; curr_l = 0; max_win_s = max(max_win_s, curr_w)
@@ -526,8 +520,7 @@ class HeavyDutyBacktester:
                 'total_trades': tot, 'win_rate': win_rate, 'profit_factor': profit_factor,
                 'win_count': len(winning), 'loss_count': len(losing),
                 'avg_win': avg_win, 'avg_loss': avg_loss,
-                'max_win_streak': max_win_s, 'max_loss_streak': max_loss_s,
-                'consensus_agreement_rate': 0.0, 'high_consensus_win_rate': 0.0
+                'max_win_streak': max_win_s, 'max_loss_streak': max_loss_s
             })
         return res
 
@@ -547,12 +540,13 @@ class HeavyDutyBacktester:
         
         mapped_config = {
             'w_titan': best['config']['TITAN'],
-            'w_struct': best['config']['PATTERN'],
-            'thresh': best['config']['L1_SCORE'],
+            'w_struct': 0.3, # Fixed as removed from grid
+            'thresh': 50.0,  # Fixed L1 Logic
             'oracle_thresh': best['config']['ORACLE'],
             'sniper_thresh': best['config']['SNIPER'],
-            'hydra_thresh': best['config']['HYDRA_CRASH'],
-            'legacy_thresh': best['config']['LEGACY_V2']
+            'gov_thresh': best['config']['GOV_SCORE'],
+            'hydra_thresh': 0.85, # Default Safe
+            'legacy_thresh': 0.95 # Default Safe
         }
 
         # Diagnosis
@@ -560,7 +554,6 @@ class HeavyDutyBacktester:
         if best['total_trades'] > 2000 and best['net_profit'] < 10: diag.append("⚠️ Overtrading")
         if best['win_rate'] > 55 and best['net_profit'] < 0: diag.append("⚠️ Fee Burn")
         if abs(best['avg_loss']) > best['avg_win'] and best['win_count'] > 0: diag.append("⚠️ Risk/Reward Inversion")
-        if best['max_loss_streak'] > 10: diag.append("⚠️ Consecutive Loss Risk")
         if not diag: diag.append("✅ System Healthy")
 
         print("\n" + "="*60)
@@ -570,15 +563,8 @@ class HeavyDutyBacktester:
         print("-" * 60)
         print(f"   📊 Total Trades:    {best['total_trades']}")
         print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
-        print(f"   ✅ Winning Trades:  {best['win_count']} (Avg: {best['avg_win']*100:.2f}%)")
-        print(f"   ❌ Losing Trades:   {best['loss_count']} (Avg: {best['avg_loss']*100:.2f}%)")
-        print(f"   🌊 Max Streaks:     Win {best['max_win_streak']} | Loss {best['max_loss_streak']}")
         print(f"   ⚖️ Profit Factor:   {best['profit_factor']:.2f}")
         print("-" * 60)
-        print(f"   🧠 CONSENSUS ANALYTICS:")
-        print(f"   🤝 Model Agreement Rate:     {best.get('consensus_agreement_rate', 0.0):.1f}%")
-        print(f"   🌟 High-Consensus Win Rate:  {best.get('high_consensus_win_rate', 0.0):.1f}%")
-        print("-" * 60)
         print(f"   🩺 DIAGNOSIS: {' '.join(diag)}")
         
         p_str = ""
@@ -598,16 +584,18 @@ async def run_strategic_optimization_task():
         if proc.guardian_hydra: proc.guardian_hydra.set_silent_mode(True)
         hub = AdaptiveHub(r2); await hub.initialize()
         opt = HeavyDutyBacktester(dm, proc)
+        
+        # Scenarios now just set the regime target for saving, dates handled internally
         scenarios = [
-                {"regime": "DEAD", "start": "2023-06-01", "end": "2023-08-01"},
-                {"regime": "RANGE", "start": "2024-07-01", "end": "2024-09-30"},
-                {"regime": "BULL", "start": "2024-01-01", "end": "2024-03-30"},
-                {"regime": "BEAR", "start": "2023-08-01", "end": "2023-09-15"},
-                  ]
+            {"regime": "RANGE"}, 
+            # Add more regimes if needed to run consecutively
+        ]
+        
         for s in scenarios:
-            opt.set_date_range(s["start"], s["end"])
+            # Dates are now handled by LOOKBACK_DAYS in constructor by default
             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: