Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V122.1 - GEM-Architect: Method Scope Fix)
+# 🧪 backtest_engine.py (V123.0 - GEM-Architect: Real Legacy & Consensus Fix)
 # ============================================================
 
 import asyncio
@@ -34,7 +34,7 @@ logging.getLogger('ml_engine').setLevel(logging.WARNING)
 CACHE_DIR = "backtest_real_scores"
 
 # ============================================================
-# 🔧 1. FEATURE ENGINEERING REPLICAS (GLOBAL SCOPE)
+# 🔧 1. FEATURE ENGINEERING (GLOBAL & VECTORIZED)
 # ============================================================
 
 def _zv(x):
@@ -146,6 +146,82 @@ def calculate_titan_features_real(df):
     if vwap is not None: df['VWAP_dist'] = (df['close'] / vwap) - 1
     return df.fillna(0)
 
+# ============================================================
+# 🔧 NEW: LEGACY GUARD VECTORIZED FEATURES (REAL EXECUTION)
+# ============================================================
+def calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m):
+    """
+    Replicates HybridDeepSteward V2 features in a vectorized way for speed.
+    """
+    try:
+        def calc_basic(df, suffix):
+            c = df['close']; h = df['high']; l = df['low']
+            res = pd.DataFrame(index=df.index)
+            res[f'log_ret_{suffix}'] = np.log(c / c.shift(1)).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).fillna(0)
+            else:
+                ema = ta.ema(c, 20)
+                res[f'trend_slope_{suffix}'] = ((ema - ema.shift(5)) / ema.shift(5)).fillna(0)
+                if suffix == '15m':
+                    fib618 = roll_max - (diff * 0.382)
+                    res[f'dist_fib618_{suffix}'] = ((c - fib618) / c).fillna(0)
+            return res.fillna(0)
+
+        f1 = calc_basic(df_1m, '1m')
+        f5 = calc_basic(df_5m, '5m').reindex(df_1m.index, method='ffill')
+        f15 = calc_basic(df_15m, '15m').reindex(df_1m.index, method='ffill')
+
+        FEATS_1M = ['log_ret_1m', 'rsi_1m', 'fib_pos_1m', 'volatility_1m']
+        FEATS_5M = ['log_ret_5m', 'rsi_5m', 'fib_pos_5m', 'trend_slope_5m']
+        FEATS_15M = ['log_ret_15m', 'rsi_15m', 'dist_fib618_15m', 'trend_slope_15m']
+
+        parts = [f1[FEATS_1M], f5[FEATS_5M], f15[FEATS_15M]]
+        
+        lags = [1, 2, 3, 5, 10, 20]
+        for lag in lags:
+            lagged = f1[FEATS_1M].shift(lag).fillna(0)
+            parts.append(lagged)
+            
+        X_df = pd.concat(parts, axis=1)
+        return X_df.values 
+    except Exception as e:
+        print(f"Legacy V2 Vec Error: {e}")
+        return None
+
+def calculate_legacy_v3_vectorized(df_1m, df_5m, df_15m, feature_names):
+    """Replicates HybridDeepSteward V3 features"""
+    try:
+        def calc_v3(df, suffix=""):
+            d = df.copy()
+            d['rsi'] = ta.rsi(d['close'], 14).fillna(50)
+            d['ema_50'] = ta.ema(d['close'], 50).fillna(d['close'])
+            d['ema_200'] = ta.ema(d['close'], 200).fillna(d['close'])
+            d['dist_ema50'] = (d['close'] - d['ema_50'])/d['close']
+            d['dist_ema200'] = (d['close'] - d['ema_200'])/d['close']
+            d['log_ret'] = np.log(d['close']/d['close'].shift(1)).fillna(0)
+            
+            cols = ['rsi', 'dist_ema50', 'dist_ema200', 'log_ret']
+            res = d[cols].copy()
+            if suffix: res.columns = [f"{c}_{suffix}" for c in cols]
+            return res.fillna(0)
+
+        v1 = calc_v3(df_1m)
+        v5 = calc_v3(df_5m, "5m").reindex(df_1m.index, method='ffill')
+        v15 = calc_v3(df_15m, "15m").reindex(df_1m.index, method='ffill')
+
+        full_df = pd.concat([v1, v5, v15], axis=1)
+        
+        if not feature_names: return None
+        return full_df.reindex(columns=feature_names, fill_value=0).values
+    except: return None
+
 # ============================================================
 # 🧪 THE BACKTESTER CLASS
 # ============================================================
@@ -164,7 +240,7 @@ class HeavyDutyBacktester:
             for f in glob.glob(os.path.join(CACHE_DIR, "*")): os.remove(f)
         else: os.makedirs(CACHE_DIR)
             
