Update ml_engine/processor.py

ml_engine/processor.py

@@ -1,393 +1,690 @@
 # ============================================================
-# 🧠 ml_engine/processor.py (V36.0 - GEM-Architect: The Cybernetic Processor)
+# 🧪 backtest_engine.py (V115.0 - GEM-Architect: Full Grid Density)
 # ============================================================
 
 import asyncio
-import traceback
+import pandas as pd
+import numpy as np
+import pandas_ta as ta
+import time
 import logging
+import itertools 
 import os
+import gc 
 import sys
-import numpy as np
-from typing import Dict, Any, List, Optional
-
-# --- استيراد المحركات (كما هي) ---
-try: from .titan_engine import TitanEngine
-except ImportError: TitanEngine = None
-try: from .patterns import ChartPatternAnalyzer
-except ImportError: ChartPatternAnalyzer = None
-try: from .monte_carlo import MonteCarloEngine
-except ImportError: MonteCarloEngine = None
-try: from .oracle_engine import OracleEngine
-except ImportError: OracleEngine = None
-try: from .sniper_engine import SniperEngine
-except ImportError: SniperEngine = None
-try: from .hybrid_guardian import HybridDeepSteward
-except ImportError: HybridDeepSteward = None
-try: from .guardian_hydra import GuardianHydra
-except ImportError: GuardianHydra = None
+import traceback
+from datetime import datetime, timezone
+from typing import Dict, Any, List
 
-# ============================================================
-# 📂 مسارات النماذج
-# ============================================================
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-MODELS_L2_DIR = os.path.join(BASE_DIR, "ml_models", "layer2")
-MODELS_PATTERN_DIR = os.path.join(BASE_DIR, "ml_models", "xgboost_pattern2")
-MODELS_UNIFIED_DIR = os.path.join(BASE_DIR, "ml_models", "Unified_Models_V1")
-MODELS_SNIPER_DIR = os.path.join(BASE_DIR, "ml_models", "guard_v2") 
-MODELS_HYDRA_DIR = os.path.join(BASE_DIR, "ml_models", "guard_v1")
-MODEL_V2_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V2_Production.json")
-MODEL_V3_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Production.json")
-MODEL_V3_FEAT = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Features.json")
+try:
+    from ml_engine.processor import MLProcessor, SystemLimits 
+    from ml_engine.data_manager import DataManager
+    from learning_hub.adaptive_hub import StrategyDNA, AdaptiveHub
+    from r2 import R2Service
+    import ccxt.async_support as ccxt 
+    import xgboost as xgb 
+except ImportError:
+    pass
 
-# ============================================================
-# 🎛️ SYSTEM LIMITS & THRESHOLDS (Dynamic DNA Container)
-# ============================================================
-class SystemLimits:
-    """
-    GEM-Architect: The Dynamic Constitution.
-    يتم تحديث هذه القيم آلياً بواسطة AdaptiveHub بناءً على حالة السوق (Bull/Bear/etc).
-    """
-    
-    # --- Layer 1 (Data Manager Control) ---
-    L1_MIN_AFFINITY_SCORE = 15.0  # سيتم الكتابة عليها من الـ DNA
-    
-    # --- Layer 2 Weights (Dynamic) ---
-    # هذه الأوزان تتغير حسب أداء النماذج (Tactical Loop) وحالة السوق
-    L2_WEIGHT_TITAN    = 0.40
-    L2_WEIGHT_PATTERNS = 0.30
-    L2_WEIGHT_MC       = 0.10
-    # (Hydra/Sniper قد يساهمون في L2 أو L4 حسب التصميم)
-
-    # إعدادات الأنماط (تتغير حسب الاستراتيجية)
-    PATTERN_TF_WEIGHTS = {'15m': 0.40, '1h': 0.30, '5m': 0.20, '4h': 0.10, '1d': 0.00}
-    PATTERN_THRESH_BULLISH = 0.60
-    PATTERN_THRESH_BEARISH = 0.40
-
-    # --- Layer 3 (Oracle) ---
-    L3_CONFIDENCE_THRESHOLD = 0.65
-    L3_WHALE_IMPACT_MAX = 0.10
-    L3_NEWS_IMPACT_MAX  = 0.05
-    L3_MC_ADVANCED_MAX  = 0.10
-
-    # --- Layer 4 (Sniper & Execution) ---
-    L4_ENTRY_THRESHOLD  = 0.40
-    # أوزان داخلية لـ Sniper (ML vs OrderBook)
-    L4_WEIGHT_ML        = 0.60
-    L4_WEIGHT_OB        = 0.40
-    # نسبة الجدار المسموح بها (تتغير جذرياً بين Bull و Bear)
-    L4_OB_WALL_RATIO    = 0.40
-
-    # --- Layer 0: Hydra & Guardian Thresholds ---
-    HYDRA_CRASH_THRESH      = 0.60
-    HYDRA_GIVEBACK_THRESH   = 0.70
-    HYDRA_STAGNATION_THRESH = 0.50
-
-    # Legacy Guard Thresholds
-    LEGACY_V2_PANIC_THRESH = 0.95
-    LEGACY_V3_HARD_THRESH  = 0.95
-    LEGACY_V3_SOFT_THRESH  = 0.85
-    LEGACY_V3_ULTRA_THRESH = 0.98
-
-    @classmethod
-    def to_dict(cls) -> Dict[str, Any]:
-        return {k: v for k, v in cls.__dict__.items() if not k.startswith('__') and not callable(v)}
-
-    @classmethod
-    def update_from_dict(cls, config: Dict[str, Any]):
-        """تحديث القيم من AdaptiveHub"""
-        if not config: return
-        for k, v in config.items():
-            if hasattr(cls, k): 
-                setattr(cls, k, v)
-        # print(f"🔄 [SystemLimits] Updated. TitanW={cls.L2_WEIGHT_TITAN:.2f}, WallRatio={cls.L4_OB_WALL_RATIO}")
+logging.getLogger('ml_engine').setLevel(logging.WARNING)
+CACHE_DIR = "backtest_real_scores"
 
-# ============================================================
-# 🧠 MLProcessor Class
-# ============================================================
-class MLProcessor:
-    def __init__(self, data_manager=None):
-        self.data_manager = data_manager
-        self.initialized = False
+class HeavyDutyBacktester:
+    def __init__(self, data_manager, processor):
+        self.dm = data_manager
+        self.proc = processor
         
