Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V96.0 - GEM-Architect: Vectorized Logic Mirror)
+# 🧪 backtest_engine.py (V101.0 - GEM-Architect: Smart Adaptive Grid)
 # ============================================================
 
 import asyncio
@@ -31,12 +31,13 @@ class HeavyDutyBacktester:
     def __init__(self, data_manager, processor):
         self.dm = data_manager
         self.proc = processor
-        self.GRID_DENSITY = 10 
+        # كثافة الشبكة للدخول (Titan/Structure)
+        self.GRID_DENSITY = 6 
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
         
-        # القائمة الكاملة (50 عملة)
+        # القائمة الكاملة
         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', 
@@ -53,7 +54,7 @@ class HeavyDutyBacktester:
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V96.0] Vectorized Logic Mirror (Exact L1 Simulation).")
+        print(f"🧪 [Backtest V101.0] Smart Adaptive Grid (Full Dynamic Optimization).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -108,40 +109,29 @@ class HeavyDutyBacktester:
         return unique_candles
 
     # ==============================================================
-    # 🏎️ VECTORIZED INDICATOR CALCULATION
+    # 🏎️ VECTORIZED INDICATORS
     # ==============================================================
     def _calculate_indicators_vectorized(self, df):
-        """
-        حساب المؤشرات الفنية لكامل البيانات دفعة واحدة باستخدام Pandas Vectorization.
-        هذا يطابق منطق DataManager._calc_indicators بالضبط ولكن أسرع بـ 1000 مرة.
-        """
-        # RSI
         delta = df['close'].diff()
         gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
         loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
         rs = gain / loss
         df['rsi'] = 100 - (100 / (1 + rs))
-        
-        # EMA
         df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
         df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
         
-        # ATR (Simplified Vectorized)
         high_low = df['high'] - df['low']
         high_close = (df['high'] - df['close'].shift()).abs()
         low_close = (df['low'] - df['close'].shift()).abs()
         ranges = pd.concat([high_low, high_close, low_close], axis=1)
         true_range = ranges.max(axis=1)
         df['atr'] = true_range.rolling(14).mean()
-        
-        # Volume MA
         df['vol_ma20'] = df['volume'].rolling(window=20).mean()
-        
         df.fillna(0, inplace=True)
         return df
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (VECTORIZED LOGIC MIRROR)
+    # 🧠 CPU PROCESSING (WITH TWIN-GUARDIAN PROFILING)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -152,10 +142,9 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Analyzing {sym}...", flush=True)
+        print(f"   ⚙️ [CPU] Analyzing {sym} (Profiling Hydra & Legacy)...", flush=True)
         t0 = time.time()
 
-        # 1. Prepare Pandas
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         cols = ['open', 'high', 'low', 'close', 'volume']
         df_1m[cols] = df_1m[cols].astype('float32')
@@ -163,116 +152,65 @@ class HeavyDutyBacktester:
         df_1m.set_index('datetime', inplace=True)
         df_1m = df_1m.sort_index()
 
-        # 2. Resample & Calculate Indicators (ONCE)
         frames = {}
         numpy_frames = {}
         time_indices = {}
         agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
         
-        # 1m Setup
         frames['1m'] = df_1m.copy()
         frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
         col_order = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
         numpy_frames['1m'] = frames['1m'][col_order].values 
         time_indices['1m'] = frames['1m'].index
 
-        # Resample Others
         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()
-            
-            # 🔥🔥 Calculate Indicators HERE (Vectorized) 🔥🔥
             if tf_str in ['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 # Raw data for passing
+            numpy_frames[tf_str] = resampled[col_order].values
             time_indices[tf_str] = resampled.index
 
         ai_results = []
         valid_idx_5m = time_indices['5m']
         
-        # 3. 🔥 VECTORIZED LOGIC MATCHING (The Speed Force) 🔥
-        # بدلاً من حلقة تكرار عمياء، نجد "أماكن الاهتمام" فوراً باستخدام المنطق البولياني
-        # هذا يطابق شروط DataManager._apply_logic_tree حرفياً
-        
-        # نحتاج لمطابقة وقت الـ 5m مع الـ 1h و 15m
-        # سنقوم بعمل reindex للـ 1h و 15m ليتطابق مع الـ 5m (Forward Fill)
-        # هذا يسمح لنا بمقارنة الأعمدة مباشرة
-        
+        # --- L1 Logic Vectorized ---
         df_5m_aligned = frames['5m'].copy()
-        
-        # دمج بيانات الـ 1h مع الـ 5m (Matching times)
         df_1h_aligned = frames['1h'].reindex(frames['5m'].index, method='ffill')
         df_15m_aligned = frames['15m'].reindex(frames['5m'].index, method='ffill')
         
-        # --- تطبيق شروط L1 (Breakout & Reversal) ---
-        
-        # الشروط المشتركة (Common Filters from V15.2)
-        # 1. 4H Change calculation (approx from 1H data)
-        # shift(4) في فريم الساعة يقابل shift(48) في فريم 5 دقائق (تقريباً)
-        # للأمان نستخدم بيانات الساعة المحاذية
         change_4h = ((df_1h_aligned['close'] - df_1h_aligned['close'].shift(4)) / df_1h_aligned['close'].shift(4)) * 100
-        
-        # فلتر: ممنوع أكثر من 8% صعود في 4 ساعات
         cond_not_pump = change_4h <= 8.0
-        # فلتر: RSI 1H ممنوع فوق 70
         cond_rsi_1h_safe = df_1h_aligned['rsi'] <= 70
-        # فلتر: الامتداد (Deviation)
         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
         
-        # --- Breakout Logic ---
-        # 1. Bullish Structure (1H)
         bullish_1h = (df_1h_aligned['ema20'] > df_1h_aligned['ema50']) | (df_1h_aligned['close'] > df_1h_aligned['ema20'])
-        # 2. RSI 1H Room (45-68)
         rsi_1h_ok = (df_1h_aligned['rsi'] >= 45) & (df_1h_aligned['rsi'] <= 68)
-        # 3. 15M Close > EMA20
         close_above_ema_15m = df_15m_aligned['close'] >= df_15m_aligned['ema20']
-        # 4. Volume 15M Spike
         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
         
-        # --- Reversal Logic ---
-        # 1. RSI 1H Oversold (20-40)
         rsi_oversold = (df_1h_aligned['rsi'] >= 20) & (df_1h_aligned['rsi'] <= 40)
-        # 2. Drop in price (change_4h <= -2)
         price_drop = change_4h <= -2.0
-        # 3. Hammer/Rejection on 15M (Vectorized Approximation)
-        # Hammer: Lower wick > 1.5 * Body
         body = (df_15m_aligned['close'] - df_15m_aligned['open']).abs()
         lower_wick = df_15m_aligned[['open', 'close']].min(axis=1) - df_15m_aligned['low']
         is_hammer = lower_wick > (body * 1.5)
         is_green = df_15m_aligned['close'] > df_15m_aligned['open']
-        
         is_reversal = filters_pass & rsi_oversold & price_drop & (is_hammer | is_green)
         
-        # --- Combined Mask ---
-        # هذه هي اللحظات التي تستحق التحليل فقط!
         valid_mask = is_breakout | is_reversal
         valid_indices = df_5m_aligned[valid_mask].index
         
-        # --------------------------------------------------------
-        
-        # 4. Loop ONLY on Valid Indices (The massive speedup)
-        # بدلاً من 129,000 لفة، سنجد ربما 2,000 - 5,000 لفة فقط.
-        
         start_dt = df_1m.index[0] + pd.Timedelta(minutes=500)
         final_valid_indices = [t for t in valid_indices if t >= start_dt]
         
         total_hits = len(final_valid_indices)
-        print(f"     🎯 Found {total_hits} potential setups. Running Titan...", flush=True)
+        print(f"     🎯 Found {total_hits} signals. Profiling Guardians...", flush=True)
         
         for i, current_time in enumerate(final_valid_indices):
-            # قص البيانات (Slicing) لتمريرها للنماذج
-            # نستخدم searchsorted للسرعة القصوى
-            
-            # نحتاج تحويل timestamp الـ index إلى مكان في الـ numpy arrays
-            # ملاحظة: time_indices['1m'] مرتب، لذا searchsorted يعمل
-            
             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
@@ -282,13 +220,6 @@ class HeavyDutyBacktester:
             
             if idx_1m < 500 or idx_4h < 100: continue
             
-            # استخراج نوع الإشارة (لأننا دمجناهم في valid_mask)
-            # نعيد التحقق السريع لنعرف النوع
-            # ملاحظة: الوصول هنا سريع جداً لأننا نعرف التوقيت
-            # أو يمكننا الاعتماد على أن DataManager سيعيد النوع الصحيح
-            
-            # نجهز الـ Packet ونرسلها لـ DataManager للتأكيد النهائي واستخراج السكور
-            # هذا يضمن التطابق 100%
             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()
             
@@ -319,16 +250,73 @@ class HeavyDutyBacktester:
                     if proc_res: real_titan = proc_res.get('titan_score', 0.5)
                 except: pass
 
+                # 🔥 RISK PROFILING (Hydra + Legacy)
+                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
+                
+                trade_ctx = {
+                    'entry_price': current_price, 'entry_time': str(current_time),
+                    'volume_30m_usd': 1000000 
+                }
+                
+                future_limit = 240
+                end_idx_1m = min(idx_1m + future_limit, len(numpy_frames['1m']) - 1)
+                check_step = 10 
+                current_idx_1m = idx_1m
+                
+                while current_idx_1m < end_idx_1m:
+                    current_idx_1m += check_step
+                    
+                    future_1m_data = numpy_frames['1m'][current_idx_1m-1000+1 : current_idx_1m+1].tolist()
+                    future_5m_data = numpy_frames['5m'][idx_5m-300+1 : idx_5m+1].tolist() 
+                    current_ts = int(numpy_frames['1m'][current_idx_1m][0])
+                    
+                    # 🐉 A. Check Hydra
+                    if self.proc.guardian_hydra:
+                        hydra_res = self.proc.guardian_hydra.analyze_position(sym, future_1m_data, future_5m_data, ohlcv_15m, trade_ctx)
+                        probs = hydra_res.get('probs', {})
+                        p_crash = probs.get('crash', 0.0)
+                        
+                        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 probs.get('giveback', 0) > max_hydra_giveback: max_hydra_giveback = probs.get('giveback', 0)
+
+                    # 🕸️ B. Check Legacy
+                    if self.proc.guardian_legacy:
+                        legacy_res = self.proc.guardian_legacy.analyze_position(
+                            future_1m_data, future_5m_data, ohlcv_15m, current_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
+                            
+                        if s_v3 > max_legacy_v3: max_legacy_v3 = s_v3
+
                 ts_aligned = int(current_time.timestamp() // 60) * 60 * 1000
                 ai_results.append({
                     'timestamp': ts_aligned, 'symbol': sym, 'close': current_price,
-                    'real_titan': real_titan, 'signal_type': signal_type, 'l1_score': l1_score
+                    'real_titan': real_titan, 'signal_type': signal_type, 'l1_score': l1_score,
+                    'risk_hydra_crash': max_hydra_crash,
+                    'time_hydra_crash': hydra_crash_time,
+                    'risk_legacy_v2': max_legacy_v2,
+                    'time_legacy_panic': legacy_panic_time
                 })
         
         dt = time.time() - t0
         if ai_results:
             pd.DataFrame(ai_results).to_pickle(scores_file)
-            print(f"   💾 [{sym}] Saved {len(ai_results)} verified signals. (Compute: {dt:.1f}s)", flush=True)
+            print(f"   💾 [{sym}] Saved {len(ai_results)} profiled signals. ({dt:.1f}s)", flush=True)
         else:
             print(f"   ⚠️ [{sym}] No signals.", flush=True)
             
@@ -344,7 +332,7 @@ class HeavyDutyBacktester:
             dt_end = datetime.strptime(self.force_end_date, "%Y-%m-%d").replace(tzinfo=timezone.utc)
             start_time_ms = int(dt_start.timestamp() * 1000)
             end_time_ms = int(dt_end.timestamp() * 1000)
-            print(f"\n🚜 [Phase 1] Era: {self.force_start_date} -> {self.force_end_date}")
+            print(f"\n🚜 [Phase 1] Processing Era: {self.force_start_date} -> {self.force_end_date}")
         else:
             return 
         
@@ -361,7 +349,7 @@ class HeavyDutyBacktester:
             gc.collect()
 
     # ==============================================================
-    # PHASE 2: Portfolio Digital Twin Engine
+    # PHASE 2: Portfolio Digital Twin (✅ SMART DYNAMIC GRID)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
@@ -382,24 +370,44 @@ class HeavyDutyBacktester:
         
         for config in combinations_batch:
             wallet = { "balance": initial_capital, "allocated": 0.0, "positions": {}, "trades_history": [] }
+            
+            # Configs
             w_titan = config['w_titan']; w_struct = config['w_struct']; entry_thresh = config['thresh']
+            hydra_thresh = config['hydra_thresh']
+            legacy_thresh = config['legacy_thresh']
+            
             peak_balance = initial_capital; max_drawdown = 0.0
             
             for ts, group in grouped_by_time:
                 active_symbols = list(wallet["positions"].keys())
                 current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
                 
-                # Exit Logic
+                # --- 1. Exit Logic ---
                 for sym in active_symbols:
                     if sym in current_prices:
                         curr_p = current_prices[sym]
                         pos = wallet["positions"][sym]
                         entry_p = pos['entry_price']
+                        
+                        hydra_score = pos.get('risk_hydra_crash', 0.0)
+                        hydra_time = pos.get('time_hydra_crash', 0)
+                        exit_hydra = (hydra_score > hydra_thresh) and (hydra_time > 0) and (ts >= hydra_time)
+                        
+                        legacy_score = pos.get('risk_legacy_v2', 0.0)
+                        legacy_time = pos.get('time_legacy_panic', 0)
+                        exit_legacy = (legacy_score > legacy_thresh) and (legacy_time > 0) and (ts >= legacy_time)
+                        
+                        tp_target = pos.get('tp_target', 0.03)
+                        sl_target = pos.get('sl_target', -0.02)
+                        if curr_p > entry_p * 1.025: sl_target = 0.001 
+                        
                         pct_change = (curr_p - entry_p) / entry_p
-                        if pct_change >= 0.03 or pct_change <= -0.02:
+                        
+                        if exit_hydra or exit_legacy or pct_change >= tp_target or pct_change <= sl_target:
                             gross_pnl = pos['size_usd'] * pct_change
                             fees = pos['size_usd'] * fees_pct * 2
                             net_pnl = gross_pnl - fees
+                            
                             wallet["allocated"] -= pos['size_usd']
                             wallet["balance"] += (pos['size_usd'] + net_pnl)
                             del wallet["positions"][sym]
@@ -410,19 +418,20 @@ class HeavyDutyBacktester:
                 dd = (peak_balance - current_total_equity) / peak_balance
                 if dd > max_drawdown: max_drawdown = dd
 
-                # Entry Logic
+                # --- 2. Entry Logic ---
                 effective_max_slots = max_slots
-                if current_total_equity < MIN_CAPITAL_FOR_SPLIT:
-                    effective_max_slots = min(max_slots, 2)
+                if current_total_equity < MIN_CAPITAL_FOR_SPLIT: effective_max_slots = min(max_slots, 2)
                 
                 if len(wallet["positions"]) < effective_max_slots:
                     free_capital = wallet["balance"]
                     slots_left = effective_max_slots - len(wallet["positions"])
+                    
                     if slots_left > 0 and free_capital >= MIN_TRADE_SIZE:
                         candidates = []
                         for _, row in group.iterrows():
                             sym = row['symbol']
                             if sym in wallet["positions"]: continue
+                            
                             sig_type = row['signal_type']
                             l1_raw_score = row['l1_score']
                             real_titan = row['real_titan']
@@ -432,8 +441,17 @@ class HeavyDutyBacktester:
                             score = 0.0
                             if (w_titan + w_struct) > 0:
                                 score = ((real_titan * w_titan) + (norm_struct * w_struct)) / (w_titan + w_struct)
+                            
                             if score >= entry_thresh:
-                                candidates.append({ 'symbol': sym, 'score': score, 'price': row['close'] })
+                                candidates.append({ 
+                                    'symbol': sym, 'score': score, 'price': row['close'],
+                                    'titan': real_titan,
+                                    'risk_hydra_crash': row.get('risk_hydra_crash', 0),
+                                    'time_hydra_crash': row.get('time_hydra_crash', 0),
+                                    'risk_legacy_v2': row.get('risk_legacy_v2', 0),
+                                    'time_legacy_panic': row.get('time_legacy_panic', 0)
+                                })
+                        
                         candidates.sort(key=lambda x: x['score'], reverse=True)
                         for cand in candidates[:slots_left]:
                             if current_total_equity >= MIN_CAPITAL_FOR_SPLIT:
@@ -441,44 +459,57 @@ class HeavyDutyBacktester:
                                 trade_size = min(target_size, wallet["balance"])
                             else:
                                 trade_size = wallet["balance"] * 0.98
+                            
                             if trade_size < MIN_TRADE_SIZE: continue
-                            wallet["positions"][cand['symbol']] = {'entry_price': cand['price'], 'size_usd': trade_size}
+                            
+                            tp_base = 0.03; sl_base = -0.02
+                            if cand['titan'] > 0.8: tp_base = 0.06; sl_base = -0.025
+                            elif cand['titan'] < 0.6: tp_base = 0.02; sl_base = -0.015
+                                
+                            wallet["positions"][cand['symbol']] = {
+                                'entry_price': cand['price'], 
+                                'size_usd': trade_size,
+                                'tp_target': tp_base, 'sl_target': sl_base,
+                                'risk_hydra_crash': cand['risk_hydra_crash'],
+                                'time_hydra_crash': cand['time_hydra_crash'],
+                                'risk_legacy_v2': cand['risk_legacy_v2'],
+                                'time_legacy_panic': cand['time_legacy_panic']
+                            }
                             wallet["allocated"] += trade_size
                             wallet["balance"] -= trade_size
                             if wallet["balance"] < MIN_TRADE_SIZE: break
 
-            trades = wallet["trades_history"]
-            if trades:
-                final_equity = wallet["balance"] + wallet["allocated"]
-                net_profit = final_equity - initial_capital
-                pnls = [t['pnl'] for t in trades]
-                win_count = len([p for p in pnls if p > 0]); loss_count = len([p for p in pnls if p <= 0])
-                win_rate = (win_count / len(trades)) * 100
-                max_single_win = max(pnls) if pnls else 0.0; max_single_loss = min(pnls) if pnls else 0.0
-                current_win_streak = 0; max_win_streak = 0
-                current_loss_streak = 0; max_loss_streak = 0
+            final_equity = wallet["balance"] + wallet["allocated"]
+            net_profit = final_equity - initial_capital
+            
+            total_trades = len(wallet["trades_history"])
+            win_count = 0; loss_count = 0; win_rate = 0.0
+            max_single_win = 0.0; max_single_loss = 0.0
+            max_win_streak = 0; max_loss_streak = 0
+            
+            if total_trades > 0:
+                pnls = [t['pnl'] for t in wallet["trades_history"]]
+                win_count = len([p for p in pnls if p > 0])
+                loss_count = len([p for p in pnls if p <= 0])
+                win_rate = (win_count / total_trades) * 100
+                max_single_win = max(pnls) if pnls else 0.0
+                max_single_loss = min(pnls) if pnls else 0.0
+                curr_win = 0; curr_loss = 0
                 for p in pnls:
                     if p > 0:
-                        current_win_streak += 1; current_loss_streak = 0
-                        if current_win_streak > max_win_streak: max_win_streak = current_win_streak
+                        curr_win += 1; curr_loss = 0
+                        if curr_win > max_win_streak: max_win_streak = curr_win
                     else:
-                        current_loss_streak += 1; current_win_streak = 0
-                        if current_loss_streak > max_loss_streak: max_loss_streak = current_loss_streak
-                results.append({
-                    'config': config, 'final_balance': final_equity,
-                    'net_profit': net_profit, 'total_trades': len(trades),
-                    'win_count': win_count, 'loss_count': loss_count, 'win_rate': win_rate,
-                    'max_single_win': max_single_win, 'max_single_loss': max_single_loss,
-                    'max_win_streak': max_win_streak, 'max_loss_streak': max_loss_streak,
-                    'max_drawdown': max_drawdown * 100
-                })
-            else:
-                 results.append({
-                     'config': config, 'final_balance': initial_capital, 'net_profit': 0.0, 
-                     'total_trades': 0, 'win_count': 0, 'loss_count': 0, 'win_rate': 0.0,
-                     'max_single_win': 0.0, 'max_single_loss': 0.0, 'max_win_streak': 0, 
-                     'max_loss_streak': 0, 'max_drawdown': 0.0
-                 })
+                        curr_loss += 1; curr_win = 0
+                        if curr_loss > max_loss_streak: max_loss_streak = curr_loss
+
+            results.append({
+                'config': config, 'final_balance': final_equity, 'net_profit': net_profit,
+                'total_trades': total_trades, 'win_count': win_count, 'loss_count': loss_count,
+                'win_rate': win_rate, 'max_single_win': max_single_win, 'max_single_loss': max_single_loss,
+                'max_win_streak': max_win_streak, 'max_loss_streak': max_loss_streak, 'max_drawdown': max_drawdown * 100
+            })
+            
         return results
 
     async def run_optimization(self, target_regime="RANGE"):
@@ -498,37 +529,65 @@ class HeavyDutyBacktester:
             return None, None
 
         print(f"\n🧩 [Phase 2] Optimizing for {target_regime}...")
+        
         w_titan_range = np.linspace(0.4, 0.9, num=self.GRID_DENSITY)
         w_struct_range = np.linspace(0.1, 0.6, num=self.GRID_DENSITY)
         thresh_range = np.linspace(0.20, 0.60, num=self.GRID_DENSITY)
         
+        # ✅ Smart Dynamic Grid for Guardians (Controlled Density)
+        GUARD_DENSITY = 4 
+        hydra_range = np.linspace(0.70, 0.95, num=GUARD_DENSITY)
+        legacy_range = np.linspace(0.85, 0.98, num=GUARD_DENSITY)
+        
         combinations = []
-        for wt, ws, th in itertools.product(w_titan_range, w_struct_range, thresh_range):
+        for wt, ws, th, hydra, legacy in itertools.product(w_titan_range, w_struct_range, thresh_range, hydra_range, legacy_range):
             if 0.9 <= (wt + ws) <= 1.1:
-                combinations.append({'w_titan': round(wt, 2), 'w_struct': round(ws, 2), 'thresh': round(th, 2)})
+                combinations.append({
+                    'w_titan': round(wt, 2), 
+                    'w_struct': round(ws, 2), 
+                    'thresh': round(th, 2),
+                    'hydra_thresh': round(hydra, 2),
+                    'legacy_thresh': round(legacy, 2)
+                })
             
         final_results = []
-        batch_size = 100 
+        batch_size = 200 
+        
+        print(f"     🔥 Testing {len(combinations)} Strategy Combinations...")
         
         for i in range(0, len(combinations), batch_size):
             batch = combinations[i:i+batch_size]
             res = self._worker_optimize(batch, current_period_files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
             final_results.extend(res)
-            if i % 1000 == 0: print(f"     ...Analyzed {i}/{len(combinations)} configs", flush=True)
+            if i % 2000 == 0: print(f"     ...Analyzed {i}/{len(combinations)} configs", flush=True)
 
         if not final_results: return None, None
         best = sorted(final_results, key=lambda x: x['final_balance'], reverse=True)[0]
         
         print("\n" + "="*60)
         print(f"🏆 CHAMPION REPORT [{target_regime}]:")
+        print(f"   📅 Period: {self.force_start_date} -> {self.force_end_date}")
         print(f"   💰 Final Balance:   ${best['final_balance']:,.2f}")
+        print(f"   🚀 Net PnL:         ${best['net_profit']:,.2f}")
+        print("-" * 60)
+        print(f"   📊 Total Trades:    {best['total_trades']}")
+        print(f"   ✅ Winning Trades:  {best['win_count']}")
+        print(f"   ❌ Losing Trades:   {best['loss_count']}")
         print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
-        print(f"   ⚙️ Config: Titan={best['config']['w_titan']} | Struct={best['config']['w_struct']} | Thresh={best['config']['thresh']}")
+        print("-" * 60)
+        print(f"   🟢 Max Single Win:  ${best['max_single_win']:.2f}")
+        print(f"   🔴 Max Single Loss: ${best['max_single_loss']:.2f}")
+        print(f"   🔥 Max Win Streak:  {best['max_win_streak']} trades")
+        print(f"   🧊 Max Loss Streak: {best['max_loss_streak']} trades")
+        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}%")
+        print("-" * 60)
+        print(f"   ⚙️ Entry: Titan={best['config']['w_titan']} | Struct={best['config']['w_struct']} | Thresh={best['config']['thresh']}")
+        print(f"   🛡️ Guard: Hydra={best['config']['hydra_thresh']} | Legacy={best['config']['legacy_thresh']}")
         print("="*60)
         return best['config'], best
 
 async def run_strategic_optimization_task():
-    print("\n🧪 [STRATEGIC BACKTEST] Vectorized Logic Mirror Initiated...")
+    print("\n🧪 [STRATEGIC BACKTEST] Smart Adaptive Grid Initiated...")
     r2 = R2Service()
     dm = DataManager(None, None, r2)
     proc = MLProcessor(dm)