-        print(f"🧪 [Backtest V122.1] Method Scope Fix. Checking Engines...")
+        print(f"🧪 [Backtest V123.0] Real Legacy & Consensus. Checking Engines...")
         self._check_engines()
 
     def _check_engines(self):
@@ -176,23 +252,20 @@ class HeavyDutyBacktester:
         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)")
         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
 
-    # ✅ FIXED: Helper methods are now INSIDE the class
     def _smart_predict(self, model, X):
         """Forces predict_proba and handles shape mismatch"""
         try:
-            # 1. Try Proba (For Classifiers)
             if hasattr(model, "predict_proba"):
                 raw = model.predict_proba(X)
                 if raw.ndim == 2:
-                    return raw[:, -1] # Positive/Buy Class
+                    return raw[:, -1] 
                 return raw 
-            
-            # 2. Fallback to predict
             return model.predict(X)
         except:
             return np.zeros(len(X) if hasattr(X, '__len__') else 0)
@@ -238,7 +311,7 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Analyzing {sym} (Real Models + Patterns)...", flush=True)
+        print(f"   ⚙️ [CPU] Analyzing {sym} (ALL REAL MODELS)...", flush=True)
         t0 = time.time()
 
         # 1. Base Data
@@ -248,6 +321,10 @@ class HeavyDutyBacktester:
         df_1m.set_index('datetime', inplace=True)
         df_1m = df_1m.sort_index()
 
+        # Aux Dataframes for Legacy
+        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 (L4/L1)
         df_sniper = calculate_sniper_features_exact(df_1m)
         df_sniper['rel_vol'] = df_sniper['volume'] / (df_sniper['volume'].rolling(50).mean() + 1e-9)
@@ -264,12 +341,14 @@ class HeavyDutyBacktester:
         pattern_models = getattr(self.proc.pattern_engine, 'models', {})
         if pattern_models and '15m' in pattern_models:
             try:
-                df_15m = df_1m.resample('15T').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'volume':'sum'}).dropna()
-                pat_scores_15m = np.full(len(df_15m), 0.5)
+                # ⚠️ Note: We rely on the internal feature calculation here for speed.
+                # In real execution, Pattern Engine handles this.
+                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)):
-                    window = df_15m.iloc[i-200:i]
+                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)
@@ -279,7 +358,7 @@ class HeavyDutyBacktester:
                     pat_preds = self._smart_predict(pattern_models['15m'], xgb.DMatrix(X_pat))
                     pat_scores_15m[valid_15m_idxs] = pat_preds
                 
-                ts_15m = df_15m.index.astype(np.int64) // 10**6
+                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}")
@@ -288,7 +367,6 @@ class HeavyDutyBacktester:
         res_titan = np.full(len(df_candidates), 0.5)
         if self.proc.titan and self.proc.titan.model:
             try:
-                df_5m = df_1m.resample('5T').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'volume':'sum'}).dropna()
                 df_5m_feat = calculate_titan_features_real(df_5m).add_prefix('5m_')
                 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)
@@ -306,7 +384,6 @@ class HeavyDutyBacktester:
                 for f in feats: 
                     if f not in df_candidates.columns: df_candidates[f] = 0.0
                 X_snip = df_candidates[feats].values
-                # ✅ Calling internal method self._smart_predict
                 preds = [self._extract_probs(self._smart_predict(m, X_snip)) for m in sniper_models]
                 res_sniper = np.mean(preds, axis=0)
             except Exception as e: print(f"Sniper Error: {e}")
@@ -325,9 +402,8 @@ class HeavyDutyBacktester:
                 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 & LEGACY (L0)
-        res_hydra_risk = np.zeros(len(df_candidates)); res_hydra_time = np.zeros(len(df_candidates), dtype=int)
-        
+        # 6️⃣ HYDRA (L0)
+        res_hydra_risk = np.zeros(len(df_candidates))
         hydra_models = getattr(self.proc.guardian_hydra, 'models', {})
         if hydra_models and 'crash' in hydra_models:
             try:
@@ -366,7 +442,45 @@ class HeavyDutyBacktester:
                     res_hydra_risk[r_idxs] = np.max(preds, axis=1)
             except: pass
 