-        self.titan = TitanEngine(model_dir=MODELS_L2_DIR) if TitanEngine else None
-        self.pattern_engine = ChartPatternAnalyzer(models_dir=MODELS_PATTERN_DIR) if ChartPatternAnalyzer else None
-        self.mc_analyzer = MonteCarloEngine() if MonteCarloEngine else None
-        self.oracle = OracleEngine(model_dir=MODELS_UNIFIED_DIR) if OracleEngine else None
-        self.sniper = SniperEngine(models_dir=MODELS_SNIPER_DIR) if SniperEngine else None
+        # 🎛️ GRID DENSITY CONTROL
+        # 3 = Low (243 Scenarios) - Fast
+        # 4 = Med (1024 Scenarios) - Balanced
+        # 5 = High (3125 Scenarios) - Deep Search
+        self.GRID_DENSITY = 3  
         
-        self.guardian_hydra = None
-        if GuardianHydra:
-            self.guardian_hydra = GuardianHydra(model_dir=MODELS_HYDRA_DIR)
-
-        self.guardian_legacy = None
-        if HybridDeepSteward:
-            self.guardian_legacy = HybridDeepSteward(
-                v2_model_path=MODEL_V2_PATH,
-                v3_model_path=MODEL_V3_PATH,
-                v3_features_map_path=MODEL_V3_FEAT
-            )
-
-        print(f"🧠 [MLProcessor V36.0] Cybernetic Control Active.")
-
-    async def initialize(self):
-        if self.initialized: return
-        print("⚙️ [Processor] Initializing Neural Grid...")
-        try:
-            tasks = []
-            if self.titan: tasks.append(self.titan.initialize())
-            
-            if self.pattern_engine: 
-                # التكوين الأولي (سيتم تحديثه لاحقاً ديناميكياً)
-                self.pattern_engine.configure_thresholds(
-                    weights=SystemLimits.PATTERN_TF_WEIGHTS, 
-                    bull_thresh=SystemLimits.PATTERN_THRESH_BULLISH, 
-                    bear_thresh=SystemLimits.PATTERN_THRESH_BEARISH
-                )
-                tasks.append(self.pattern_engine.initialize())
-            
-            if self.oracle: 
-                if hasattr(self.oracle, 'set_threshold'): 
-                    self.oracle.set_threshold(SystemLimits.L3_CONFIDENCE_THRESHOLD)
-                tasks.append(self.oracle.initialize())
+        self.INITIAL_CAPITAL = 10.0
+        self.TRADING_FEES = 0.001 
+        self.MAX_SLOTS = 4         
+        
+        self.TARGET_COINS = [
+            'SOL/USDT', 'XRP/USDT', 'DOGE/USDT'
+        ]
+        
+        self.force_start_date = None 
+        self.force_end_date = None   
+        
+        if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
+        print(f"🧪 [Backtest V115.0] Grid Density: {self.GRID_DENSITY} | Full Stack Optimization.")
+
+    def set_date_range(self, start_str, end_str):
+        self.force_start_date = start_str
+        self.force_end_date = end_str
+
+    # ==============================================================
+    # ⚡ FAST DATA DOWNLOADER
+    # ==============================================================
+    async def _fetch_all_data_fast(self, sym, start_ms, end_ms):
+        print(f"   ⚡ [Network] Downloading {sym}...", flush=True)
+        limit = 1000
+        duration_per_batch = limit * 60 * 1000
+        tasks = []
+        current = start_ms
+        while current < end_ms:
+            tasks.append(current)
+            current += duration_per_batch
+        all_candles = []
+        sem = asyncio.Semaphore(10) 
+
+        async def _fetch_batch(timestamp):
+            async with sem:
+                for _ in range(3): 
+                    try:
+                        return await self.dm.exchange.fetch_ohlcv(sym, '1m', since=timestamp, limit=limit)
+                    except: await asyncio.sleep(1)
+                return []
+
+        chunk_size = 20
+        for i in range(0, len(tasks), chunk_size):
+            chunk_tasks = tasks[i:i + chunk_size]
+            futures = [_fetch_batch(ts) for ts in chunk_tasks]
+            results = await asyncio.gather(*futures)
+            for res in results:
+                if res: all_candles.extend(res)
+
+        if not all_candles: return None
+        filtered = [c for c in all_candles if c[0] >= start_ms and c[0] <= end_ms]
+        seen = set(); unique_candles = []
+        for c in filtered:
+            if c[0] not in seen:
+                unique_candles.append(c)
+                seen.add(c[0])
+        unique_candles.sort(key=lambda x: x[0])
+        print(f"     ✅ Downloaded {len(unique_candles)} candles.", flush=True)
+        return unique_candles
+
+    # ==============================================================
+    # 🏎️ VECTORIZED INDICATORS
+    # ==============================================================
+    def _calculate_indicators_vectorized(self, df, timeframe='1m'):
+        df['close'] = df['close'].astype(float)
+        df['high'] = df['high'].astype(float)
+        df['low'] = df['low'].astype(float)
+        df['volume'] = df['volume'].astype(float)
+        df['open'] = df['open'].astype(float)
+        
+        df['rsi'] = ta.rsi(df['close'], length=14)
+        df['ema20'] = ta.ema(df['close'], length=20)
+        df['ema50'] = ta.ema(df['close'], length=50)
+        df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
+        
+        if timeframe == '1m':
+            sma20 = df['close'].rolling(20).mean()
+            std20 = df['close'].rolling(20).std()
+            df['bb_width'] = ((sma20 + 2*std20) - (sma20 - 2*std20)) / sma20
+            df['vol_ma50'] = df['volume'].rolling(50).mean()
+            df['rel_vol'] = df['volume'] / (df['vol_ma50'] + 1e-9)
+
+        df['slope'] = ta.slope(df['close'], length=7)
+        vol_mean = df['volume'].rolling(20).mean()
+        vol_std = df['volume'].rolling(20).std()
+        df['vol_z'] = (df['volume'] - vol_mean) / (vol_std + 1e-9)
+        df['atr_pct'] = df['atr'] / df['close']
+
+        if timeframe == '1m':
+            df['ret'] = df['close'].pct_change()
+            df['dollar_vol'] = df['close'] * df['volume']
+            df['amihud'] = (df['ret'].abs() / df['dollar_vol'].replace(0, np.nan)).fillna(0)
+            dp = df['close'].diff()
+            roll_cov = dp.rolling(64).cov(dp.shift(1))
+            df['roll_spread'] = (2 * np.sqrt(np.maximum(0, -roll_cov))).fillna(0)
+            sign = np.sign(df['close'].diff()).fillna(0)
+            df['signed_vol'] = sign * df['volume']
+            df['ofi'] = df['signed_vol'].rolling(30).sum().fillna(0)
+            buy_vol = (sign > 0) * df['volume']
+            sell_vol = (sign < 0) * df['volume']
+            imb = (buy_vol.rolling(60).sum() - sell_vol.rolling(60).sum()).abs()
+            tot = df['volume'].rolling(60).sum()
+            df['vpin'] = (imb / tot.replace(0, np.nan)).fillna(0)
+            vwap = (df['close'] * df['volume']).rolling(20).sum() / df['volume'].rolling(20).sum()
+            df['vwap_dev'] = (df['close'] - vwap).fillna(0)
+            df['rv_gk'] = (np.log(df['high'] / df['low'])**2) / 2 - (2 * np.log(2) - 1) * (np.log(df['close'] / df['open'])**2)
+            df['return_1m'] = df['ret']
+            df['return_5m'] = df['close'].pct_change(5)
+            df['return_15m'] = df['close'].pct_change(15)
+            r = df['volume'].rolling(500).mean()
+            s = df['volume'].rolling(500).std()
+            df['vol_zscore_50'] = ((df['volume'] - r) / s).fillna(0)
+
+        df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
+        roll_max = df['high'].rolling(50).max()
+        roll_min = df['low'].rolling(50).min()
+        diff = (roll_max - roll_min).replace(0, 1e-9)
+        df['fib_pos'] = (df['close'] - roll_min) / diff
+        df['trend_slope'] = (df['ema20'] - df['ema20'].shift(5)) / df['ema20'].shift(5)
+        df['volatility'] = df['atr'] / df['close']
+        fib618 = roll_max - (diff * 0.382)
+        df['dist_fib618'] = (df['close'] - fib618) / df['close']
+        df['dist_ema50'] = (df['close'] - df['ema50']) / df['close']
+        df['ema200'] = ta.ema(df['close'], length=200)
+        df['dist_ema200'] = (df['close'] - df['ema200']) / df['close']
+        
+        # Lags for V2
+        if timeframe == '1m':
+            for lag in [1, 2, 3, 5, 10, 20]:
+                df[f'log_ret_lag_{lag}'] = df['log_ret'].shift(lag).fillna(0)
+                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
+
+    # ==============================================================
+    # 🧠 CPU PROCESSING (PRE-INFERENCE OPTIMIZED)
+    # ==============================================================
+    async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
+        safe_sym = sym.replace('/', '_')
+        period_suffix = f"{start_ms}_{end_ms}"
+        scores_file = f"{CACHE_DIR}/{safe_sym}_{period_suffix}_scores.pkl"
+
+        if os.path.exists(scores_file):
+             print(f"   📂 [{sym}] Data Exists -> Skipping.")
+             return
+
+        print(f"   ⚙️ [CPU] Analyzing {sym} (Global Pre-Inference)...", flush=True)
+        t0 = time.time()
+
+        df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        df_1m['datetime'] = pd.to_datetime(df_1m['timestamp'], unit='ms')
+        df_1m.set_index('datetime', inplace=True)
+        df_1m = df_1m.sort_index()
+
+        frames = {}
+        agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
+        
+        # 1. Calc 1m
+        frames['1m'] = self._calculate_indicators_vectorized(df_1m.copy(), timeframe='1m')
+        frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
+        fast_1m = {col: frames['1m'][col].values for col in frames['1m'].columns}
+        
+        # 2. Calc 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()
+            resampled = self._calculate_indicators_vectorized(resampled, timeframe=tf_str)
+            resampled['timestamp'] = resampled.index.astype(np.int64) // 10**6
+            frames[tf_str] = resampled
+            numpy_htf[tf_str] = {col: resampled[col].values for col in resampled.columns}
+
+        # 3. Global Index Maps
+        map_1m_to_1h = np.searchsorted(numpy_htf['1h']['timestamp'], fast_1m['timestamp'])
+        map_1m_to_5m = np.searchsorted(numpy_htf['5m']['timestamp'], fast_1m['timestamp'])
+        map_1m_to_15m = np.searchsorted(numpy_htf['15m']['timestamp'], fast_1m['timestamp'])
+        
+        # Clip
+        max_idx_1h = len(numpy_htf['1h']['timestamp']) - 1
+        max_idx_5m = len(numpy_htf['5m']['timestamp']) - 1
+        max_idx_15m = len(numpy_htf['15m']['timestamp']) - 1
+        
+        map_1m_to_1h = np.clip(map_1m_to_1h, 0, max_idx_1h)
+        map_1m_to_5m = np.clip(map_1m_to_5m, 0, max_idx_5m)
+        map_1m_to_15m = np.clip(map_1m_to_15m, 0, max_idx_15m)
+
+        # 4. Load Models
+        hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
+        hydra_cols = getattr(self.proc.guardian_hydra, 'feature_cols', []) if self.proc.guardian_hydra else []
+        legacy_v2 = getattr(self.proc.guardian_legacy, 'model_v2', None)
+        
+        # 5. 🔥 PRE-CALCULATE LEGACY V2 (GLOBAL) 🔥
+        global_v2_probs = np.zeros(len(fast_1m['close']))
+        
+        if legacy_v2:
+            print(f"     🚀 Pre-calculating Legacy V2 for entire history...", flush=True)
+            try:
+                # 1m Feats
+                l_log = fast_1m['log_ret']
+                l_rsi = fast_1m['rsi'] / 100.0
+                l_fib = fast_1m['fib_pos']
+                l_vol = fast_1m['volatility']
+                
+                # HTF Feats Mapped to 1m
+                l5_log = numpy_htf['5m']['log_ret'][map_1m_to_5m]
+                l5_rsi = numpy_htf['5m']['rsi'][map_1m_to_5m] / 100.0
+                l5_fib = numpy_htf['5m']['fib_pos'][map_1m_to_5m]
+                l5_trd = numpy_htf['5m']['trend_slope'][map_1m_to_5m]
+                
+                l15_log = numpy_htf['15m']['log_ret'][map_1m_to_15m]
+                l15_rsi = numpy_htf['15m']['rsi'][map_1m_to_15m] / 100.0
+                l15_fib618 = numpy_htf['15m']['dist_fib618'][map_1m_to_15m]
+                l15_trd = numpy_htf['15m']['trend_slope'][map_1m_to_15m]
+                
+                # Lags
+                lag_cols = []
+                for lag in [1, 2, 3, 5, 10, 20]:
+                    lag_cols.append(fast_1m[f'log_ret_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'rsi_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'fib_pos_lag_{lag}'])
+                    lag_cols.append(fast_1m[f'volatility_lag_{lag}'])
+                
+                # Huge Matrix
+                X_GLOBAL_V2 = np.column_stack([
+                    l_log, l_rsi, l_fib, l_vol,
+                    l5_log, l5_rsi, l5_fib, l5_trd,
+                    l15_log, l15_rsi, l15_fib618, l15_trd,
+                    *lag_cols
+                ])
+                
+                # Predict All in One Go
+                dm_glob = xgb.DMatrix(X_GLOBAL_V2)
+                preds_glob = legacy_v2.predict(dm_glob)
+                global_v2_probs = preds_glob[:, 2] if len(preds_glob.shape) > 1 else preds_glob
+                
+            except Exception as e: print(f"V2 Error: {e}")
+
+        # 6. 🔥 PRE-ASSEMBLE HYDRA STATIC (GLOBAL) 🔥
+        global_hydra_static = None
+        if hydra_models:
+            print(f"     🚀 Pre-assembling Hydra features...", flush=True)
+            try:
+                # Map columns that don't depend on PnL
+                h_rsi_1m = fast_1m['rsi']
+                h_rsi_5m = numpy_htf['5m']['rsi'][map_1m_to_5m]
+                h_rsi_15m = numpy_htf['15m']['rsi'][map_1m_to_15m]
+                h_bb = fast_1m['bb_width']
+                h_vol = fast_1m['rel_vol']
+                h_atr = fast_1m['atr']
+                h_close = fast_1m['close']
+                
+                global_hydra_static = np.column_stack([h_rsi_1m, h_rsi_5m, h_rsi_15m, h_bb, h_vol, h_atr, h_close])
+            except: pass
+
+        # 7. Candidate Filtering
+        df_1h = frames['1h'].reindex(frames['5m'].index, method='ffill')
+        df_5m = frames['5m'].copy()
+        is_valid = (df_1h['rsi'] <= 70) 
+        valid_indices = df_5m[is_valid].index
+        start_dt = df_1m.index[0] + pd.Timedelta(minutes=500)
+        final_valid_indices = [t for t in valid_indices if t >= start_dt]
+        
+        total_signals = len(final_valid_indices)
+        print(f"     🎯 Candidates: {total_signals}. Running Models...", flush=True)
+
+        oracle_dir_model = getattr(self.proc.oracle, 'model_direction', None)
+        oracle_cols = getattr(self.proc.oracle, 'feature_cols', [])
+        sniper_models = getattr(self.proc.sniper, 'models', [])
+        sniper_cols = getattr(self.proc.sniper, 'feature_names', [])
+
+        ai_results = []
+        
+        # Pre-allocate Hydra time vector (0 to 240)
+        time_vec = np.arange(1, 241)
+
+        # --- MAIN LOOP (Optimized Lookups) ---
+        for i, current_time in enumerate(final_valid_indices):
+            ts_val = int(current_time.timestamp() * 1000)
+            idx_1m = np.searchsorted(fast_1m['timestamp'], ts_val)
             
