Upload 2 files

ml_engine/processor (71) (1).py

@@ -0,0 +1,394 @@
+# ============================================================
+# 🧠 ml_engine/processor.py 
+# (V66.0 - GEM-Architect: Direct Context Injection Fixed)
+# ============================================================
+
+import asyncio
+import traceback
+import logging
+import os
+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
+
+# ============================================================
+# 📂 مسارات النماذج
+# ============================================================
+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")
+
+# ============================================================
+# 🎛️ SYSTEM LIMITS (Fallback Only)
+# ============================================================
+class SystemLimits:
+    """
+    GEM-Architect: Fallback Values.
+    The real values are now injected dynamically via 'dynamic_limits' per Coin Type.
+    """
+    
+    # --- Layer 1 ---
+    L1_MIN_AFFINITY_SCORE = 15.0  
+    
+    # --- Layer 2 Weights ---
+    L2_WEIGHT_TITAN    = 0.40
+    L2_WEIGHT_PATTERNS = 0.30
+    L2_WEIGHT_MC       = 0.10
+
+    # Pattern Config
+    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 ---
+    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 ---
+    L4_ENTRY_THRESHOLD  = 0.40
+    L4_WEIGHT_ML        = 0.60
+    L4_WEIGHT_OB        = 0.40
+    L4_OB_WALL_RATIO    = 0.40
+
+    # --- Layer 0: Hydra & Guardian Defaults ---
+    HYDRA_CRASH_THRESH      = 0.85
+    HYDRA_GIVEBACK_THRESH   = 0.85
+    HYDRA_STAGNATION_THRESH = 0.80
+
+    LEGACY_V2_PANIC_THRESH = 0.95
+    LEGACY_V3_HARD_THRESH  = 0.95
+    LEGACY_V3_SOFT_THRESH  = 0.88
+    LEGACY_V3_ULTRA_THRESH = 0.99
+
+    @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)}
+
+# ============================================================
+# 🧠 MLProcessor Class
+# ============================================================
+class MLProcessor:
+    def __init__(self, data_manager=None):
+        self.data_manager = data_manager
+        self.initialized = False
+        
+        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
+        
+        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 V66.0] Context-Aware Injection 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())
+            
+            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 tasks: await asyncio.gather(*tasks)
+
+            if self.guardian_hydra: 
+                self.guardian_hydra.initialize()
+                print("   🛡️ [Guard 1] Hydra X-Ray: Active")
+            
+            if self.guardian_legacy:
+                if asyncio.iscoroutinefunction(self.guardian_legacy.initialize):
+                    await self.guardian_legacy.initialize()
+                else:
+                    self.guardian_legacy.initialize()
+                
+                # Default init
+                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 with Dynamic Weight Injection
+        """
+        if not self.initialized: await self.initialize()
+        
+        symbol = raw_data.get('symbol')
+        ohlcv_data = raw_data.get('ohlcv')
+        current_price = raw_data.get('current_price', 0.0)
+        
+        # ✅ الحقن المباشر للقيم
+        limits = raw_data.get('dynamic_limits', {})
+        
+        if not symbol or not ohlcv_data: return None
+        
+        try:
+            # 1. Titan
+            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
+            score_patterns = 0.5
+            pattern_res = {}
+            pattern_name = "Neutral"
+            if self.pattern_engine:
+                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. MC
+            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 Calc (Dynamic Injection)
+            w_titan = limits.get('w_titan', SystemLimits.L2_WEIGHT_TITAN)
+            w_patt = limits.get('w_patt', SystemLimits.L2_WEIGHT_PATTERNS)
+            w_mc = SystemLimits.L2_WEIGHT_MC 
+            
+            total_w = w_titan + w_patt + w_mc
+            if total_w <= 0: total_w = 1.0
+            
+            hybrid_score = ((score_titan * w_titan) + (score_patterns * w_patt) + (mc_score * w_mc)) / total_w
+            
+            return {
+                'symbol': symbol, 
+                'current_price': current_price, 
+                'enhanced_final_score': hybrid_score,
+                'dynamic_limits': limits, # تمرير الحدود للطبقات التالية
+                'asset_regime': raw_data.get('asset_regime', 'UNKNOWN'),
+                'strategy_type': raw_data.get('strategy_type', 'NORMAL'),
+                '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]:
+        if not self.initialized: await self.initialize()
+        
+        # ✅ الحقن المباشر للعتبة
+        limits = symbol_data.get('dynamic_limits', {})
+        threshold = limits.get('l3_oracle_thresh', SystemLimits.L3_CONFIDENCE_THRESHOLD)
+        
+        if self.oracle:
+            if hasattr(self.oracle, 'set_threshold'):
+                self.oracle.set_threshold(threshold)
+                
+            decision = await self.oracle.predict(symbol_data)
+            conf = decision.get('confidence', 0.0)
+            
+            if decision.get('action') in ['WATCH', 'BUY'] and conf < threshold:
+                decision['action'] = 'WAIT'
+                decision['reason'] = f"Context Veto: Conf {conf:.2f} < Limit {threshold:.2f}"
+            
+            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], context_data: Dict = None) -> Dict[str, Any]:
+        if not self.initialized: await self.initialize()
+        
+        # ✅ الحقن المباشر
+        limits = context_data.get('dynamic_limits', {}) if context_data else {}
+        
+        thresh = limits.get('l4_sniper_thresh', SystemLimits.L4_ENTRY_THRESHOLD)
+        wall_r = limits.get('l4_ob_wall_ratio', SystemLimits.L4_OB_WALL_RATIO)
+
+        if self.sniper: 
+            if hasattr(self.sniper, 'configure_settings'):
+                self.sniper.configure_settings(
+                    threshold=thresh,
+                    wall_ratio=wall_r,
+                    w_ml=SystemLimits.L4_WEIGHT_ML,
+                    w_ob=SystemLimits.L4_WEIGHT_OB
+                )
+            return await self.sniper.check_entry_signal_async(ohlcv_1m_data, order_book_data)
+            
+        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):
+        """
+        💎 GEM-Architect: الحقن المباشر لعتبات الحراس من سياق الصفقة
+        يضمن أن كل نوع عملة يتم حمايته بالعتبات الخاصة به (High Precision)
+        """
+        response = {'action': 'HOLD', 'detailed_log': '', 'probs': {}}
+        
+        # 1. استخراج الحدود الديناميكية من سياق الصفقة
+        # trade_context يمرر من TradeManager ويحتوي على dynamic_limits
+        limits = trade_context.get('dynamic_limits', {})
+        
+        # ✅ سحب القيم مع Fallback آمن
+        h_crash_thresh = limits.get('hydra_crash', SystemLimits.HYDRA_CRASH_THRESH)
+        h_giveback_thresh = limits.get('hydra_giveback', SystemLimits.HYDRA_GIVEBACK_THRESH)
+        h_stag_thresh = limits.get('hydra_stagnation', SystemLimits.HYDRA_STAGNATION_THRESH)
+        
+        l_v2_thresh = limits.get('legacy_v2', SystemLimits.LEGACY_V2_PANIC_THRESH)
+        l_v3_hard = limits.get('legacy_v3_hard', SystemLimits.LEGACY_V3_HARD_THRESH)
+        l_v3_soft = limits.get('legacy_v3_soft', SystemLimits.LEGACY_V3_SOFT_THRESH)
+        l_v3_ultra = limits.get('legacy_v3_ultra', SystemLimits.LEGACY_V3_ULTRA_THRESH)
+
+        # -----------------------------------------------
+        # 1. Hydra Execution
+        # -----------------------------------------------
+        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)
+            
+            # 🔥 استخدام العتبات المحقونة
+            if hydra_result['action'] == 'HOLD':
+                if p_crash >= h_crash_thresh:
+                    hydra_result['action'] = 'EXIT_HARD'
+                    hydra_result['reason'] = f"Hydra Crash Risk {p_crash:.2f} >= {h_crash_thresh}"
+                elif p_giveback >= h_giveback_thresh:
+                    hydra_result['action'] = 'EXIT_SOFT'
+                    hydra_result['reason'] = f"Hydra Giveback Risk {p_giveback:.2f} >= {h_giveback_thresh}"
+        
+        # -----------------------------------------------
+        # 2. Legacy Execution
+        # -----------------------------------------------
+        legacy_result = {'action': 'HOLD', 'reason': 'Disabled', 'scores': {}}
+        if self.guardian_legacy and self.guardian_legacy.initialized:
+            # 🔥 حقن الإعدادات ديناميكياً قبل التشغيل
+            self.guardian_legacy.configure_thresholds(
+                v2_panic=l_v2_thresh,
+                v3_hard=l_v3_hard,
+                v3_soft=l_v3_soft,
+                v3_ultra=l_v3_ultra
+            )
+            
+            entry_price = float(trade_context.get('entry_price', 0.0))
+            vol_30m = trade_context.get('volume_30m_usd', 0.0)
+            
+            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
+        # -----------------------------------------------
+        h_probs = hydra_result.get('probs', {})
+        l_scores = legacy_result.get('scores', {})
+        
+        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)
+        
+        stamp_str = f"🐲[C:{h_c:.0%}|G:{h_g:.0%}] 🕸️[V2:{l_v2:.0%}]"
+
+        final_action = 'HOLD'
+        final_reason = f"Safe. {stamp_str}"
+        
+        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']}"
+        elif legacy_result['action'] in ['EXIT_HARD', 'EXIT_SOFT']:
+             final_action = legacy_result['action']
+             final_reason = f"🕸️ LEGACY: {legacy_result['reason']}"
+
+        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

ml_engine/sniper_engine (17) (1).py

@@ -0,0 +1,353 @@
+# ============================================================
+# 🎯 ml_engine/sniper_engine.py 
+# (V2.0 - GEM-Architect: Weighted Depth & Smart Microstructure)
+# ============================================================
+
+import os
+import time
+import numpy as np
+import pandas as pd
+import pandas_ta as ta
+import lightgbm as lgb
+import traceback
+from typing import List, Dict, Any, Optional
+
+N_SPLITS = 5
+LOOKBACK_WINDOW = 500 
+
+# ============================================================
+# 🔧 1. Feature Engineering (Standard + Liquidity Proxies)
+# ============================================================
+
+def _z_score_rolling(x, w=500): 
+    r = x.rolling(w).mean()
+    s = x.rolling(w).std().replace(0, np.nan)
+    z = (x - r) / s
+    return z.fillna(0)
+
+def _add_liquidity_proxies(df):
+    """حساب مؤشرات السيولة المتقدمة (Amihud, VPIN, OFI, etc.)"""
+    df_proxy = df.copy()
+    if 'datetime' not in df_proxy.index:
+        if 'timestamp' in df_proxy.columns:
+            df_proxy['datetime'] = pd.to_datetime(df_proxy['timestamp'], unit='ms')
+            df_proxy = df_proxy.set_index('datetime')
+            
+    df_proxy['ret'] = df_proxy['close'].pct_change().fillna(0)
+    df_proxy['dollar_vol'] = df_proxy['close'] * df_proxy['volume']
+    
+    # Amihud Illiquidity Ratio
+    df_proxy['amihud'] = (df_proxy['ret'].abs() / df_proxy['dollar_vol'].replace(0, np.nan)).fillna(np.inf)
+    
+    # Roll Spread Proxy
+    dp = df_proxy['close'].diff()
+    roll_cov = dp.rolling(64).cov(dp.shift(1))
+    df_proxy['roll_spread'] = (2 * np.sqrt(np.maximum(0, -roll_cov))).bfill()
+
+    # Order Flow Imbalance (Volume-based proxy)
+    sign = np.sign(df_proxy['close'].diff()).fillna(0)
+    df_proxy['signed_vol'] = sign * df_proxy['volume']
+    df_proxy['ofi'] = df_proxy['signed_vol'].rolling(30).sum().fillna(0)
+
+    # VPIN-like Imbalance
+    buy_vol = (sign > 0) * df_proxy['volume']
+    sell_vol = (sign < 0) * df_proxy['volume']
+    imb = (buy_vol.rolling(60).sum() - sell_vol.rolling(60).sum()).abs()
+    tot = df_proxy['volume'].rolling(60).sum()
+    df_proxy['vpin'] = (imb / tot.replace(0, np.nan)).fillna(0)
+
+    # Volatility Estimator (Garman-Klass)
+    df_proxy['rv_gk'] = (np.log(df_proxy['high'] / df_proxy['low'])**2) / 2 - \
+                        (2 * np.log(2) - 1) * (np.log(df_proxy['close'] / df_proxy['open'])**2)
+    
+    # VWAP Deviation
+    vwap_window = 20
+    df_proxy['vwap'] = (df_proxy['close'] * df_proxy['volume']).rolling(vwap_window).sum() / \
+                       df_proxy['volume'].rolling(vwap_window).sum()
+    df_proxy['vwap_dev'] = (df_proxy['close'] - df_proxy['vwap']).fillna(0)
+
+    # Composite Liquidity Score
+    df_proxy['L_score'] = (
+        _z_score_rolling(df_proxy['volume']) +
+        _z_score_rolling(1 / df_proxy['amihud'].replace(np.inf, np.nan)) + 
+        _z_score_rolling(-df_proxy['roll_spread']) + 
+        _z_score_rolling(-df_proxy['rv_gk'].abs()) + 
+        _z_score_rolling(-df_proxy['vwap_dev'].abs()) + 
+        _z_score_rolling(df_proxy['ofi']) 
+    )
+    return df_proxy
+
+def _add_standard_features(df):
+    """المؤشرات الفنية القياسية"""
+    df_feat = df.copy()
+    
+    df_feat['return_1m'] = df_feat['close'].pct_change(1)
+    df_feat['return_3m'] = df_feat['close'].pct_change(3)
+    df_feat['return_5m'] = df_feat['close'].pct_change(5)
+    df_feat['return_15m'] = df_feat['close'].pct_change(15)
+
+    df_feat['rsi_14'] = ta.rsi(df_feat['close'], length=14)
+    
+    ema_9 = ta.ema(df_feat['close'], length=9)
+    ema_21 = ta.ema(df_feat['close'], length=21)
+    
+    if ema_9 is not None:
+        df_feat['ema_9_slope'] = (ema_9 - ema_9.shift(1)) / ema_9.shift(1)
+    else:
+        df_feat['ema_9_slope'] = 0
+        
+    if ema_21 is not None:
+        df_feat['ema_21_dist'] = (df_feat['close'] - ema_21) / ema_21 
+    else:
+        df_feat['ema_21_dist'] = 0
+    
+    df_feat['atr'] = ta.atr(df_feat['high'], df_feat['low'], df_feat['close'], length=100)
+    df_feat['vol_zscore_50'] = _z_score_rolling(df_feat['volume'], w=50) 
+    
+    df_feat['candle_range'] = df_feat['high'] - df_feat['low']
+    df_feat['close_pos_in_range'] = (df_feat['close'] - df_feat['low']) / (df_feat['candle_range'].replace(0, np.nan))
+    
+    return df_feat
+
+# ============================================================
+# 🎯 2. SniperEngine Class (Refactored)
+# ============================================================
+
+class SniperEngine:
+    
+    def __init__(self, models_dir: str):
+        self.models_dir = models_dir 
+        self.models: List[lgb.Booster] = []
+        self.feature_names: List[str] = []
+        
+        # --- Configurable Thresholds (Defaults) ---
+        self.entry_threshold = 0.40
+        self.wall_ratio_limit = 0.40    # Veto threshold for sell wall
+        self.weight_ml = 0.60
+        self.weight_ob = 0.40
+        
+        # --- Advanced OB Settings (New in V2.0) ---
+        self.ob_depth_decay = 0.15      # Decay factor for weighted depth
+        self.max_wall_dist = 0.005      # 0.5% max distance to consider a wall
+        self.max_spread_pct = 0.002     # 0.2% max spread allowed
+        self.spoof_patience = 0         # How many previous checks to ignore a new wall (0 = Instant Veto)
+        
+        self.initialized = False
+        self.LOOKBACK_WINDOW = LOOKBACK_WINDOW
+        self.ORDER_BOOK_DEPTH = 20
+        
+        # --- Persistence Cache for Anti-Spoofing ---
+        # Format: {symbol: {'last_check': timestamp, 'wall_counter': int}}
+        self._wall_cache = {}
+
+        print("🎯 [SniperEngine V2.0] Weighted Depth & Smart Microstructure Ready.")
+
+    def configure_settings(self, 
+                           threshold: float, 
+                           wall_ratio: float, 
+                           w_ml: float = 0.60, 
+                           w_ob: float = 0.40,
+                           max_wall_dist: float = 0.005,
+                           max_spread: float = 0.002):
+        """Dynamic configuration injection"""
+        self.entry_threshold = threshold
+        self.wall_ratio_limit = wall_ratio
+        self.weight_ml = w_ml
+        self.weight_ob = w_ob
+        self.max_wall_dist = max_wall_dist
+        self.max_spread_pct = max_spread
+
+    async def initialize(self):
+        """Load LightGBM Models"""
+        print(f"🎯 [SniperEngine] Loading models from {self.models_dir}...")
+        try:
+            model_files = [f for f in os.listdir(self.models_dir) if f.startswith('lgbm_guard_v3_fold_')]
+            
+            if len(model_files) < N_SPLITS:
+                print(f"❌ [SniperEngine] Error: Found {len(model_files)} models, need {N_SPLITS}.")
+                # Don't return, allow initialization without models (fallback mode)
+            
+            for f in sorted(model_files):
+                model_path = os.path.join(self.models_dir, f)
+                self.models.append(lgb.Booster(model_file=model_path))
+            
+            if self.models:
+                self.feature_names = self.models[0].feature_name()
+                
+            self.initialized = True
+            print(f"✅ [SniperEngine] Active. WallLimit: {self.wall_ratio_limit}, MaxDist: {self.max_wall_dist*100}%")
+
+        except Exception as e:
+            print(f"❌ [SniperEngine] Init failed: {e}")
+            traceback.print_exc()
+            self.initialized = False
+
+    def _calculate_features_live(self, df_1m: pd.DataFrame) -> pd.DataFrame:
+        try:
+            df_with_std_feats = _add_standard_features(df_1m)
+            df_with_all_feats = _add_liquidity_proxies(df_with_std_feats)
+            df_final = df_with_all_feats.replace([np.inf, -np.inf], np.nan)
+            return df_final
+        except Exception as e:
+            print(f"❌ [SniperEngine] Feature calc error: {e}")
+            return pd.DataFrame() 
+
+    # ==============================================================================
+    # 📊 3. Smart Order Book Logic (The Architect's Upgrade)
+    # ==============================================================================
+    def _score_order_book(self, order_book: Dict[str, Any], symbol: str = None) -> Dict[str, Any]:
+        try:
+            bids = order_book.get('bids', [])
+            asks = order_book.get('asks', [])
+            
+            if not bids or not asks:
+                return {'score': 0.0, 'imbalance': 0.0, 'veto': True, 'reason': 'Empty OB'}
+
+            # --- 1. Spread Check ---
+            best_bid = float(bids[0][0])
+            best_ask = float(asks[0][0])
+            spread_pct = (best_ask - best_bid) / best_bid
+            
+            if spread_pct > self.max_spread_pct:
+                return {
+                    'score': 0.0, 
+                    'veto': True, 
+                    'reason': f"Wide Spread ({spread_pct:.2%})"
+                }
+
+            # --- 2. Weighted Depth Imbalance ---
+            # Calculates imbalance giving higher weight to prices closer to spread
+            w_bid_vol = 0.0
+            w_ask_vol = 0.0
+            total_raw_ask_vol = 0.0 # for wall calculation
+            
+            # Limit depth processing to configured depth
+            depth = min(len(bids), len(asks), self.ORDER_BOOK_DEPTH)
+            
+            for i in range(depth):
+                # Decay Function: 1 / (1 + k * rank)
+                weight = 1.0 / (1.0 + (self.ob_depth_decay * i))
+                
+                bid_vol = float(bids[i][1])
+                ask_vol = float(asks[i][1])
+                
+                w_bid_vol += bid_vol * weight
+                w_ask_vol += ask_vol * weight
+                total_raw_ask_vol += ask_vol
+
+            total_w_vol = w_bid_vol + w_ask_vol
+            weighted_imbalance = w_bid_vol / total_w_vol if total_w_vol > 0 else 0.5
+            
+            # --- 3. Distance-Aware Wall Detection ---
+            max_valid_wall = 0.0
+            limit_price = best_ask * (1 + self.max_wall_dist)
+            
+            for price, vol in asks[:depth]:
+                p = float(price)
+                v = float(vol)
+                if p <= limit_price:
+                    if v > max_valid_wall: max_valid_wall = v
+            
+            wall_ratio = max_valid_wall / total_raw_ask_vol if total_raw_ask_vol > 0 else 0
+            
+            # --- 4. Anti-Spoofing / Persistence Logic ---
+            veto_wall = False
+            veto_reason = "OK"
+            
+            if wall_ratio >= self.wall_ratio_limit:
+                # Wall Detected
+                veto_wall = True
+                veto_reason = f"Sell Wall ({wall_ratio:.2f})"
+                
+                if symbol:
+                    curr_time = time.time()
+                    cache = self._wall_cache.get(symbol, {'last_check': 0, 'count': 0})
+                    
+                    # If this is a NEW wall (seen less than 1 second ago)
+                    if curr_time - cache['last_check'] > 5.0:
+                        # Reset counter if too much time passed
+                        cache['count'] = 1
+                    else:
+                        cache['count'] += 1
+                        
+                    cache['last_check'] = curr_time
+                    self._wall_cache[symbol] = cache
+                    
+                    # Optional: Logic to IGNORE flashing walls could go here
+                    # For now, we block on first sight (Safety First)
+            else:
+                # No wall, clear cache slightly
+                if symbol and symbol in self._wall_cache:
+                    self._wall_cache[symbol]['count'] = 0
+
+            return {
+                'score': float(weighted_imbalance),
+                'imbalance': float(weighted_imbalance), # Now Weighted
+                'wall_ratio': float(wall_ratio),
+                'veto': veto_wall,
+                'spread_ok': True,
+                'reason': veto_reason
+            }
+
+        except Exception as e:
+            return {'score': 0.0, 'veto': True, 'reason': f"OB Error: {e}"}
+
+    # ==============================================================================
+    # 🎯 4. Main Signal Check (Async)
+    # ==============================================================================
+    async def check_entry_signal_async(self, 
+                                     ohlcv_1m_data: List[List], 
+                                     order_book_data: Dict[str, Any] = None,
+                                     symbol: str = None) -> Dict[str, Any]:
+        
+        if not self.initialized:
+            return {'signal': 'WAIT', 'reason': 'Not initialized'}
+        
+        # --- ML Prediction ---
+        ml_score = 0.5
+        ml_reason = "No Data"
+        
+        if len(ohlcv_1m_data) >= self.LOOKBACK_WINDOW and self.models:
+            try:
+                df = pd.DataFrame(ohlcv_1m_data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+                df[['open', 'high', 'low', 'close', 'volume']] = df[['open', 'high', 'low', 'close', 'volume']].astype(float)
+                
+                df_features = self._calculate_features_live(df)
+                if not df_features.empty:
+                    X_live = df_features.iloc[-1:][self.feature_names].fillna(0)
+                    preds = [m.predict(X_live)[0][1] for m in self.models]
+                    ml_score = float(np.mean(preds))
+                    ml_reason = f"ML:{ml_score:.2f}"
+            except Exception as e:
+                print(f"❌ [Sniper] ML Error: {e}")
+                ml_reason = "ML Err"
+
+        # --- Smart Order Book Analysis ---
+        ob_res = {'score': 0.5, 'imbalance': 0.5, 'veto': False, 'reason': 'No OB'}
+        if order_book_data:
+            ob_res = self._score_order_book(order_book_data, symbol=symbol)
+
+        # --- Final Hybrid Score ---
+        # If OB vetos (Spread too high OR Sell Wall), we force score down or WAIT
+        if ob_res.get('veto', False):
+            final_score = 0.0
+            signal = 'WAIT'
+            reason_str = f"⛔ {ob_res['reason']} | {ml_reason}"
+        else:
+            final_score = (ml_score * self.weight_ml) + (ob_res['score'] * self.weight_ob)
+            
+            if final_score >= self.entry_threshold:
+                signal = 'BUY'
+                reason_str = f"✅ GO: {final_score:.2f} | {ml_reason} | OB:{ob_res['score']:.2f}"
+            else:
+                signal = 'WAIT'
+                reason_str = f"📉 Low Score: {final_score:.2f} | {ml_reason}"
+
+        return {
+            'signal': signal,
+            'confidence_prob': final_score,
+            'ml_score': ml_score,
+            'ob_score': ob_res['score'],
+            'entry_price': float(order_book_data['asks'][0][0]) if order_book_data and order_book_data.get('asks') else 0.0,
+            'reason': reason_str
+        }