-        # 7️⃣ FINAL ASSEMBLY
+        # 7️⃣ REAL LEGACY GUARD (V2 & V3) - 🛡️ NEW
+        res_legacy_v2 = np.zeros(len(df_candidates))
+        res_legacy_v3 = np.zeros(len(df_candidates))
+        
+        if self.proc.guardian_legacy:
+            try:
+                # Prepare Vectorized Features for the entire timeline for correctness
+                X_v2_full = calculate_legacy_v2_vectorized(df_1m, df_5m, df_15m)
+                v3_feats = self.proc.guardian_legacy.v3_feature_names
+                X_v3_full = calculate_legacy_v3_vectorized(df_1m, df_5m, df_15m, v3_feats)
+                
+                # Map candidates to full df indices
+                # valid_mask is boolean array same length as df_1m (approx)
+                # We need exact indices in X_v2_full matching df_candidates
+                all_indices = np.arange(len(df_1m))
+                cand_indices = all_indices[valid_mask]
+                
+                # Safety Clip
+                max_len = len(X_v2_full)
+                cand_indices = cand_indices[cand_indices < max_len]
+                
+                if len(cand_indices) > 0:
+                    # Predict V2
+                    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] # Panic Class
+                        else: res_legacy_v2[:len(cand_indices)] = preds_v2
+
+                    # Predict V3
+                    if self.proc.guardian_legacy.model_v3 and X_v3_full is not None:
+                        subset_v3 = X_v3_full[cand_indices]
+                        preds_v3 = self.proc.guardian_legacy.model_v3.predict(xgb.DMatrix(subset_v3))
+                        res_legacy_v3[:len(cand_indices)] = preds_v3
+
+            except Exception as e:
+                print(f"❌ Legacy Guard Error: {e}")
+
+        # 8️⃣ FINAL 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({
@@ -378,9 +492,8 @@ class HeavyDutyBacktester:
             'sniper_score': res_sniper,
             'l1_score': df_candidates['l1_score'],
             'risk_hydra_crash': res_hydra_risk,
-            'time_hydra_crash': res_hydra_time,
-            'risk_legacy_v2': 0.0,
-            'time_legacy_panic': 0
+            'risk_legacy_v2': res_legacy_v2,    # ✅ REAL
+            'risk_legacy_v3': res_legacy_v3     # ✅ REAL
         })
 
         dt = time.time() - t0
@@ -389,7 +502,6 @@ class HeavyDutyBacktester:
             print(f"   ✅ [{sym}] Completed {len(ai_df)} signals in {dt:.2f} seconds.", flush=True)
         gc.collect()
 
-    # --- Standard Methods (unchanged) ---
     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)
@@ -399,9 +511,7 @@ class HeavyDutyBacktester:
             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)
-# ============================================================
-    # 🔧 FIX: Updated Worker with Consensus Metrics
-    # ============================================================
+
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
         print(f"     ⏳ [System] Loading {len(scores_files)} datasets...", flush=True)
@@ -412,7 +522,7 @@ class HeavyDutyBacktester:
         if not data: return []
         df = pd.concat(data).sort_values('timestamp')
         
-        # Arrays extraction
+        # 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])
@@ -421,117 +531,94 @@ class HeavyDutyBacktester:
         hydra = df['risk_hydra_crash'].values; titan = df['real_titan'].values
         l1 = df['l1_score'].values
         
+        legacy_v2 = df['risk_legacy_v2'].values # ✅ REAL
+        legacy_v3 = df['risk_legacy_v3'].values # ✅ REAL
+        
         N = len(ts)
         print(f"     🚀 [System] Testing {len(combinations_batch)} configs on {N} candles...", flush=True)
         
         res = []
         for cfg in combinations_batch:
-            pos = {}; log = [] # log stores: (pnl, was_consensus)
+            pos = {}; log = [] 
             bal = initial_capital; alloc = 0.0
             
-            # Entry Logic Mask
             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 LOGIC ---
+                # Exit
                 if s in pos:
-                    entry_price = pos[s][0]
-                    h_r = pos[s][1]
-                    entry_titan_score = pos[s][3] # Stored Titan Score
+                    entry = pos[s][0]; h_r = pos[s][1]; titan_entry = pos[s][3]
                     
-                    crash = (h_r > cfg['hydra_thresh']) 
-                    pnl = (p - entry_price) / entry_price
+                    crash_hydra = (h_r > cfg['hydra_thresh']) 
+                    panic_legacy = (legacy_v2[i] > cfg['legacy_thresh']) or (legacy_v3[i] > cfg['legacy_thresh'])
                     
-                    # Simple SL/TP or Hydra Exit
-                    if crash or pnl > 0.04 or pnl < -0.02:
-                        # Fee impact (entry + exit)
-                        realized_pnl = pnl - (fees_pct * 2)
-                        
-                        bal += pos[s][2] * (1 + realized_pnl)
+                    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]
                         
-                        # Check consensus for this trade (Did Titan agree?)
-                        is_consensus = (entry_titan_score > 0.55) # Threshold for agreement
-                        log.append({'pnl': realized_pnl, 'consensus': is_consensus})
-                        
+                        is_consensus = (titan_entry > 0.55)
+                        log.append({'pnl': realized, 'consensus': is_consensus})
                         del pos[s]
                 
-                # --- ENTRY LOGIC ---
+                # 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) # Fixed size per slot mostly
-                        # Store: (Price, HydraRisk, Size, TitanScore)
+                        size = min(10.0, bal * 0.98)
                         pos[s] = (p, hydra[i], size, titan[i])
                         bal -= size; alloc += size
             