-            if self.sniper: 
-                # التكوين الأولي
-                if hasattr(self.sniper, 'configure_settings'): 
-                    self.sniper.configure_settings(
-                        threshold=SystemLimits.L4_ENTRY_THRESHOLD, 
-                        wall_ratio=SystemLimits.L4_OB_WALL_RATIO,
-                        w_ml=SystemLimits.L4_WEIGHT_ML,
-                        w_ob=SystemLimits.L4_WEIGHT_OB
-                    )
-                tasks.append(self.sniper.initialize())
+            if idx_1m < 500 or idx_1m >= len(fast_1m['close']) - 245: continue
             
-            if tasks: await asyncio.gather(*tasks)
+            idx_1h = map_1m_to_1h[idx_1m]
+            idx_15m = map_1m_to_15m[idx_1m]
+            idx_4h = np.searchsorted(numpy_htf['4h']['timestamp'], ts_val)
+            if idx_4h >= len(numpy_htf['4h']['close']): idx_4h = len(numpy_htf['4h']['close']) - 1
+
+            # === Oracle (Single Call) ===
+            oracle_conf = 0.5
+            if oracle_dir_model:
+                o_vec = []
+                for col in oracle_cols:
+                    val = 0.0
+                    if col.startswith('1h_'): val = numpy_htf['1h'].get(col[3:], [0])[idx_1h]
+                    elif col.startswith('15m_'): val = numpy_htf['15m'].get(col[4:], [0])[idx_15m]
+                    elif col.startswith('4h_'): val = numpy_htf['4h'].get(col[3:], [0])[idx_4h]
+                    elif col == 'sim_titan_score': val = 0.6
+                    elif col == 'sim_mc_score': val = 0.5
+                    elif col == 'sim_pattern_score': val = 0.5
+                    o_vec.append(val)
+                try:
+                    o_pred = oracle_dir_model.predict(np.array(o_vec).reshape(1, -1))[0]
+                    oracle_conf = float(o_pred[0]) if isinstance(o_pred, (list, np.ndarray)) else float(o_pred)
+                    if oracle_conf < 0.5: oracle_conf = 1 - oracle_conf 
+                except: pass
 
