Update ml_engine/processor.py

ml_engine/processor.py

@@ -1,23 +1,17 @@
 # ============================================================
 # 🧠 ml_engine/processor.py 
-# (V69.2 - GEM-Architect: Full Integrity + Titan V2)
+# (V70.0 - GEM-Architect: 5-Layer Precision Logic)
 # ============================================================
 
 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
+# Imports
+try: from .pattern_engine import PatternEngine # Renamed from Titan
+except ImportError: PatternEngine = None
 
 try: from .monte_carlo import MonteCarloEngine
 except ImportError: MonteCarloEngine = None
@@ -30,11 +24,8 @@ except ImportError: HybridDeepSteward = None
 try: from .guardian_hydra import GuardianHydra
 except ImportError: GuardianHydra = None
 
-# ============================================================
-# 📂 مسارات النماذج
-# ============================================================
+# Base Paths
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-MODELS_L2_DIR = os.path.join(BASE_DIR, "ml_models", "layer2")
 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")
@@ -43,59 +34,40 @@ MODEL_V3_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Production.j
 MODEL_V3_FEAT = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Features.json")
 
 # ============================================================
-# 🎛️ SYSTEM LIMITS (Restored & Calibrated for Titan V2)
+# 🎛️ SYSTEM LIMITS (Calibrated for 5-Layer Pipeline)
 # ============================================================
 class SystemLimits:
     """
-    GEM-Architect: Full System Configuration.
-    Titan V2 is conservative, so Gate is lowered to 0.40.
+    GEM-Architect: Logic Gates Configuration.
     """
+    # --- Layer 2: Pattern Net Gate ---
+    # The PatternNet (ResNet) outputs a probability (0.0 - 1.0).
+    # We set the gate to 0.40 as requested.
+    L2_GATE_PATTERN_NET = 0.40  
     
-    # --- Layer 1 ---
-    L1_MIN_AFFINITY_SCORE = 15.0  
-    
-    # --- Layer 2 Hard Gates ---
-    # ✅ تم التعديل ليتناسب مع Titan V2 (ResNet)
-    L2_GATE_TITAN    = 0.40  
-    L2_GATE_PATTERN  = 0.00  # Disabled (Pattern Engine Removed)
-    L2_GATE_MC       = 0.00 
+    # --- Layer 2: Composite Score Weights ---
+    # Score = (Pattern * W1) + (Oracle * W2) + (MC * W3)
+    # Total should sum to roughly 1.0 for normalized scoring
+    L2_WEIGHT_PATTERN = 0.50
+    L2_WEIGHT_ORACLE  = 0.30
+    L2_WEIGHT_MC      = 0.20
     
-    # --- Layer 2 Weights & Min Score ---
-    L2_MIN_SCORE       = 40.0 # Score is now 0-100 based
-    
-    # ✅ المعادلة الجديدة: الاعتماد الكلي على تيتان
-    L2_WEIGHT_TITAN    = 0.90
-    L2_WEIGHT_PATTERNS = 0.00
-    L2_WEIGHT_MC       = 0.10
-
-    # Pattern Config (Kept for compatibility, effectively unused)
-    PATTERN_TF_WEIGHTS = {'1h': 0.35, '15m': 0.25, '1d': 0.20, '5m': 0.10, '4h': 0.10}
-    PATTERN_THRESH_BULLISH = 0.50 
-    PATTERN_THRESH_BEARISH = 0.40
+    L2_MIN_COMPOSITE_SCORE = 50.0 # Out of 100
 
-    # --- Layer 3 (Oracle) ---
-    L3_CONFIDENCE_THRESHOLD = 0.005 # Oracle V4.5 uses Expected Return (0.5%)
-    L3_WHALE_IMPACT_MAX = 15.0
-    L3_NEWS_IMPACT_MAX  = 10.0
-    L3_MC_ADVANCED_MAX  = 10.0
+    # --- Layer 3: External Data Impact ---
+    L3_WHALE_IMPACT_MAX = 15.0 # Additive points
+    L3_NEWS_IMPACT_MAX  = 10.0 # Additive points
 
-    # --- Layer 4 (Sniper) ---
-    L4_ENTRY_THRESHOLD  = 0.40 
+    # --- Layer 4: Sniper ---
+    L4_ENTRY_THRESHOLD  = 0.50 # Higher confidence needed for final selection
     L4_WEIGHT_ML        = 0.60
     L4_WEIGHT_OB        = 0.40