-            # --- METRICS CALCULATION ---
+            # Metrics
             final_bal = bal + alloc
-            net_profit = final_bal - initial_capital
-            total_trades = len(log)
+            profit = final_bal - initial_capital
+            tot = len(log)
             wins = sum(1 for x in log if x['pnl'] > 0)
-            win_rate = (wins / total_trades * 100) if total_trades > 0 else 0.0
-            
-            # Consensus Metrics Calculation
-            consensus_trades = [x for x in log if x['consensus']]
-            num_con = len(consensus_trades)
-            
-            agreement_rate = (num_con / total_trades * 100) if total_trades > 0 else 0.0
-            con_wins = sum(1 for x in consensus_trades if x['pnl'] > 0)
-            con_win_rate = (con_wins / num_con * 100) if num_con > 0 else 0.0
-            con_avg_pnl = (sum(x['pnl'] for x in consensus_trades) / num_con * 100) if num_con > 0 else 0.0
+            win_rate = (wins/tot*100) if tot else 0
             
+            # Consensus Metrics
+            cons_trades = [x for x in log if x['consensus']]
+            n_cons = len(cons_trades)
+            agree_rate = (n_cons/tot*100) if tot else 0
+            cons_win_rate = (sum(1 for x in cons_trades if x['pnl']>0)/n_cons*100) if n_cons else 0
+            cons_avg_pnl = (sum(x['pnl'] for x in cons_trades)/n_cons*100) if n_cons else 0
+
             res.append({
-                'config': cfg,
-                'final_balance': final_bal,   # ✅ Added
-                'net_profit': net_profit,
-                'total_trades': total_trades,
-                'win_rate': win_rate,
-                'max_drawdown': 0.0, # Simplified for speed
-                'consensus_agreement_rate': agreement_rate, # ✅ Added
-                'high_consensus_win_rate': con_win_rate,    # ✅ Added
-                'high_consensus_avg_pnl': con_avg_pnl       # ✅ Added
+                'config': cfg, 'final_balance': final_bal, 'net_profit': profit, 
+                'total_trades': tot, 'win_rate': win_rate, 'max_drawdown': 0,
+                'consensus_agreement_rate': agree_rate,
+                'high_consensus_win_rate': cons_win_rate,
+                'high_consensus_avg_pnl': cons_avg_pnl
             })
-            
         return res
 
-    # ============================================================
-    # 🔧 FIX: Run Optimization with Safe Sorting
-    # ============================================================
     async def run_optimization(self, target_regime="RANGE"):
         await self.generate_truth_data()
         
-        # Grid Setup
-        oracle_r = np.linspace(0.5, 0.8, 3) 
-        sniper_r = np.linspace(0.3, 0.6, 3)
-        hydra_r = [0.85, 0.95]
-        l1_r = [5.0]
+        # 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,
-                'l1_thresh': l1, 'oracle_thresh': o, 'sniper_thresh': s, 
-                'hydra_thresh': h, 'legacy_thresh': 0.95
+                '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"))
-        if not files:
-            print("⚠️ [Warning] No data files found for backtest.")
-            return None, {'net_profit': 0.0}
-
-        # Run Worker
         results_list = self._worker_optimize(combos, files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
         
+        # ✅ FIX: Handle empty result & Sort for 'best'
         if not results_list:
             print("⚠️ [Warning] No trades generated in any config.")
             return None, {'net_profit': 0.0, 'win_rate': 0.0}
 
-        # ✅ FIX: Sort and select 'best'
-        # Sort by Net Profit descending
         results_list.sort(key=lambda x: x['net_profit'], reverse=True)
-        best = results_list[0] # The Champion
+        best = results_list[0]
 
         print("\n" + "="*60)
         print(f"🏆 CHAMPION REPORT [{target_regime}]:")
@@ -540,23 +627,23 @@ 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}% (Approx)")
+        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}%")
         print("-" * 60)
         print(f"   🧠 CONSENSUS ANALYTICS:")
-        print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}% (Titan Agreed)")
+        print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}%")
         print(f"   🌟 High-Consensus Win Rate:  {best['high_consensus_win_rate']:.1f}%")
         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']['l1_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)
     await dm.initialize(); await proc.initialize()
-    proc.guardian_hydra.set_silent_mode(True)
+    if proc.guardian_hydra: proc.guardian_hydra.set_silent_mode(True)
 
     hub = AdaptiveHub(r2); await hub.initialize()
     opt = HeavyDutyBacktester(dm, proc)
@@ -572,7 +659,9 @@ 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)
-            
+    
+    # Clean up
+    await dm.close()
     await hub._save_state_to_r2()
     print("✅ [System] DNA Updated.")