-            if self.guardian_hydra: 
-                self.guardian_hydra.initialize()
-                print("   🛡️ [Guard 1] Hydra X-Ray: Active")
+            # === Sniper (Single Call) ===
+            sniper_score = 0.5
+            if sniper_models:
+                s_vec = []
+                for col in sniper_cols:
+                    if col in fast_1m: s_vec.append(fast_1m[col][idx_1m])
+                    elif col == 'L_score': s_vec.append(fast_1m.get('vol_zscore_50', [0])[idx_1m])
+                    else: s_vec.append(0.0)
+                try:
+                    s_preds = [m.predict(np.array(s_vec).reshape(1, -1))[0] for m in sniper_models]
+                    sniper_score = np.mean(s_preds)
+                except: pass
+
+            # === RISK SIMULATION (ULTRA FAST) ===
+            start_idx = idx_1m + 1
+            end_idx = start_idx + 240
             
-            if self.guardian_legacy:
-                if asyncio.iscoroutinefunction(self.guardian_legacy.initialize):
-                    await self.guardian_legacy.initialize()
-                else:
-                    self.guardian_legacy.initialize()
+            # 1. LEGACY V2 (Instant Lookup)
+            max_legacy_v2 = 0.0; legacy_panic_time = 0
+            if legacy_v2:
+                # Just slice the pre-calculated array!
+                probs_slice = global_v2_probs[start_idx:end_idx]
+                max_legacy_v2 = np.max(probs_slice)
+                panic_indices = np.where(probs_slice > 0.8)[0]
+                if len(panic_indices) > 0:
+                    legacy_panic_time = int(fast_1m['timestamp'][start_idx + panic_indices[0]])
+
+            # 2. HYDRA (Semi-Vectorized)
+            max_hydra_crash = 0.0; hydra_crash_time = 0
+            if hydra_models and global_hydra_static is not None:
+                # Slice Static Feats
+                sl_static = global_hydra_static[start_idx:end_idx] 
                 