-    L4_OB_WALL_RATIO    = 0.35 
 
-    # --- Layer 0: Hydra & Guardian Defaults (Restored) ---
+    # --- Guardians (Exit Logic) ---
     HYDRA_CRASH_THRESH      = 0.60 
     HYDRA_GIVEBACK_THRESH   = 0.80 
     HYDRA_STAGNATION_THRESH = 0.60 
 
-    # Fixed Legacy Guards
-    LEGACY_V2_PANIC_THRESH = 0.98 
-    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)}
@@ -107,295 +79,166 @@ class MLProcessor:
     def __init__(self, data_manager=None):
         self.data_manager = data_manager
         self.initialized = False
-        self.initialization_attempted = False
         
-        # ✅ 1. Titan V2 (ResNet) - The Core
-        self.titan = TitanEngine(model_dir=MODELS_UNIFIED_DIR) if TitanEngine else None
-        
-        # ✅ 2. Oracle V4.5 (LightGBM) - The Strategist
+        # ✅ Layer 2 Engines
+        self.pattern_net = PatternEngine(model_dir=MODELS_UNIFIED_DIR) if PatternEngine else None
         self.oracle = OracleEngine(model_dir=MODELS_UNIFIED_DIR) if OracleEngine else None
-        
-        # 3. Monte Carlo (Safety Check)
         self.mc_analyzer = MonteCarloEngine() if MonteCarloEngine else None
         
-        # 4. Sniper (Entry Timing)
+        # ✅ Layer 4 Engine
         self.sniper = SniperEngine(models_dir=MODELS_SNIPER_DIR) if SniperEngine else None
         
-        # 5. Guardians (Exit Logic)
-        self.guardian_hydra = None
-        if GuardianHydra:
-            self.guardian_hydra = GuardianHydra(model_dir=MODELS_HYDRA_DIR)
-
-        self.guardian_legacy = None
+        # ✅ Layer 0 (Guardians)
+        self.guardian_hydra = GuardianHydra(model_dir=MODELS_HYDRA_DIR) if GuardianHydra else None
+        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
-            )
+            self.guardian_legacy = HybridDeepSteward(MODEL_V2_PATH, MODEL_V3_PATH, MODEL_V3_FEAT)
 
-        print(f"🧠 [MLProcessor V69.2] Titan V2 Architecture Loaded.")
+        print(f"🧠 [Processor V70.0] 5-Layer Architecture Initialized.")
 
     async def initialize(self):
         if self.initialized: return True
-        if self.initialization_attempted: return self.initialized
-            
-        self.initialization_attempted = True
-        print("⚙️ [Processor] Initializing Neural Grid...")
-        
+        print("⚙️ [Processor] Starting Neural Grid...")
         try:
-            init_tasks = []
+            tasks = []
+            if self.pattern_net: tasks.append(self.pattern_net.initialize())
+            if self.oracle: tasks.append(self.oracle.initialize())
+            if self.sniper: tasks.append(self.sniper.initialize())
+            if tasks: await asyncio.gather(*tasks)
             
-            if self.titan: init_tasks.append(self.titan.initialize())
-            if self.oracle: 
-                # Oracle settings are handled in its class now
-                init_tasks.append(self.oracle.initialize())
-            if self.mc_analyzer and hasattr(self.mc_analyzer, 'initialize'):
-                 # Check if async
-                 if asyncio.iscoroutinefunction(self.mc_analyzer.initialize):
-                     init_tasks.append(self.mc_analyzer.initialize())
-            
-            if self.sniper: 
-                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
-                )
-                init_tasks.append(self.sniper.initialize())
-
-            # Await all async inits
-            await asyncio.gather(*init_tasks)
-
-            # Sync Guardians (usually sync methods)
             if self.guardian_hydra: self.guardian_hydra.initialize()
-            if self.guardian_legacy: 
-                if asyncio.iscoroutinefunction(self.guardian_legacy.initialize):
-                    await self.guardian_legacy.initialize()
-                else:
-                    self.guardian_legacy.initialize()
-                
-                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
-                )
-
+            if self.guardian_legacy: self.guardian_legacy.initialize()
+            
             self.initialized = True
-            print("✅ [Processor] All Systems Operational.")
             return True
-            
         except Exception as e:
-            print(f"❌ [Processor FATAL] Init failed: {e}")
-            traceback.print_exc()
-            self.initialized = False
+            print(f"❌ [Processor] Init Error: {e}")
             return False
 
-    async def process_compound_signal(self, raw_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    # ============================================================
+    # 🏢 LAYER 2: Pattern + Oracle + MC (The Filter)
+    # ============================================================
+    async def execute_layer2_analysis(self, raw_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """
-        L2 Processing: Titan V2 -> MC -> Oracle.
-        Patterns Engine is bypassed.
+        Calculates the Composite Score for Layer 2.
+        Input: Symbol Data from Layer 1.
+        Output: Enriched Data with Score if passed, else None.
         """
         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
+        ohlcv = raw_data.get('ohlcv')
         
         try:
-            # 1. Titan Prediction (ResNet)
-            score_titan = 0.0
-            titan_probs = [0.0, 0.0, 0.0]
-            titan_res = {}
+            # 1. Pattern Net Analysis (The Neural Core)
+            pattern_res = {'score': 0.0, 'probs': [0,0,0]}
+            if self.pattern_net:
+                pattern_res = await asyncio.to_thread(self.pattern_net.predict, ohlcv)
             
-            if self.titan:
-                titan_res = await asyncio.to_thread(self.titan.predict, ohlcv_data)
-                if titan_res.get('error'):
-                    return None # Titan Failure = Abort
-                
-                score_titan = titan_res.get('score', 0.0) # Win Prob
-                titan_probs = titan_res.get('probs', [0.0, 0.0, 0.0])
-
-            # 2. Monte Carlo (Light Check)
-            mc_score = 0.5
-            if self.mc_analyzer and '1h' in ohlcv_data:
-                try:
-                    closes = [c[4] for c in ohlcv_data['1h']]
-                    raw_mc = self.mc_analyzer.run_light_check(closes)
-                    # Normalize MC (-0.1 to +0.1) -> (0.0 to 1.0) approx
-                    mc_score = 0.5 + (raw_mc * 5.0) 
-                    mc_score = max(0.0, min(1.0, mc_score))
-                except: pass
-
-            # --- 3. Gated Logic (Titan V2 Focused) ---
-            gate_titan = limits.get('l2_gate_titan', SystemLimits.L2_GATE_TITAN)
+            nn_score = pattern_res.get('score', 0.0)
+            pattern_probs = pattern_res.get('probs', [0,0,0]) # [Neutral, Loss, Win]
+
+            # 🛑 Hard Gate: Pattern Net
+            if nn_score < SystemLimits.L2_GATE_PATTERN_NET:
+                return None # REJECT immediately
+
+            # 2. Oracle Analysis (Strategic Return)
+            # We must pass 'titan_probs' key because Oracle expects it, even if we renamed variable locally
+            # or update Oracle to accept 'pattern_probs' if modified. Let's send both.
+            oracle_input = raw_data.copy()
+            oracle_input['titan_probs'] = pattern_probs 
+            oracle_input['pattern_probs'] = pattern_probs
             
-            is_valid = True
-            rejection_reason = None
-
-            # Hard Gate: Titan Only
-            if score_titan < gate_titan:
-                is_valid = False
-                rejection_reason = f"Titan Weak ({score_titan:.2f} < {gate_titan})"
-
-            # Weighted Score (Titan 90%, MC 10%)
-            hybrid_score = (score_titan * 90) + (mc_score * 10) # 0-100 scale
+            oracle_res = {'oracle_score': 0.0}
+            if self.oracle:
+                oracle_res = await self.oracle.predict(oracle_input)
             
-            return {
-                'symbol': symbol, 
-                'current_price': current_price, 
-                'enhanced_final_score': hybrid_score,
-                'is_valid': is_valid,
-                'rejection_reason': rejection_reason,
-                'dynamic_limits': limits, 
-                'asset_regime': raw_data.get('asset_regime', 'UNKNOWN'),
-                'strategy_type': raw_data.get('strategy_type', 'NORMAL'),
-                'titan_score': score_titan * 100, # Display as % 
-                'titan_probs': titan_probs,       # Essential for Oracle
-                'mc_score': mc_score, 
-                'patterns_score': 0.0,            # Deprecated
-                'components': {
-                    'titan_score': score_titan, 
-                    'mc_score': mc_score
-                }, 
-                'ohlcv': ohlcv_data
-            }
-        except Exception as e: 
-            print(f"❌ [Processor] Error processing {symbol}: {e}")
-            traceback.print_exc()
-            return None
+            # Oracle score is Expected Return (e.g. 0.01 for 1%). Normalize it roughly 0-1 for scoring
+            # 1% return = 1.0 score contribution (capped)
+            oracle_val = max(0.0, min(1.0, oracle_res.get('oracle_score', 0.0) * 100))
+
+            # 3. Monte Carlo (Light Check)
+            mc_val = 0.5
+            if self.mc_analyzer and '1h' in ohlcv:
+                closes = [c[4] for c in ohlcv['1h']]
+                raw_mc = self.mc_analyzer.run_light_check(closes) # -0.1 to +0.1
+                mc_val = 0.5 + (raw_mc * 5.0) # Map to 0.0-1.0
+                mc_val = max(0.0, min(1.0, mc_val))
+
+            # 4. Composite Scoring
+            # Weights: Pattern(50%) + Oracle(30%) + MC(20%)
+            composite_score = (
+                (nn_score * SystemLimits.L2_WEIGHT_PATTERN) +
+                (oracle_val * SystemLimits.L2_WEIGHT_ORACLE) +
+                (mc_val * SystemLimits.L2_WEIGHT_MC)
+            ) * 100 # Scale to 0-100
+
+            if composite_score < SystemLimits.L2_MIN_COMPOSITE_SCORE:
+                return None # REJECT Weak Score
+
+            # Pass to Layer 3
+            result = raw_data.copy()
+            result.update({
+                'l2_score': composite_score,
+                'pattern_score': nn_score,
+                'oracle_score': oracle_res.get('oracle_score', 0.0),
+                'mc_score': mc_val,
+                'pattern_probs': pattern_probs
+            })
+            return result
 
-    async def consult_oracle(self, symbol_data: Dict[str, Any]) -> Dict[str, Any]:
-        if not self.initialized: await self.initialize()
-        
-        # الحقن المباشر للعتبة من Limits
-        limits = symbol_data.get('dynamic_limits', {})
-        threshold = limits.get('l3_oracle_thresh', SystemLimits.L3_CONFIDENCE_THRESHOLD)
-        
-        if self.oracle:
-            try:
-                # Update threshold dynamically
-                if hasattr(self.oracle, 'set_threshold'):
-                    self.oracle.set_threshold(threshold)
-                    
-                decision = await self.oracle.predict(symbol_data)
-                
-                # Oracle V4.5 decision is based on Expected Return (oracle_score)
-                # But we map it to standard keys for app.py
-                return decision
-            except Exception as e:
-                print(f"❌ [Processor] Oracle error: {e}")
-                return {'action': 'WAIT', 'reason': f'Oracle error: {str(e)}'}
-        return {'action': 'WAIT', 'reason': 'Oracle Engine Missing'}
+        except Exception as e:
+            print(f"❌ [Layer 2] Error {symbol}: {e}")
+            return None
 
-    async def check_sniper_entry(self, ohlcv_1m_data: List, order_book_data: Dict[str, Any], context_data: Dict = None) -> Dict[str, Any]:
+    # ============================================================
+    # 🎯 LAYER 4: Sniper Analysis (The Executor)
+    # ============================================================
+    async def execute_layer4_sniper(self, symbol: str, ohlcv_1m: List, order_book: Dict) -> Dict[str, Any]:
+        """
+        Runs the Sniper Engine on the Top Candidates.
+        """
         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: 
-            try:
-                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)
-            except Exception as e:
-                return {'signal': 'WAIT', 'reason': f'Sniper error: {str(e)}'}
+        if not self.sniper:
+            return {'signal': 'WAIT', 'confidence_prob': 0.0, 'reason': 'No Sniper'}
             
-        return {'signal': 'WAIT', 'reason': 'Sniper Engine Missing'}
+        try:
+            self.sniper.configure_settings(
+                threshold=SystemLimits.L4_ENTRY_THRESHOLD,
+                wall_ratio=0.35, # Strict wall check
+                w_ml=SystemLimits.L4_WEIGHT_ML,
+                w_ob=SystemLimits.L4_WEIGHT_OB
+            )
+            
+            result = await self.sniper.check_entry_signal_async(ohlcv_1m, order_book, symbol=symbol)
+            return result
+        except Exception as e:
+            return {'signal': 'WAIT', 'confidence_prob': 0.0, 'reason': f"Sniper Error: {e}"}
 
-    def consult_dual_guardians(self, symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context, order_book_snapshot=None):
-        """
-        💎 GEM-Architect: Full Guardian Logic (Restored)
-        """
-        if not self.initialized:
-            return {'action': 'HOLD', 'detailed_log': 'System not initialized', 'probs': {}, 'scores': {}}
+    # ============================================================
+    # 🛡️ Guardians (Exit Logic)
+    # ============================================================
+    def consult_guardians(self, symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context, ob_snapshot=None):
+        """Dual-Core Guardian Logic (Hydra + Legacy)"""
+        if not self.initialized: return {'action': 'HOLD', 'reason': 'Not Init'}
         
-        # 1. استخراج الحدود
-        limits = trade_context.get('dynamic_limits', {})
-        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)
-        
-        # Context
-        entry_price = float(trade_context.get('entry_price', 0.0))
-        highest_price = trade_context.get('highest_price', entry_price)
-        max_pnl_pct = ((highest_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0.0
-        time_in_trade_mins = trade_context.get('time_in_trade_mins', 0.0)
-
-        # A. Hydra Execution
-        hydra_result = {'action': 'HOLD', 'reason': 'Disabled', 'probs': {}}
+        hydra_res = {'action': 'HOLD'}
         if self.guardian_hydra:
-            try:
-                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)
-                p_stagnation = h_probs.get('stagnation', 0.0)
-                
-                if p_crash >= h_crash_thresh:
-                    hydra_result['action'] = 'EXIT_HARD'
-                    hydra_result['reason'] = f"Hydra Crash Risk {p_crash:.2f}"
-                elif p_giveback >= h_giveback_thresh and max_pnl_pct >= 0.6: 
-                    hydra_result['action'] = 'EXIT_SOFT'
-                    hydra_result['reason'] = f"Hydra Giveback {p_giveback:.2f}"
-                elif p_stagnation >= h_stag_thresh and time_in_trade_mins > 90:
-                    hydra_result['action'] = 'EXIT_SOFT'
-                    hydra_result['reason'] = f"Hydra Stagnation {p_stagnation:.2f}"
-            except Exception as e:
-                print(f"⚠️ [Processor] Hydra error: {e}")
-
-        # B. Legacy Execution
-        legacy_result = {'action': 'HOLD', 'reason': 'Disabled', 'scores': {}}
+            hydra_res = self.guardian_hydra.analyze_position(symbol, ohlcv_1m, ohlcv_5m, ohlcv_15m, trade_context)
+            
+        # Prioritize Hydra
+        if hydra_res['action'] != 'HOLD':
+            return hydra_res
+            
+        # Fallback to Legacy if Hydra says HOLD
         if self.guardian_legacy:
-            try:
-                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
-                )
-            except Exception as e:
-                print(f"⚠️ [Processor] Legacy error: {e}")
-
-        # C. Arbitration
-        h_probs = hydra_result.get('probs', {})
-        l_scores = legacy_result.get('scores', {})
-        
-        final_action = 'HOLD'
-        final_reason = f"Safe."
-        
-        hydra_act = hydra_result.get('action', 'HOLD')
-        legacy_act = legacy_result.get('action', 'HOLD')
-        
-        if hydra_act in ['EXIT_HARD', 'EXIT_SOFT', 'TIGHTEN_SL', 'TRAIL_SL']:
-             final_action = hydra_act
-             final_reason = f"🐲 {hydra_result.get('reason')}"
-        elif legacy_act in ['EXIT_HARD', 'EXIT_SOFT']:
-             final_action = legacy_act
-             final_reason = f"🕸️ {legacy_result.get('reason')}"
-
-        return {
-            'action': final_action, 
-            'reason': final_reason, 
-            '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: pass
-        return 0.0
+            legacy_res = self.guardian_legacy.analyze_position(
+                ohlcv_1m, ohlcv_5m, ohlcv_15m, 
+                float(trade_context.get('entry_price', 0)),
+                order_book=ob_snapshot,
+                volume_30m_usd=trade_context.get('volume_30m_usd', 0)
+            )
+            return legacy_res
+            
+        return {'action': 'HOLD', 'reason': 'Default'}