-                # تطبيق العتبات المبدئية
-                self.guardian_legacy.configure_thresholds(
-                    v2_panic=SystemLimits.LEGACY_V2_PANIC_THRESH,
-                    v3_hard=SystemLimits.LEGACY_V3_HARD_THRESH,
-                    v3_soft=SystemLimits.LEGACY_V3_SOFT_THRESH,
-                    v3_ultra=SystemLimits.LEGACY_V3_ULTRA_THRESH
-                )
-                print(f"   🛡️ [Guard 2] Legacy Steward: Active")
-
-            self.initialized = True
-            print("✅ [Processor] All Systems Operational.")
-            
-        except Exception as e:
-            print(f"❌ [Processor FATAL] Init failed: {e}")
-            traceback.print_exc()
-
-    async def process_compound_signal(self, raw_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        L2 Processing:
-        هنا يتم دمج الدرجات بناءً على الأوزان الديناميكية الحالية (SystemLimits).
-        """
-        if not self.initialized: await self.initialize()
+                entry_price = fast_1m['close'][idx_1m]
+                sl_close = sl_static[:, 6]
+                sl_atr = sl_static[:, 5]
+                
+                # Calc Dynamic Feats
+                sl_dist = 1.5 * sl_atr
+                sl_dist = np.where(sl_dist > 0, sl_dist, entry_price * 0.015)
+                
+                sl_pnl = sl_close - entry_price
+                sl_norm_pnl = sl_pnl / sl_dist
+                
+                sl_cum_max = np.maximum.accumulate(sl_close)
+                sl_cum_max = np.maximum(sl_cum_max, entry_price)
+                sl_max_pnl_r = (sl_cum_max - entry_price) / sl_dist
+                
+                sl_atr_pct = sl_atr / sl_close
+                
+                zeros = np.zeros(240)
+                oracle_arr = np.full(240, oracle_conf)
+                l2_arr = np.full(240, 0.7)
+                target_arr = np.full(240, 3.0)
+                
+                X_hydra = np.column_stack([
+                    sl_static[:, 0], sl_static[:, 1], sl_static[:, 2], # RSIs
+                    sl_static[:, 3], sl_static[:, 4], # BB, Vol
+                    zeros, # dist_ema
+                    sl_atr_pct, sl_norm_pnl, sl_max_pnl_r,
+                    zeros, zeros, # dists
+                    time_vec, # time
+                    zeros, oracle_arr, l2_arr, target_arr
+                ])
+                
+                try:
+                    probs_crash = hydra_models['crash'].predict_proba(X_hydra)[:, 1]
+                    max_hydra_crash = np.max(probs_crash)
+                    crash_indices = np.where(probs_crash > 0.6)[0]
+                    if len(crash_indices) > 0:
+                        hydra_crash_time = int(fast_1m['timestamp'][start_idx + crash_indices[0]])
+                except: pass
+
+            ai_results.append({
+                'timestamp': ts_val, 'symbol': sym, 'close': entry_price,
+                'real_titan': 0.6, # Placeholder for real Titan score if available
+                'oracle_conf': oracle_conf, 
+                'sniper_score': sniper_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,
+                'signal_type': 'BREAKOUT',
+                'l1_score': 50.0
+            })
         
-        symbol = raw_data.get('symbol')
-        ohlcv_data = raw_data.get('ohlcv')
-        current_price = raw_data.get('current_price', 0.0)
+        dt = time.time() - t0
+        if ai_results:
+            pd.DataFrame(ai_results).to_pickle(scores_file)
+            print(f"   ✅ [{sym}] Completed {len(ai_results)} signals in {dt:.2f} seconds.", flush=True)
+        else:
+            print(f"   ⚠️ [{sym}] No valid signals. Time: {dt:.2f}s", flush=True)
+            
+        del frames, fast_1m, numpy_htf, global_v2_probs, global_hydra_static
+        gc.collect()
+
+    # ==============================================================
+    # PHASE 1 & 2 (Enhanced with Consensus Analytics)
+    # ==============================================================
+    async def generate_truth_data(self):
+        if self.force_start_date and self.force_end_date:
+            dt_start = datetime.strptime(self.force_start_date, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+            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] Processing Era: {self.force_start_date} -> {self.force_end_date}")
+        else: return 
         
-        if not symbol or not ohlcv_data: return None
+        for sym in self.TARGET_COINS:
+            try:
+                candles = await self._fetch_all_data_fast(sym, start_time_ms, end_time_ms)
+                if candles: await self._process_data_in_memory(sym, candles, start_time_ms, end_time_ms)
+            except Exception as e: print(f"   ❌ SKIP {sym}: {e}", flush=True)
+            gc.collect()
+
+    @staticmethod
+    def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
+        results = []
+        all_data = []
+        for fp in scores_files:
+            try: 
+                df = pd.read_pickle(fp)
+                if not df.empty: all_data.append(df)
+            except: pass
+        if not all_data: return []
+        global_df = pd.concat(all_data)
+        global_df.sort_values('timestamp', inplace=True)
+        grouped_by_time = global_df.groupby('timestamp')
         
-        try:
-            # 1. Titan Engine
-            score_titan = 0.5
-            titan_res = {}
-            if self.titan:
-                titan_res = await asyncio.to_thread(self.titan.predict, ohlcv_data)
-                score_titan = titan_res.get('score', 0.5)
-
-            # 2. Pattern Engine (Inject Dynamic Config First)
-            score_patterns = 0.5
-            pattern_res = {}
-            pattern_name = "Neutral"
-            if self.pattern_engine:
-                # تحديث التكوين قبل التحليل لضمان استخدام أحدث أوزان الاستراتيجية
-                self.pattern_engine.configure_thresholds(
-                    weights=SystemLimits.PATTERN_TF_WEIGHTS,
-                    bull_thresh=SystemLimits.PATTERN_THRESH_BULLISH,
-                    bear_thresh=SystemLimits.PATTERN_THRESH_BEARISH
-                )
-                pattern_res = await self.pattern_engine.detect_chart_patterns(ohlcv_data)
-                score_patterns = pattern_res.get('pattern_confidence', 0.5)
-                pattern_name = pattern_res.get('pattern_detected', 'Neutral')
-
-            # 3. Monte Carlo (Light)
-            mc_score = 0.5
-            if self.mc_analyzer and '1h' in ohlcv_data:
-                closes = [c[4] for c in ohlcv_data['1h']]
-                raw_mc = self.mc_analyzer.run_light_check(closes)
-                mc_score = 0.5 + (raw_mc * 5.0)
-                mc_score = max(0.0, min(1.0, mc_score))
-
-            # 4. Hybrid Calculation (Using Dynamic Weights from SystemLimits)
-            # هذه الأوزان يتم تحديثها بواسطة AdaptiveHub
-            w_titan = SystemLimits.L2_WEIGHT_TITAN
-            w_patt = SystemLimits.L2_WEIGHT_PATTERNS
-            w_mc = SystemLimits.L2_WEIGHT_MC
+        for config in combinations_batch:
+            wallet = { "balance": initial_capital, "allocated": 0.0, "positions": {}, "trades_history": [] }
             
-            # تطبيع الأوزان (لضمان أن مجموعها 1.0 تقريباً)
-            total_w = w_titan + w_patt + w_mc
-            if total_w <= 0: total_w = 1.0
+            # Param Extraction
+            oracle_thresh = config.get('oracle_thresh', 0.6)
+            sniper_thresh = config.get('sniper_thresh', 0.4)
+            hydra_thresh = config['hydra_thresh']
+            # Titan & Pattern weights are in config but not used for hard filtering here, 
+            # they are optimized for the DNA output.
             
-            hybrid_score = ((score_titan * w_titan) + (score_patterns * w_patt) + (mc_score * w_mc)) / total_w
+            peak_balance = initial_capital; max_drawdown = 0.0
+
+            for ts, group in grouped_by_time:
+                active = list(wallet["positions"].keys())
+                current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
+                for sym in active:
+                    if sym in current_prices:
+                        curr = current_prices[sym]
+                        pos = wallet["positions"][sym]
+                        h_risk = pos.get('risk_hydra_crash', 0)
+                        h_time = pos.get('time_hydra_crash', 0)
+                        is_crash = (h_risk > hydra_thresh) and (h_time > 0) and (ts >= h_time)
+                        pnl = (curr - pos['entry']) / pos['entry']
+                        if is_crash or pnl > 0.04 or pnl < -0.02:
+                            wallet['balance'] += pos['size'] * (1 + pnl - (fees_pct*2))
+                            wallet['allocated'] -= pos['size']
+                            # Add consensus data to history
+                            wallet['trades_history'].append({
+                                'pnl': pnl, 
+                                'consensus_score': pos['consensus_score']
+                            })
+                            del wallet['positions'][sym]
+
+                total_eq = wallet['balance'] + wallet['allocated']
+                if total_eq > peak_balance: peak_balance = total_eq
+                dd = (peak_balance - total_eq) / peak_balance
+                if dd > max_drawdown: max_drawdown = dd
+
+                if len(wallet['positions']) < max_slots:
+                    for _, row in group.iterrows():
+                        if row['symbol'] in wallet['positions']: continue
+                        
+                        # Hard Filters
+                        if row['oracle_conf'] < oracle_thresh: continue
+                        if row['sniper_score'] < sniper_thresh: continue
+                        
+                        # Consensus Calculation (Normalized)
+                        # Titan (default 0.6) + Oracle + Sniper
+                        cons_score = (row['real_titan'] + row['oracle_conf'] + row['sniper_score']) / 3.0
+
+                        size = 10.0
+                        if wallet['balance'] >= size:
+                            wallet['positions'][row['symbol']] = {
+                                'entry': row['close'], 'size': size,
+                                'risk_hydra_crash': row['risk_hydra_crash'],
+                                'time_hydra_crash': row['time_hydra_crash'],
+                                'consensus_score': cons_score
+                            }
+                            wallet['balance'] -= size
+                            wallet['allocated'] += size
             
-            return {
-                'symbol': symbol, 
-                'current_price': current_price, 
-                'enhanced_final_score': hybrid_score, 
-                'titan_score': score_titan, 
-                'patterns_score': score_patterns, 
-                'mc_score': mc_score, 
-                'components': {
-                    'titan_score': score_titan, 
-                    'patterns_score': score_patterns, 
-                    'mc_score': mc_score
-                }, 
-                'pattern_name': pattern_name, 
-                'ohlcv': ohlcv_data, 
-                'titan_details': titan_res, 
-                'pattern_details': pattern_res.get('details', {})
-            }
-        except Exception as e: 
-            print(f"❌ [Processor] Error processing {symbol}: {e}")
-            return None
-
-    async def consult_oracle(self, symbol_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        L3 Processing:
-        Oracle يستخدم العتبة الحالية من SystemLimits.
-        """
-        if not self.initialized: await self.initialize()
-        
-        if self.oracle:
-            # تحديث العتبة ديناميكياً
-            if hasattr(self.oracle, 'set_threshold'):
-                self.oracle.set_threshold(SystemLimits.L3_CONFIDENCE_THRESHOLD)
-                
-            decision = await self.oracle.predict(symbol_data)
-            conf = decision.get('confidence', 0.0)
+            final_bal = wallet['balance'] + wallet['allocated']
+            net_profit = final_bal - initial_capital
+            trades = wallet['trades_history']
+            total_t = len(trades)
+            win_count = len([t for t in trades if t['pnl'] > 0])
+            loss_count = len([t for t in trades if t['pnl'] <= 0])
+            win_rate = (win_count / total_t * 100) if total_t > 0 else 0
+            max_win = max([t['pnl'] for t in trades]) if trades else 0
+            max_loss = min([t['pnl'] for t in trades]) if trades else 0
             
-            # طبقة أمان إضافية (Redundant Safety)
-            if decision.get('action') in ['WATCH', 'BUY'] and conf < SystemLimits.L3_CONFIDENCE_THRESHOLD:
-                decision['action'] = 'WAIT'
-                decision['reason'] = f"Processor Veto: Conf {conf:.2f} < Limit {SystemLimits.L3_CONFIDENCE_THRESHOLD}"
+            # 1. Fix: Calculate Streaks
+            max_win_streak = 0; max_loss_streak = 0; curr_w = 0; curr_l = 0
+            for t in trades:
+                if t['pnl'] > 0:
+                    curr_w += 1; curr_l = 0
+                    if curr_w > max_win_streak: max_win_streak = curr_w
+                else:
+                    curr_l += 1; curr_w = 0
+                    if curr_l > max_loss_streak: max_loss_streak = curr_l
+
+            # 2. Fix: Consensus Analytics
+            high_cons_trades = [t for t in trades if t['consensus_score'] > 0.65]
+            low_cons_trades = [t for t in trades if t['consensus_score'] <= 0.65]
             
-            return decision
-        return {'action': 'WAIT', 'reason': 'Oracle Engine Missing'}
-
-    async def check_sniper_entry(self, ohlcv_1m_data: List, order_book_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        L4 Processing:
-        Sniper يستلم إعدادات دفتر الطلبات (DNA) قبل اتخاذ القرار.
-        """
-        if not self.initialized: await self.initialize()
-        
-        if self.sniper: 
-            # ✅ الحقن الديناميكي لإعدادات Sniper قبل التنفيذ
-            if hasattr(self.sniper, 'configure_settings'):
-                self.sniper.configure_settings(
-                    threshold=SystemLimits.L4_ENTRY_THRESHOLD,
-                    wall_ratio=SystemLimits.L4_OB_WALL_RATIO,
-                    w_ml=SystemLimits.L4_WEIGHT_ML,
-                    w_ob=SystemLimits.L4_WEIGHT_OB
-                )
+            hc_count = len(high_cons_trades)
+            hc_wins = len([t for t in high_cons_trades if t['pnl'] > 0])
+            hc_win_rate = (hc_wins/hc_count*100) if hc_count > 0 else 0
+            hc_avg_pnl = (sum([t['pnl'] for t in high_cons_trades]) / hc_count * 100) if hc_count > 0 else 0
             
-            return await self.sniper.check_entry_signal_async(ohlcv_1m_data, order_book_data)
+            lc_count = len(low_cons_trades)
+            lc_wins = len([t for t in low_cons_trades if t['pnl'] > 0])
+            lc_win_rate = (lc_wins/lc_count*100) if lc_count > 0 else 0
             
-        return {'signal': 'WAIT', 'reason': 'Sniper Engine Missing'}
-
-    def consult_dual_guardians(self, symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context, order_book_snapshot=None):
-        """
-        L0 Guardians:
-        الحراس يستخدمون العتبات الديناميكية (Panic Thresholds) التي قد تختلف بين Bull و Bear.
-        """
-        response = {'action': 'HOLD', 'detailed_log': '', 'probs': {}}
-        
-        # 1. Hydra
-        hydra_result = {'action': 'HOLD', 'reason': 'Disabled', 'probs': {}}
-        if self.guardian_hydra and self.guardian_hydra.initialized:
-            hydra_result = self.guardian_hydra.analyze_position(symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context)
-            h_probs = hydra_result.get('probs', {})
-            p_crash = h_probs.get('crash', 0.0)
-            p_giveback = h_probs.get('giveback', 0.0)
+            agreement_rate = (hc_count / total_t * 100) if total_t > 0 else 0.0
+
+            results.append({
+                'config': config, 'final_balance': final_bal, 'net_profit': net_profit,
+                'total_trades': total_t, 'win_count': win_count, 'loss_count': loss_count,
+                'win_rate': win_rate, 'max_single_win': max_win, 'max_single_loss': max_loss,
+                'max_drawdown': max_drawdown * 100,
+                # New Fields
+                'max_win_streak': max_win_streak,
+                'max_loss_streak': max_loss_streak,
+                'consensus_agreement_rate': agreement_rate,
+                'high_consensus_win_rate': hc_win_rate,
+                'low_consensus_win_rate': lc_win_rate,
+                'high_consensus_avg_pnl': hc_avg_pnl
+            })
             
-            # استخدام العتبات الحية
-            if hydra_result['action'] == 'HOLD':
-                if p_crash >= SystemLimits.HYDRA_CRASH_THRESH:
-                    hydra_result['action'] = 'EXIT_HARD'
-                    hydra_result['reason'] = f"Hydra Crash Risk {p_crash:.2f}"
-                elif p_giveback >= SystemLimits.HYDRA_GIVEBACK_THRESH:
-                    hydra_result['action'] = 'EXIT_SOFT'
-                    hydra_result['reason'] = f"Hydra Giveback Risk {p_giveback:.2f}"
+        return results
+
+    async def run_optimization(self, target_regime="RANGE"):
+        await self.generate_truth_data()
         
-        # 2. Legacy (Volume-Aware Veto)
-        legacy_result = {'action': 'HOLD', 'reason': 'Disabled', 'scores': {}}
-        if self.guardian_legacy and self.guardian_legacy.initialized:
-            # تحديث العتبات قبل التحليل
-            self.guardian_legacy.configure_thresholds(
-                v2_panic=SystemLimits.LEGACY_V2_PANIC_THRESH,
-                v3_hard=SystemLimits.LEGACY_V3_HARD_THRESH,
-                v3_soft=SystemLimits.LEGACY_V3_SOFT_THRESH,
-                v3_ultra=SystemLimits.LEGACY_V3_ULTRA_THRESH
-            )
-            
-            entry_price = float(trade_context.get('entry_price', 0.0))
-            vol_30m = trade_context.get('volume_30m_usd', 0.0)
+        # 🔥 Dynamic Ranges based on GRID_DENSITY
+        density = self.GRID_DENSITY
+        
+        oracle_range = np.linspace(0.5, 0.8, density).tolist()
+        sniper_range = np.linspace(0.4, 0.7, density).tolist()
+        hydra_range = np.linspace(0.75, 0.95, density).tolist()
+        
+        # New Params (Titan & Pattern)
+        titan_range = np.linspace(0.4, 0.7, density).tolist()
+        pattern_range = np.linspace(0.2, 0.5, density).tolist()
+        
+        combinations = []
+        # Full Stack Loop
+        for o, s, h, wt, wp in itertools.product(oracle_range, sniper_range, hydra_range, titan_range, pattern_range):
+            combinations.append({
+                'w_titan': wt, 
+                'w_struct': wp, 
+                'thresh': 0.5, 
+                'oracle_thresh': o, 
+                'sniper_thresh': s, 
+                'hydra_thresh': h,
+                'legacy_thresh': 0.95
+            })
             
-            legacy_result = self.guardian_legacy.analyze_position(
-                ohlcv_1m, ohlcv_5m, ohlcv_15m, entry_price, 
-                order_book=order_book_snapshot,
-                volume_30m_usd=vol_30m
-            )
-
-        # 3. Final Arbitration & Display
-        h_probs = hydra_result.get('probs', {})
-        l_scores = legacy_result.get('scores', {})
+        current_period_files = [os.path.join(CACHE_DIR, f) for f in os.listdir(CACHE_DIR) if f.endswith('_scores.pkl')]
+        if not current_period_files: return None, None
         
-        h_c = h_probs.get('crash', 0.0)
-        h_g = h_probs.get('giveback', 0.0)
-        h_s = h_probs.get('stagnation', 0.0) 
-        l_v2 = l_scores.get('v2', 0.0)
-        l_v3 = l_scores.get('v3', 0.0)
+        print(f"\n🧩 [Phase 2] Optimizing {len(combinations)} Configs (Full Stack | Density {density}) for {target_regime}...")
+        best_res = self._worker_optimize(combinations, current_period_files, self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS)
+        if not best_res: return None, None
+        best = sorted(best_res, key=lambda x: x['final_balance'], reverse=True)[0]
         
-        stamp_str = f"🐲[C:{h_c:.0%}|G:{h_g:.0%}|S:{h_s:.0%}] 🕸️[V2:{l_v2:.0%}|V3:{l_v3:.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("-" * 60)
+        print(f"   🧠 CONSENSUS ANALYTICS:")
+        print(f"   🤝 Model Agreement Rate:     {best['consensus_agreement_rate']:.1f}% (of all trades)")
+        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"   🟢 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"   ⚙️ 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}")
+        print("="*60)
+        return best['config'], best
+
+async def run_strategic_optimization_task():
+    print("\n🧪 [STRATEGIC BACKTEST] Full Stack Mode...")
+    r2 = R2Service()
+    dm = DataManager(None, None, r2)
+    proc = MLProcessor(dm)
+    await dm.initialize(); await proc.initialize()
+    if proc.guardian_hydra: proc.guardian_hydra.set_silent_mode(True)
 
-        final_action = 'HOLD'
-        final_reason = f"Safe. {stamp_str}"
+    try:
+        hub = AdaptiveHub(r2); await hub.initialize()
+        optimizer = HeavyDutyBacktester(dm, proc)
         
-        if hydra_result['action'] in ['EXIT_HARD', 'EXIT_SOFT', 'TIGHTEN_SL', 'TRAIL_SL']:
-             final_action = hydra_result['action']
-             final_reason = f"🐲 HYDRA: {hydra_result['reason']} | {stamp_str}"
-        elif legacy_result['action'] in ['EXIT_HARD', 'EXIT_SOFT']:
-             final_action = legacy_result['action']
-             final_reason = f"🕸️ LEGACY: {legacy_result['reason']} | {stamp_str}"
-
-        return {
-            'action': final_action, 
-            'reason': final_reason, 
-            'detailed_log': f"{final_action} | {stamp_str}", 
-            'probs': h_probs, 
-            'scores': l_scores
-        }
-
-    async def run_advanced_monte_carlo(self, symbol, timeframe='1h'):
-        if self.mc_analyzer and self.data_manager:
-            try:
-                ohlcv = await self.data_manager.get_latest_ohlcv(symbol, timeframe, limit=300)
-                if ohlcv: return self.mc_analyzer.run_advanced_simulation([c[4] for c in ohlcv])
-            except Exception: pass
-        return 0.0
+        # ⚡ ADJUST DENSITY HERE IF NEEDED
+        # optimizer.GRID_DENSITY = 3 (Default)
+        
+        scenarios = [
+            {"regime": "BULL", "start": "2024-01-01", "end": "2024-03-30"},
+            {"regime": "BEAR", "start": "2023-08-01", "end": "2023-09-15"},
+            {"regime": "DEAD", "start": "2023-06-01", "end": "2023-08-01"},
+            {"regime": "RANGE", "start": "2024-07-01", "end": "2024-09-30"}
+        ]
+        
+        for scen in scenarios:
+            target = scen["regime"]
+            optimizer.set_date_range(scen["start"], scen["end"])
+            best_cfg, best_stats = await optimizer.run_optimization(target_regime=target)
+            if best_cfg:
+                hub.submit_challenger(target, best_cfg, best_stats)
+                
+        await hub._save_state_to_r2()
+        print("✅ [System] ALL Strategic DNA Updated & Saved.")
+        
+    finally:
+        await dm.close()
+
+if __name__ == "__main__":
+    asyncio.run(run_strategic_optimization_task())