Update trade_manager.py

trade_manager.py

@@ -1,883 +1,517 @@
-# app.py (V22.5 - GEM-Architect: FULL ORIGINAL SOURCE + Hybrid Guardian & Multi-Stats UI)
-import os
-import sys
-import traceback
+# trade_manager.py (V22.4 - GEM-Architect: Full Logic + Multi-Stats + 300 Candle Fix)
 import asyncio
-import gc
 import json
-import time
-from datetime import datetime, timedelta
-from contextlib import asynccontextmanager, redirect_stdout, redirect_stderr
-from io import StringIO
-from fastapi import FastAPI, HTTPException, BackgroundTasks
+import uuid
+import traceback
+from datetime import datetime
 from typing import List, Dict, Any
 
-# [ 💡 مكتبات الواجهة والرسم البياني ]
-import gradio as gr
-import pandas as pd
-import plotly.graph_objects as go 
-
-# ==============================================================================
-# 📥 استيراد الوحدات الأساسية (Core Modules Imports)
-# ==============================================================================
-try:
-    from r2 import R2Service
-    from data_manager import DataManager
-    from ml_engine.processor import MLProcessor
-    from trade_manager import TradeManager
-    from ml_engine.oracle_engine import OracleEngine
-    from whale_monitor.core import EnhancedWhaleMonitor
-    from sentiment_news import NewsFetcher
-    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-    from ml_engine.sniper_engine import SniperEngine
-    
-    # [ 🧠 الجوهرة ] استيراد الحارس الهجين (V4 Dual Brain)
-    from ml_engine.hybrid_guardian import HybridDeepSteward
-    
-except ImportError as e:
-    sys.exit(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
-
-# ==============================================================================
-# 🌐 المتغيرات العامة وحالة النظام (Global State)
-# ==============================================================================
-r2: R2Service = None
-data_manager: DataManager = None
-ml_processor: MLProcessor = None
-trade_manager: TradeManager = None
-whale_monitor: EnhancedWhaleMonitor = None
-news_fetcher: NewsFetcher = None
-senti_analyzer: SentimentIntensityAnalyzer = None
-sys_state: 'SystemState' = None
-sniper_engine: SniperEngine = None
-oracle_engine: OracleEngine = None
-
-# [ 🧠 ] المتغير العام للنموذج الهجين
-deep_steward: HybridDeepSteward = None
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-SHARED_GUARD_MODELS_DIR = os.path.join(BASE_DIR, "ml_models", "guard_v2")
-UNIFIED_MODELS_DIR = os.path.join(BASE_DIR, "ml_models", "Unified_Models_V1")
-
-# [ 🧠 ] مسارات النماذج للحارس الهجين
-V2_MODEL_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_Production_V1.json")
-V3_MODEL_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Production.json")
-V3_FEATURES_PATH = os.path.join(BASE_DIR, "ml_models", "DeepSteward_V3_Features.json")
-
-# ==============================================================================
-# 🔄 حالة النظام (System State)
-# ==============================================================================
-class SystemState:
-    def __init__(self):
-        self.ready = False
-        self.cycle_running = False
-        self.auto_pilot = True # 🚀 [Auto-Pilot Default: ON]
-        self.last_cycle_time: datetime = None
-        self.last_cycle_error = None
-        self.app_start_time = datetime.now()
-        self.last_cycle_logs = "النظام قيد التهيئة... يرجى الانتظار."
-
-    def set_ready(self): 
-        self.ready = True
-        self.last_cycle_logs = "✅ النظام جاهز. الطيار الآلي مفعل."
-    
-    def set_cycle_start(self): 
-        self.cycle_running = True
-        self.last_cycle_logs = "🌀 [Cycle START] جاري البحث عن إشارات..."
-
-    def set_cycle_end(self, error=None, logs=None):
-        self.cycle_running = False
-        self.last_cycle_time = datetime.now()
-        self.last_cycle_error = str(error) if error else None
-        if logs:
-            self.last_cycle_logs = logs
-        elif error:
-            self.last_cycle_logs = f"❌ [Cycle ERROR] {error}"
-        else:
-            self.last_cycle_logs = f"✅ [Cycle END] {datetime.now().strftime('%H:%M:%S')}. الدورة اكتملت."
-
-sys_state = SystemState()
-
-# ==============================================================================
-# 🛠️ Helper Functions
-# ==============================================================================
-def format_crypto_price(price):
-    """
-    تنسيق السعر بذكاء ليظهر كاملاً بغض النظر عن عدد الأصفار.
-    """
-    if price is None: return "0.0"
-    try:
-        p = float(price)
-        if p == 0: return "0.0"
-        return "{:.8f}".format(p).rstrip('0').rstrip('.')
-    except:
-        return str(price)
-
-def calculate_duration_str(timestamp_str):
-    """
-    دالة لحساب المدة الزمنية (Uptime/Trade Duration) داخل بايثون
-    """
-    if not timestamp_str:
-        return "--:--:--"
-    try:
-        try:
-            start_time = datetime.fromisoformat(str(timestamp_str))
-        except ValueError:
-            start_time = datetime.strptime(str(timestamp_str), "%Y-%m-%dT%H:%M:%S.%f")
-            
-        now = datetime.now()
-        diff = now - start_time
-        total_seconds = int(diff.total_seconds())
+class TradeManager:
+    def __init__(self, r2_service, data_manager, titan_engine, pattern_engine, guard_engine=None, sniper_engine=None, deep_steward=None): 
+        self.r2 = r2_service
+        self.data_manager = data_manager
+        self.titan = titan_engine
+        self.pattern_engine = pattern_engine
+        
+        # ⚠️ GuardEngine (Old V1) - معطل تماماً
+        self.guard = guard_engine 
+        
+        self.sniper = sniper_engine 
+        
+        # [ 🧠 ] Hybrid Deep Steward (V2 Radar + V3 Sniper)
+        self.deep_steward = deep_steward
+        
+        self.open_positions = {}
+        self.watchlist = {}
+        self.sentry_tasks = {}
+        self.running = True
+        
+        # [ 🧠 IQ Stats ] مخزن الإحصائيات (سجلات فقط - المال في R2)
+        # Hybrid: كل الصفقات التي أغلقها الذكاء الاصطناعي
+        # V2: إحصائيات خاصة عندما كان V2 مرتفعاً
+        # V3: إحصائيات خاصة عندما كان V3 مرتفعاً
+        self.ai_stats = {
+            "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
+            "v2":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
+            "v3":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0}
+        }
         
-        days = total_seconds // 86400
-        hours = (total_seconds % 86400) // 3600
-        minutes = (total_seconds % 3600) // 60
-        seconds = total_seconds % 60
+        # للإبقاء على التوافق مع الكود القديم الذي قد يطلب ds_stats مباشرة
+        self.ds_stats = self.ai_stats["hybrid"]
         
-        if days > 0:
-            return f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
-        return f"{hours:02}:{minutes:02}:{seconds:02}"
-    except Exception:
-        return "--:--:--"
-
-# ==============================================================================
-# 🤖 [Auto-Pilot Daemon] حلقة الطيار الآلي
-# ==============================================================================
-async def auto_pilot_loop():
-    """
-    مهمة تعمل في الخلفية بشكل دائم للتحقق من خلو النظام من الصفقات وبدء التحليل فوراً.
-    """
-    print("🤖 [Auto-Pilot] المحرك يعمل في الخلفية...")
-    while True:
-        try:
-            # ننتظر قليلاً لحماية الموارد (10 ثواني راحة بين الفحوصات)
-            await asyncio.sleep(10)
+        self.execution_lock = asyncio.Lock()
+        
+        print(f"🛡️ [TradeManager V22.4] Initialized. Hybrid Guardian Active (Limit: 300).")
 
-            if not sys_state.ready: continue
-            
-            # الشروط الثلاثة للتشغيل التلقائي:
-            if sys_state.auto_pilot and not sys_state.cycle_running:
-                if trade_manager and len(trade_manager.open_positions) == 0:
-                    # تشغيل الدورة
-                    asyncio.create_task(run_unified_cycle())
-                    # ننتظر فترة أطول قليلاً بعد إطلاق الدورة لمنع التكرار الفوري
-                    await asyncio.sleep(5) 
-                else:
-                    # إذا كانت هناك صفقة، الطيار الآلي يراقب فقط ولا يتدخل في الدورة
-                    pass 
+    async def initialize_sentry_exchanges(self):
+        print("🛡️ [TradeManager] Initializing and syncing state with R2...")
+        await self.sync_internal_state_with_r2()
 
+    async def sync_internal_state_with_r2(self):
+        try:
+            open_trades_list = await self.r2.get_open_trades_async()
+            self.open_positions = {trade['symbol']: trade for trade in open_trades_list}
+            print(f"   -> [Sync] تم استعادة {len(self.open_positions)} صفقة مفتوحة من R2.")
         except Exception as e:
-            print(f"⚠️ [Auto-Pilot Error] {e}")
-            await asyncio.sleep(30) # انتظار أطول عند الخطأ
-
-# ==============================================================================
-# 🚀 تهيئة التطبيق ودورة الحياة (Lifespan)
-# ==============================================================================
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global r2, data_manager, ml_processor, trade_manager, oracle_engine
-    global whale_monitor, news_fetcher, senti_analyzer, sniper_engine
-    global deep_steward, sys_state
-    
-    print("🚀 [FastAPI] بدء التشغيل (Startup Event)...")
-    print("------------------------------------------------------")
-    
-    try:
-        print("   [1/8] تهيئة R2Service...")
-        r2 = R2Service()
-        print("   [2/8] تهيئة DataManager...")
-        data_manager = DataManager(contracts_db={}, whale_monitor=None, r2_service=r2)
-        await data_manager.initialize() 
-        await data_manager.load_contracts_from_r2()
-        print("   [3/8] تهيئة L2 Services (Whales, News, Sentiment)...")
-        whale_monitor = EnhancedWhaleMonitor(contracts_db=data_manager.get_contracts_db(), r2_service=r2)
-        news_fetcher = NewsFetcher()
-        senti_analyzer = SentimentIntensityAnalyzer()
-        data_manager.whale_monitor = whale_monitor
-        print(f"   [4/8] تهيئة OracleEngine (L3 Brain) من {UNIFIED_MODELS_DIR}...")
-        oracle_engine = OracleEngine(model_dir=UNIFIED_MODELS_DIR)
-        await oracle_engine.initialize()
-        print("   [5/8] (تم تخطي LearningHub - مدمج في Oracle)")
-        print("   [6/8] تهيئة MLProcessor (L1 Engine)...")
-        ml_processor = MLProcessor(market_context=None, data_manager=data_manager, learning_hub=None) 
-        await ml_processor.initialize()
+            print(f"❌ [TradeManager] فشل فادح في مزامنة R2 (get_open_trades_async): {e}")
+            self.open_positions = {} 
+
+    # ==============================================================================
+    # 🎯 دوال الفرز والتنفيذ (L4 Sniper Logic)
+    # ==============================================================================
+    async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
+        if len(self.open_positions) > 0:
+             print(f"⛔ [TradeManager] تم إلغاء الفرز. توجد صفقة مفتوحة بالفعل.")
+             return
+
+        if self.sniper and not self.sniper.initialized:
+            try:
+                print("   -> [Lazy Load] 🎯 تهيئة SniperEngine V3 (Batch Select) عند الطلب...")
+                await self.sniper.initialize()
+            except Exception as e:
+                print(f"❌ [Lazy Load] فشل فادح في تهيئة SniperEngine: {e}")
+                self.sniper = None
         
-        print("   [7/8] تهيئة SniperEngine (L2 Entry Sniper)...")
-        sniper_engine = SniperEngine(models_dir=SHARED_GUARD_MODELS_DIR) 
-        await sniper_engine.initialize()
-        sniper_engine.set_entry_threshold(0.35) 
+        if not self.sniper or not self.sniper.initialized:
+            print("⚠️ [TradeManager] SniperEngine V3 غير جاهز للفرز. تم الإلغاء.")
+            return
+
+        sniper_candidates = []
         
-        # [ 🧠 ] تهيئة Hybrid Deep Steward (V4 Dual Brain)
-        print(f"   [8/8] تهيئة Hybrid Guardian (V2 + V3)...")
-        deep_steward = HybridDeepSteward(
-            v2_model_path=V2_MODEL_PATH,
-            v3_model_path=V3_MODEL_PATH,
-            v3_features_map_path=V3_FEATURES_PATH
-        )
+        for signal in oracle_approved_signals:
+            symbol = signal['symbol']
+            
+            if symbol in self.open_positions or symbol in self.watchlist:
+                print(f"   -> [L4 Skip] {symbol} موجودة مسبقاً في الصفقات أو المراقبة.")
+                continue
+
+            print(f"   -> [L4 Check] {symbol} التحقق من L4 (Sniper)...")
+            ohlcv_1m = await self.data_manager.get_latest_ohlcv(symbol, '1m', 600)
+            
+            if not ohlcv_1m or len(ohlcv_1m) < self.sniper.LOOKBACK_WINDOW:
+                print(f"   -> [L4 Skip] {symbol} بيانات 1m غير كافية للقناص ({len(ohlcv_1m)} < {self.sniper.LOOKBACK_WINDOW}).")
+                continue
+
+            sniper_result = await self.sniper.check_entry_signal_async(ohlcv_1m)
+            
+            if sniper_result['signal'] == 'BUY':
+                confidence = sniper_result['confidence_prob']
+                threshold = sniper_result.get('threshold', self.sniper.threshold)
+                print(f"   -> [L4 PASS] {symbol} (Conf: {confidence:.2f} >= {threshold:.2f}). أضيف للفرز النهائي.")
+                
+                signal['l2_sniper_result'] = sniper_result
+                signal['sniper_confidence'] = confidence
+                sniper_candidates.append(signal)
+            else:
+                confidence = sniper_result.get('confidence_prob', 0.0)
+                threshold = sniper_result.get('threshold', self.sniper.threshold)
+                print(f"   -> [L4 REJECT] {symbol} (Conf: {confidence:.2f} < {threshold:.2f}).")
+
+        if not sniper_candidates:
+            print("   -> [L4 Result] القناص رفض جميع الإشارات المعتمدة من العقل. لا يوجد تنفيذ.")
+            return
+
+        sniper_candidates.sort(key=lambda x: (x['sniper_confidence'], x['final_total_score']), reverse=True)
         
-        if deep_steward.initialize():
-            print("   ✅ [Hybrid Guardian] جاهز للعمل: V2 (Radar) + V3 (Sniper).")
-        else:
-            print("   ⚠️ [Hybrid Guardian] فشل التحميل! سيعمل النظام بدون حماية AI.")
-
-        print("   [FINAL] تهيئة TradeManager...")
-        trade_manager = TradeManager(
-            r2_service=r2, 
-            data_manager=data_manager, 
-            titan_engine=ml_processor.titan, 
-            pattern_engine=ml_processor.pattern_engine,
-            guard_engine=None, 
-            sniper_engine=sniper_engine,
-            deep_steward=deep_steward # تمرير الحارس الهجين
-        )
-        await trade_manager.initialize_sentry_exchanges()
-        await trade_manager.start_sentry_loops()
+        best_signal = sniper_candidates[0]
         
-        sys_state.set_ready()
+        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} (Sniper: {best_signal['sniper_confidence']:.2f}, L2: {best_signal['final_total_score']:.2f})")
         
-        asyncio.create_task(auto_pilot_loop())
-        print("   -> 🤖 تم تشغيل خدمة الطيار الآلي (Auto-Pilot Daemon).")
+        if len(sniper_candidates) > 1:
+            for i, loser in enumerate(sniper_candidates[1:]):
+                print(f"       -> (خسرت أمامها: {i+2}. {loser['symbol']} (Sniper: {loser['sniper_confidence']:.2f}, L2: {loser['final_total_score']:.2f}))")
 
-        print("------------------------------------------------------")
-        print("✅ [System READY] جميع الوحدات تم تهيئتها بنجاح.")
-        print("------------------------------------------------------")
-        
-        yield
-    
-    except Exception as e:
-        print(f"❌ [FATAL STARTUP ERROR] فشل فادح أثناء بدء التشغيل: {e}")
-        traceback.print_exc()
-
-    finally:
-        print("\n🛑 [FastAPI] بدء إيقاف التشغيل (Shutdown Event)...")
-        sys_state.ready = False
-        if trade_manager: await trade_manager.stop_sentry_loops()
-        if data_manager: await data_manager.close()
-        print("✅ [System SHUTDOWN] تم إغلاق جميع الاتصالات.")
-
-# ==============================================================================
-# 🧠 دوال التحليل المساعدة
-# ==============================================================================
-async def _analyze_symbol_task(symbol: str) -> Dict[str, Any]:
-    global data_manager, ml_processor
-    try:
-        required_tfs = ["5m", "15m", "1h", "4h", "1d"]
-        data_tasks = [data_manager.get_latest_ohlcv(symbol, tf, limit=250) for tf in required_tfs]
-        all_data = await asyncio.gather(*data_tasks)
-        
-        ohlcv_data = {}
-        for tf, data in zip(required_tfs, all_data):
-            if data and len(data) > 0: ohlcv_data[tf] = data
+        async with self.execution_lock:
+            if len(self.open_positions) > 0:
+                print(f"⛔ [TradeManager] تم إلغاء التنفيذ في اللحظة الأخيرة. توجد صفقة مفتوحة.")
+                return
 
-        if '5m' not in ohlcv_data or '15m' not in ohlcv_data or '1h' not in ohlcv_data or '4h' not in ohlcv_data:
-            return None
-            
-        current_price = await data_manager.get_latest_price_async(symbol)
-        raw_data = {'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': current_price}
-        return await ml_processor.process_and_score_symbol_enhanced(raw_data)
-    except Exception as e:
-        return None
-
-# ==============================================================================
-# [ 🚀 🚀 🚀 ] الدورة الموحدة (Unified Cycle)
-# ==============================================================================
-async def run_unified_cycle():
-    
-    log_buffer = StringIO()
-    
-    def log_and_print(message):
-        print(message)
-        log_buffer.write(message + '\n')
-
-    if sys_state.cycle_running:
-        log_and_print("⚠️ [Cycle] الدورة الحالية لا تزال قيد التشغيل. تم تجاهل الطلب.")
-        return
-    
-    if not sys_state.ready:
-        log_and_print("⚠️ [Cycle] تم تجاهل الدورة، النظام لم يكتمل تهيئته.")
-        return
-
-    sys_state.set_cycle_start()
-    log_and_print(f"\n🌀 [Cycle START] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    
-    try:
-        # 1. التحقق الحاسم من الصفقات المفتوحة من R2
-        await trade_manager.sync_internal_state_with_r2()
-        
-        # ============================================================
-        # 🔬 وضع الإدارة الذكية (Smart Management by Hybrid Guardian)
-        # ============================================================
-        if len(trade_manager.open_positions) > 0:
-            symbol = list(trade_manager.open_positions.keys())[0]
-            trade = trade_manager.open_positions[symbol]
+            if best_signal['symbol'] in self.open_positions:
+                print(f"   -> [L4 EXEC SKIP] {best_signal['symbol']} تم فتحها بواسطة عملية أخرى للتو.")
+                return
             
-            log_and_print(f"🔒 [HybridGuardian] الصفقة {symbol} نشطة وتحت الحراسة المشددة.")
-            log_and_print(f"   -> المراقبة تتم كل 60 ثانية في الخلفية (V2 Radar + V3 Sniper).")
-            log_and_print(f"   -> باقي نماذج البحث (L1/L2/L3) في وضع السكون لتوفير الموارد.")
+            await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
+
+    # ==============================================================================
+    # 🎯 تنفيذ الدخول (Entry Execution)
+    # ==============================================================================
+    async def _execute_entry_from_signal(self, symbol, signal_data):
+        try:
+            if len(self.open_positions) > 0:
+                print(f"⛔ [Entry BLOCKED] لا يمكن فتح {symbol}، توجد صفقة مفتوحة بالفعل.")
+                return
+
+            trade_id = str(uuid.uuid4())
+            current_price = float(signal_data.get('current_price', 0.0))
             
-            # فحص طوارئ سريع (فقط للتأكيد)
-            current_price = await data_manager.get_latest_price_async(symbol)
-            log_and_print(f"   -> السعر الحالي: {format_crypto_price(current_price)}")
+            if current_price <= 0.0:
+                 current_price = await self.data_manager.get_latest_price_async(symbol)
+                 if current_price <= 0.0:
+                    print(f"⚠️ [Entry ERROR] {symbol} السعر 0، لا يمكن التنفيذ.")
+                    return
+
+            l2_result = signal_data.get('l2_sniper_result', {})
+            l2_confidence = l2_result.get('confidence_prob', 0.0)
+            l2_threshold = l2_result.get('threshold', 0.0)
+
+            tp_price = signal_data.get('tp_price')
+            sl_price = signal_data.get('sl_price')
+
+            if not tp_price or not sl_price:
+                print(f"   -> [Entry Info] {symbol} لم يوفر العقل أهدافاً، جاري الحساب الوهمي.")
+                atr_mock = current_price * 0.02 
+                tp_price = current_price + (atr_mock * 2.0)
+                sl_price = current_price - (atr_mock * 1.0)
             
-            # --- [NEW] استشارة الحارس وعرض الطوابع في السجلات ---
-            try:
-                log_and_print("   -> 📡 جاري طلب تقرير الحارس المباشر (Consultation Scan)...")
+            tp_price = float(tp_price)
+            sl_price = float(sl_price)
+
+            if tp_price <= current_price or sl_price >= current_price:
+                 print(f"⚠️ [Entry ERROR] {symbol} أهداف TP/SL غير صالحة. إلغاء.")
+                 return
+
+            new_trade = {
+                'id': trade_id,
+                'symbol': symbol,
+                'entry_price': current_price,
+                'entry_time': datetime.now().isoformat(),
+                'status': 'OPEN',
+                'tp_price': tp_price,
+                'sl_price': sl_price,
+                'last_update': datetime.now().isoformat(),
                 
-                # [CRITICAL FIX] رفع الحد إلى 300 شمعة لضمان عمل المؤشرات
-                t1 = data_manager.get_latest_ohlcv(symbol, '1m', 300)
-                t5 = data_manager.get_latest_ohlcv(symbol, '5m', 200)
-                t15 = data_manager.get_latest_ohlcv(symbol, '15m', 100)
-                
-                d1, d5, d15 = await asyncio.gather(t1, t5, t15)
-                
-                if d1 and d5 and d15 and len(d1) >= 200:
-                    decision = deep_steward.analyze_position(d1, d5, d15, float(trade['entry_price']))
-                    scores = decision.get('scores', {'v2': 0.0, 'v3': 0.0})
-                    
-                    log_and_print(f"\n   📊 [GUARDIAN LIVE REPORT]")
-                    log_and_print(f"      • Decision: {decision.get('action')} ({decision.get('reason')})")
-                    log_and_print(f"      • V2 (Radar):  {scores.get('v2', 0.0):.4f}  [Safe < {deep_steward.V2_SAFE_LIMIT} | Panic > {deep_steward.V2_PANIC_TRIGGER}]")
-                    log_and_print(f"      • V3 (Sniper): {scores.get('v3', 0.0):.4f}  [Hard > {deep_steward.V3_HARD_EXIT} | Ultra > {deep_steward.V3_ULTRA_CONF}]")
-                else:
-                    log_and_print("   ⚠️ بيانات السوق غير كافية للتحليل اللحظي الآن (Requires 200+ candles).")
-            except Exception as e:
-                log_and_print(f"   ⚠️ تعذر عرض تقرير الحارس: {e}")
+                'l1_score': float(signal_data.get('final_total_score', 0.0)), 
+                'l1_components': signal_data.get('components', {}),
+                'l2_sniper_confidence': float(l2_confidence),
+                'l2_sniper_threshold': float(l2_threshold),
+                'l3_oracle_tp': float(signal_data.get('tp_price', 0.0) or 0.0),
+                'l3_oracle_sl': float(signal_data.get('sl_price', 0.0) or 0.0),
+            }
             
-            sys_state.set_cycle_end(logs=log_buffer.getvalue())
-            return 
+            self.open_positions[symbol] = new_trade
+            
+            if self.watchlist:
+                print(f"   -> [Watchlist] مسح {len(self.watchlist)} عنصر من قائمة المراقبة.")
+                self.watchlist.clear()
+            
+            # ============================================================
+            # 🕒 تسجيل وقت أول صفقة في تاريخ النظام (للعداد)
+            # ============================================================
+            portfolio = await self.r2.get_portfolio_state_async()
+            if portfolio.get('first_trade_timestamp') is None:
+                portfolio['first_trade_timestamp'] = new_trade['entry_time']
+                await self.r2.save_portfolio_state_async(portfolio)
+                print(f"🕒 [System Info] تم تسجيل توقيت أول صفقة في النظام: {new_trade['entry_time']}")
+            # ============================================================
+
+            await self.r2.save_open_trades_async(list(self.open_positions.values()))
+            
+            if symbol in self.sentry_tasks:
+                self.sentry_tasks[symbol].cancel()
+            
+            self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
+            
+            print(f"✅ [ENTRY EXECUTED] {symbol} | Price: {current_price:.8f} | TP: {tp_price:.8f} | SL: {sl_price:.8f}")
+            print(f"   -> L2 Score: {new_trade['l1_score']:.2f}, L4 Conf: {new_trade['l2_sniper_confidence']:.2f}")
 
-        # ============================================================
-        # 🔍 وضع البحث (Scanning Mode) - Normal Flow (مستعاد بالكامل)
-        # ============================================================
-        
-        # --- 1. الغربلة الأولية (L1) ---
-        log_and_print("   [Cycle 1/5] 🔍 بدء الغربلة السريعة (L1 Screening)...")
-        candidates_to_analyze = await data_manager.layer1_rapid_screening()
-        
-        if not candidates_to_analyze:
-            log_and_print("⚠️ [Cycle] لا توجد مرشحات من L1. إنهاء.")
-            sys_state.set_cycle_end(logs=log_buffer.getvalue()); return
+        except Exception as e:
+            print(f"❌ [TradeManager] فشل فادح أثناء تنفيذ الدخول لـ {symbol}: {e}")
+            traceback.print_exc()
+
+    # ==============================================================================
+    # 👁️ Watchlist Functions
+    # ==============================================================================
+    async def _add_to_watchlist(self, symbol, signal_data):
+        if symbol not in self.open_positions and symbol not in self.watchlist:
+            if self.open_positions:
+                print(f"👀 [Watchlist] {symbol} تم تجاهله (توجد صفقة أخرى مفتوحة).")
+                return
+                
+            self.watchlist[symbol] = signal_data
+            print(f"👀 [Watchlist] {symbol} تمت إضافته للمراقبة (L1 Score: {signal_data['enhanced_final_score']:.2f})")
+
+    async def _find_signal_in_watchlist(self):
+        if not self.watchlist:
+            return
             
-        log_and_print(f"   -> 🧠 بدء تحليل L1 المعمق لـ {len(candidates_to_analyze)} عملة...")
-        analysis_start_time = time.time()
-        
-        tasks = [_analyze_symbol_task(cand['symbol']) for cand in candidates_to_analyze if cand.get('symbol')]
-        results = await asyncio.gather(*tasks)
+        if self.open_positions:
+            print("   -> [Watchlist] تم تخطي البحث (توجد صفقة مفتوحة). مسح المراقب...")
+            self.watchlist.clear()
+            return
+            
+        if self.sniper and not self.sniper.initialized:
+            try:
+                print("   -> [Lazy Load] 🎯 تهيئة SniperEngine V3 (Watchlist) عند الطلب...")
+                await self.sniper.initialize()
+            except Exception as e:
+                print(f"❌ [Lazy Load] فشل فادح في تهيئة SniperEngine (Watchlist): {e}")
+                self.sniper = None
         
-        valid_l1_results = [res for res in results if res is not None]
-        top_10_l1 = sorted(valid_l1_results, key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)[:10]
+        if not self.sniper or not self.sniper.initialized:
+            return 
+
+        watchlist_symbols = list(self.watchlist.keys())
+        if not watchlist_symbols:
+            return
+
+        print(f"   -> [Watchlist] فحص {len(watchlist_symbols)} عملة في قائمة المراقبة لـ L4...")
         
-        log_and_print(f"   -> 🧠 انتهى تحليل L1 في {time.time() - analysis_start_time:.2f} ثانية.")
-        log_and_print(f"       - ✅ نجح: {len(valid_l1_results)} إشارة مرشحة.")
+        signals_from_watchlist = []
+        for symbol in watchlist_symbols:
+            signal_data = self.watchlist.get(symbol)
+            if not signal_data: continue
+            signals_from_watchlist.append(signal_data)
         
-        if top_10_l1:
-            log_and_print(f"\n       -> 🥇 أعلى 10 درجات في الطبقة الأولى (L1):")
-            for i, res in enumerate(top_10_l1):
-                components = res.get('components', {})
-                titan_s = components.get('titan_score', 0.0)
-                pattern_s = components.get('patterns_score', 0.0)
-                mc_s = components.get('mc_score', 0.0)
-                log_and_print(f"           {i+1}. {res.get('symbol'):<10}: {res.get('enhanced_final_score', 0.0):.4f} [T: {titan_s:.2f} | P: {pattern_s:.2f} | M: {mc_s:.2f}]")
-        else:
-            log_and_print("       -> ⚠️ لم يتم العثور على أي عملات صالحة.")
-            sys_state.set_cycle_end(logs=log_buffer.getvalue()); return
+        if signals_from_watchlist:
+            await self.select_and_execute_best_signal(signals_from_watchlist)
 
-        # --- 2. التعزيز وحساب نقاط الطبقة الثانية (L2 Boosting) ---
-        log_and_print(f"\n   [Cycle 2/5] 🚀 بدء تعزيز النقاط (L2 Boosting) لأفضل 10 عملات...")
-        l2_enriched_candidates = []
+    # ==============================================================================
+    # 🛡️ دوال حارس الخروج (Hybrid Sentry)
+    # ==============================================================================
+    async def _guardian_loop(self, symbol: str):
+        print(f"🛡️ [Sentry Activated] بدء الحراسة لـ {symbol} (فحص كل 60 ثانية).")
         
-        for candidate in top_10_l1:
-            symbol = candidate['symbol']
-            l1_score = candidate['enhanced_final_score']
-            whale_score = 0.0; whale_raw_str = "No Data"
-            news_score = 0.0; news_raw_str = "No Data"
-            adv_mc_score = 0.0; mc_raw_str = "No Data"
-            
-            # (أ. بيانات الحيتان)
+        while self.running and symbol in self.open_positions:
             try:
-                whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
-                net_flow = whale_data.get('accumulation_analysis_24h', {}).get('net_flow_usd', 0.0)
-                whale_raw_str = f"${net_flow:,.0f}"
-                if net_flow <= -500000: whale_score = 0.10
-                elif net_flow < 0: whale_score = 0.05
-            except Exception as e: log_and_print(f"       ⚠️ [Whale Error] {symbol}: {e}")
-            candidate['whale_data'] = {} 
-
-            # (ب. الأخبار)
-            try:
-                news_item = await news_fetcher.get_news(symbol)
-                if news_item:
-                    news_text = news_item.get('summary', 'No news')
-                    sentiment = senti_analyzer.polarity_scores(news_text)
-                    compound = sentiment['compound']
-                    news_raw_str = f"{compound:.2f}"
-                    if compound >= 0.5: news_score = 0.05
-                    elif compound >= 0.1: news_score = 0.02
-            except Exception as e: log_and_print(f"       ⚠️ [News Error] {symbol}: {e}")
-            candidate['news_text'] = "..." 
-
-            # (ج. مونت كارلو المتقدمة)
-            try:
-                full_ohlcv_1h = await data_manager.get_latest_ohlcv(symbol, '1h', limit=100)
-                if full_ohlcv_1h and len(full_ohlcv_1h) >= 30:
-                    mc_data = {'1h': full_ohlcv_1h}
-                    mc_res = await ml_processor.mc_analyzer.generate_1h_distribution_advanced(mc_data)
-                    if mc_res and not mc_res.get('error', False):
-                        prob_gain = mc_res.get('probability_of_gain', 0.5)
-                        mc_raw_str = f"{prob_gain:.2f}"
-                        if prob_gain > 0.5: adv_mc_score = min(0.10, (prob_gain - 0.5) * 0.20)
-            except Exception as e: log_and_print(f"       ⚠️ [MC Exception] {symbol}: {e}")
+                # 🚀 1. الانتظار لمدة 60 ثانية
+                await asyncio.sleep(60) 
                 
-            final_score = l1_score + whale_score + news_score + adv_mc_score
-            candidate['final_total_score'] = final_score
-            candidate['l2_scores'] = {'whale': whale_score, 'news': news_score, 'adv_mc': adv_mc_score}
-            candidate['l2_raw_values'] = {'whale': whale_raw_str, 'news': news_raw_str, 'adv_mc': mc_raw_str}
-            l2_enriched_candidates.append(candidate)
-
-        # --- 3. إعادة الترتيب وطباعة الجدول ---
-        log_and_print(f"   [Cycle 3/5] 📊 إعادة ترتيب ال��رشحين حسب الدرجة النهائية (L1 + L2)...")
-        sorted_finalists = sorted(l2_enriched_candidates, key=lambda x: x['final_total_score'], reverse=True)
-        
-        log_and_print("\n" + "="*135)
-        header = f"{'SYMBOL':<10} | {'L1 SCORE':<8} | {'WHALE (Flow)':<22} | {'NEWS (Sent)':<18} | {'ADV MC (Prob)':<18} | {'FINAL':<8}"
-        log_and_print(header)
-        log_and_print("-" * 135)
-        for cand in sorted_finalists:
-            sym = cand['symbol']; l1 = cand['enhanced_final_score']; l2 = cand['l2_scores']; l2_raw = cand['l2_raw_values']; final = cand['final_total_score']
-            whale_cell = f"{l2['whale']:.2f} ({l2_raw['whale']})"
-            news_cell = f"{l2['news']:.2f} ({l2_raw['news']})"
-            mc_cell = f"{l2['adv_mc']:.2f} ({l2_raw['adv_mc']})"
-            log_and_print(f"{sym:<10} | {l1:.4f}   | {whale_cell:<22} | {news_cell:<18} | {mc_cell:<18} | {final:.4f}")
-        log_and_print("="*135 + "\n")
-
-        # --- 4. اختيار أفضل 5 للنموذج الضخم (Oracle) ---
-        top_5_candidates = sorted_finalists[:5]
-        log_and_print(f"   [Cycle 4/5] 🧠 إرسال أفضل {len(top_5_candidates)} عملة للعقل الاحتمالي (Oracle Engine)...")
-        
-        oracle_start_time = time.time()
-        oracle_approved_signals = []
-        
-        for signal in top_5_candidates:
-            symbol = signal['symbol']
-            if signal['final_total_score'] < 0.60: 
-                log_and_print(f"   -> 🛑 {symbol} تم استبعاده (الدرجة النهائية {signal['final_total_score']:.2f} < 0.60)")
-                continue
-            log_and_print(f"   -> 🧠 [Oracle Scan] جاري فحص {symbol}...")
-            try:
-                oracle_decision = await oracle_engine.predict(signal)
-                action = oracle_decision.get('action'); confidence = oracle_decision.get('confidence', 0.0)
-                reason = oracle_decision.get('analysis_summary') or oracle_decision.get('reason', 'No summary provided')
-                if action == 'WATCH': 
-                    log_and_print(f"       🔥 [Oracle APPROVED] {symbol} (Conf: {confidence:.2f})")
-                    log_and_print(f"           📝 Reason: {reason}")
-                    signal['tp_price'] = oracle_decision.get('tp_price')
-                    signal['sl_price'] = oracle_decision.get('sl_price')
-                    oracle_approved_signals.append(signal)
+                trade = self.open_positions.get(symbol)
+                if not trade: break 
+
+                current_price = await self.data_manager.get_latest_price_async(symbol)
+                if current_price == 0.0: continue 
+
+                # 🚀 2. فحص الحدود الصارمة (Hard Limits) - أمان أخير
+                if current_price >= trade['tp_price']:
+                    print(f"✅ [Sentry EXIT] {symbol} (Hard TP Hit) at {current_price:.8f}")
+                    async with self.execution_lock:
+                        await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
+                    break 
+
+                if current_price <= trade['sl_price']:
+                    print(f"🛑 [Sentry EXIT] {symbol} (Hard SL Hit) at {current_price:.8f}")
+                    async with self.execution_lock:
+                        await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
+                    break 
+
+                # 🚀 3. [ 🧠 ] Hybrid DeepSteward (V2 + V3 Dual Brain)
+                if self.deep_steward and self.deep_steward.initialized:
+                    # --- [تعديل جوهري] زيادة الحد إلى 300 شمعة لتجنب أخطاء النموذج ---
+                    task1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
+                    task5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
+                    task15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
+                    
+                    d1, d5, d15 = await asyncio.gather(task1, task5, task15)
+                    
+                    # التأكد من وجود بيانات كافية (V2 يحتاج 64 شمعة، المؤشرات تحتاج 200)
+                    if d1 and d5 and d15 and len(d1) >= 200:
+                        # استشارة الحارس الهجين
+                        decision = self.deep_steward.analyze_position(d1, d5, d15, trade['entry_price'])
+                        action = decision.get('action', 'HOLD')
+                        scores = decision.get('scores', {}) # درجات V2 و V3 للتدقيق
+                        
+                        if action == 'EXIT_HARD':
+                            print(f"🤖 [Hybrid Guardian] 🚨 خروج طارئ! {decision['reason']}")
+                            async with self.execution_lock:
+                                await self._execute_exit(symbol, current_price, "AI_HARD_EXIT", ai_scores=scores)
+                            break
+                        
+                        elif action == 'EXIT_SOFT':
+                            print(f"🤖 [Hybrid Guardian] ⚠️ تحذير خروج! {decision['reason']}")
+                            # هنا يمكن إضافة منطق لتشديد الستوب بدلاً من الخروج المباشر
+                            async with self.execution_lock:
+                                await self._execute_exit(symbol, current_price, "AI_SOFT_EXIT", ai_scores=scores)
+                            break
+
+                    else:
+                        print(f"⚠️ [Sentry] بيانات الحارس الهجين غير مكتملة لـ {symbol} (Rows: {len(d1) if d1 else 0}). تخطي الدورة.")
                 else:
-                    log_and_print(f"       🛑 [Oracle REJECTED] {symbol} (Conf: {confidence:.2f})")
-                    log_and_print(f"           📝 Reason: {reason[:200]}...")
+                    pass # لا يوجد نموذج فعال
+
+                self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
+            
+            except asyncio.CancelledError:
+                print(f"🛡️ [Sentry STOP] تم إيقاف الحارس لـ {symbol}.")
+                break
             except Exception as e:
-                log_and_print(f"       ⚠️ [Oracle Error] فشل تحليل Oracle لـ {symbol}: {e}")
-                traceback.print_exc(file=log_buffer)
-                continue
+                print(f"❌ [Sentry ERROR] فشل مؤقت لـ {symbol}: {e}")
+                await asyncio.sleep(10) 
+
+    # ==============================================================================
+    # 👻 المراقب الشبحي (Ghost Monitor) - [محدث لتوزيع الإحصائيات]
+    # ==============================================================================
+    def _launch_post_exit_analysis(self, symbol, exit_price, exit_time, position_size_usd, ai_scores=None):
+        """يطلق مهمة خلفية لمراقبة السعر بعد الخروج وحساب الأثر بالدولار"""
+        asyncio.create_task(self._analyze_after_exit_task(symbol, exit_price, exit_time, position_size_usd, ai_scores))
+
+    def _update_specific_stat(self, key, is_good, usd_impact):
+        """دالة مساعدة لتحديث إحصائيات محفظة معينة (Hybrid, V2, V3)"""
+        if key not in self.ai_stats: return
+        self.ai_stats[key]["total"] += 1
+        if is_good:
+            self.ai_stats[key]["good"] += 1
+            self.ai_stats[key]["saved"] += abs(usd_impact)
+        else:
+            self.ai_stats[key]["missed"] += abs(usd_impact)
+
+    async def _analyze_after_exit_task(self, symbol, exit_price, exit_time, position_size_usd, ai_scores):
+        # ⏳ ننتظر 15 دقيقة (900 ثانية)
+        await asyncio.sleep(900) 
         
-        log_and_print(f"   -> 🧠 انتهى فحص Oracle في {time.time() - oracle_start_time:.2f} ثانية. (تمت الموافقة على {len(oracle_approved_signals)} إشارة)")
+        try:
+            current_price = await self.data_manager.get_latest_price_async(symbol)
+            if current_price == 0: return
 
-        # (إرسال المجموعة إلى TradeManager للفرز النهائي والتنفيذ)
-        if oracle_approved_signals:
-            log_and_print(f"   -> 🎯 [L4 Sniper Batch] إرسال {len(oracle_approved_signals)} إشارة للقناص للفرز النهائي واختيار الأفضل...")
+            # هل كان الخروج صحيحاً؟
+            change_pct = (current_price - exit_price) / exit_price
+            usd_impact = change_pct * position_size_usd
+            is_good_exit = change_pct < 0 # جيد إذا السعر هبط بعد الخروج
             
-            tm_log_buffer = StringIO()
-            with redirect_stdout(tm_log_buffer), redirect_stderr(tm_log_buffer):
-                await trade_manager.select_and_execute_best_signal(oracle_approved_signals)
+            # 1. تحديث إحصائيات النظام الهجين (الكل)
+            self._update_specific_stat("hybrid", is_good_exit, usd_impact)
             
-            tm_logs = tm_log_buffer.getvalue()
-            print(tm_logs) 
-            log_buffer.write(tm_logs + '\n')
-        else:
-            log_and_print("   -> 🎯 [L4 Sniper Batch] لا توجد إشارات معتمدة من العقل لإرسالها للقناص.")
+            # 2. توزيع الفضل (Attribution) لـ V2 و V3
+            if ai_scores:
+                v2_score = ai_scores.get('v2', 0.0)
+                v3_score = ai_scores.get('v3', 0.0)
+                
+                # V2 ينسب له الفضل إذا كانت درجة الخطر لديه عالية (فتح البوابة)
+                if v2_score >= 0.60:
+                    self._update_specific_stat("v2", is_good_exit, usd_impact)
+                
+                # V3 ينسب له الفضل إذا كانت درجة الثقة لديه عالية (ضغط الزناد)
+                if v3_score >= 0.75:
+                    self._update_specific_stat("v3", is_good_exit, usd_impact)
+
+            # إعداد السجل لـ R2
+            audit_record = {
+                "symbol": symbol,
+                "exit_time": exit_time,
+                "exit_price": exit_price,
+                "price_15m_later": current_price,
+                "change_15m_pct": change_pct * 100,
+                "usd_impact": usd_impact,
+                "verdict": "SUCCESS (Saved Loss)" if is_good_exit else "MISS (Lost Profit)",
+                "ai_scores": ai_scores if ai_scores else {},
+                "timestamp": datetime.now().isoformat()
+            }
             
-        # --- 5. الصيانة والتعلم ---
-        log_and_print(f"   [Cycle 5/5] 🧹 تنظيف الذاكرة...")
-        gc.collect()
-        log_and_print(f"🌀 [Cycle END] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        sys_state.set_cycle_end(logs=log_buffer.getvalue())
-
-    except Exception as e:
-        error_logs = f"❌ [Cycle ERROR] فشلت الدورة الموحدة: {e}\n{traceback.format_exc()}"
-        log_and_print(error_logs)
-        sys_state.set_cycle_end(error=e, logs=log_buffer.getvalue())
-
-# ==============================================================================
-# 🚦 نقاط النهاية (FastAPI Endpoints)
-# ==============================================================================
-app = FastAPI(
-    lifespan=lifespan, 
-    title="Titan V22.5 Pro (Hybrid Guardian + MultiStats)", 
-    description="نظام تداول آلي هجين (L1/L2/L3-ML) مع حارس ذكي مزدوج وواجهة Gradio مدمجة"
-)
-
-@app.get("/run-cycle")
-async def trigger_cycle_endpoint(background_tasks: BackgroundTasks):
-    if not sys_state.ready:
-        raise HTTPException(status_code=503, detail="System is still initializing.")
-    if sys_state.cycle_running:
-        raise HTTPException(status_code=429, detail="Cycle is already running.")
-        
-    background_tasks.add_task(run_unified_cycle)
-    return {"status": "ACCEPTED", "message": "Unified smart cycle triggered (Batch Mode)."}
-
-@app.get("/status") 
-async def get_full_status():
-    return {
-        "initialized": sys_state.ready,
-        "cycle_running": sys_state.cycle_running,
-        "active_trades_count": len(trade_manager.open_positions) if trade_manager else 0,
-        "active_trades": list(trade_manager.open_positions.keys()) if trade_manager else [],
-        "sentry_watchlist_count": len(trade_manager.watchlist) if trade_manager else 0,
-        "sentry_watchlist": list(trade_manager.watchlist.keys()) if trade_manager else []
-    }
-
-# ==============================================================================
-# 📊 [ 💡 GEM-ARCHITECT: UI LOGIC - FULL RESTORE & FIX ]
-# ==============================================================================
-
-async def manual_close_current_trade():
-    """دالة زر الإغلاق اليدوي"""
-    if not trade_manager.open_positions:
-        return "⚠️ لا توجد صفقة مفتوحة لإغلاقها."
-    
-    symbol = list(trade_manager.open_positions.keys())[0]
-    await trade_manager.force_exit_by_manager(symbol, reason="MANUAL_UI_BUTTON")
-    return f"✅ تم إرسال أمر إغلاق فوري لـ {symbol}."
-
-# [جديد] معالج زر التصفير
-async def reset_stats_handler():
-    """معالج زر التصفير"""
-    if len(trade_manager.open_positions) > 0:
-        return "⚠️ خطأ: يجب إغلاق الصفقات المفتوحة أولاً قبل التصفير!"
-    
-    success = await r2.reset_all_stats_async()
-    if success: return "✅ تم تصفير الحساب والسجلات بنجاح."
-    else: return "❌ فشل التصفير. راجع السجلات."
-
-# تبديل وضع الطيار الآلي (On/Off)
-async def toggle_auto_pilot(enable):
-    sys_state.auto_pilot = enable
-    status = "مفعل (ON)" if enable else "متوقف (OFF)"
-    return f"تم تغيير وضع الطيار الآلي إلى: {status}"
-
-async def check_live_pnl_and_status(selected_view="Hybrid System"):
-    """
-    تحديث الواجهة الدورية (مع دعم القائمة المنسدلة للإحصائيات)
-    """
-    global trade_manager, data_manager, sys_state, r2
-    
-    # Default Values
-    empty_chart = go.Figure()
-    empty_chart.update_layout(
-        template="plotly_dark", paper_bgcolor="#0b0f19", plot_bgcolor="#0b0f19",
-        xaxis={'visible': False}, yaxis={'visible': False},
-        annotations=[dict(text="Waiting for Signal...", x=0.5, y=0.5, showarrow=False, font=dict(color="gray", size=20))]
-    )
-    wl_df_empty = pd.DataFrame(columns=["Symbol", "Score"])
-    
-    if not sys_state.ready:
-        return "Initializing...", "...", empty_chart, "0.0", "0.0", "0.0", "0.0", "0.0%", wl_df_empty, "Loading...", "Loading..."
-
-    try:
-        # 1. Fetch Portfolio & Time
-        portfolio = await r2.get_portfolio_state_async()
-        curr_cap = portfolio.get('current_capital_usd', 100.0)
-        first_ts = portfolio.get('first_trade_timestamp')
-        
-        # 🕒 حساب وقت التشغيل (Uptime) في بايثون
-        uptime_str = calculate_duration_str(first_ts)
-        
-        total_t = portfolio.get('total_trades', 0)
-        wins = portfolio.get('winning_trades', 0)
-        losses = portfolio.get('losing_trades', 0)
-        if losses == 0 and total_t > 0: losses = total_t - wins
-        
-        tot_prof = portfolio.get('total_profit_usd', 0.0)
-        tot_loss = portfolio.get('total_loss_usd', 0.0)
-        net_prof = tot_prof - tot_loss
-        win_rate = (wins / total_t * 100) if total_t > 0 else 0.0
-
-        # 2. Active Trade Logic
-        symbol = None
-        entry_p = 0.0
-        tp_p = 0.0
-        sl_p = 0.0
-        curr_p = 0.0
-        pnl_val = 0.0
-        pnl_pct = 0.0
-        trade_dur_str = "--:--:--"
-        
-        if trade_manager.open_positions:
-            symbol = list(trade_manager.open_positions.keys())[0]
-            trade = trade_manager.open_positions[symbol]
+            await self.r2.append_deep_steward_audit(audit_record)
+            print(f"👻 [Ghost Monitor] {symbol}: {audit_record['verdict']} | Impact: ${usd_impact:.2f}")
+
+        except Exception as e:
+            print(f"⚠️ [Ghost Error] فشل تحليل ما بعد الخروج لـ {symbol}: {e}")
+
+    # ==============================================================================
+    # 🔴 دالة الخروج المحاسبية (Accounting Exit Logic)
+    # ==============================================================================
+    async def _execute_exit(self, symbol, price, reason, ai_scores=None):
+        if symbol not in self.open_positions:
+            print(f"⚠️ [Exit ERROR] {symbol} غير موجودة في الصفقات المفتوحة.")
+            return
+
+        try:
+            # 1. استخراج بيانات الصفقة
+            trade = self.open_positions.pop(symbol) 
             
-            entry_p = float(trade.get('entry_price', 0.0))
-            tp_p = float(trade.get('tp_price', 0.0))
-            sl_p = float(trade.get('sl_price', 0.0))
+            entry_price = float(trade['entry_price'])
+            exit_price = float(price)
             
-            # 🕒 حساب مدة الصفقة الحالية في بايثون
-            trade_dur_str = calculate_duration_str(trade.get('entry_time'))
+            # 2. حساب نسبة الربح
+            raw_profit_pct = (exit_price - entry_price) / entry_price
+            profit_pct_display = raw_profit_pct * 100
             
-            curr_p = await data_manager.get_latest_price_async(symbol)
-            if curr_p > 0 and entry_p > 0:
-                pnl_pct = ((curr_p - entry_p) / entry_p) * 100
-                pnl_val = curr_cap * (pnl_pct / 100)
-
-        final_bal = curr_cap + pnl_val
-        wallet_color = "#00ff00" if pnl_val >= 0 else "#ff0000"
-
-        # 3. 🎨 Wallet HTML (مع توقيتات بايثون)
-        wallet_md = f"""
-        <div style='background-color: #1a1a1a; padding: 15px; border-radius: 8px; border: 1px solid #333; text-align:center;'>
-            <h3 style='margin:0; color:#888; font-size:14px;'>💰 Live Wallet</h3>
-            <div style='font-size: 26px; font-weight: bold; color: white; margin: 5px 0;'>
-                ${final_bal:,.2f}
-            </div>
-            <div style='font-size: 14px; color: {wallet_color};'>
-                ({pnl_val:+,.2f} USD)
-            </div>
-            <hr style='border-color:#444; margin: 10px 0;'>
+            # 3. تحديث بيانات الصفقة
+            trade['status'] = 'CLOSED'
+            trade['exit_price'] = exit_price
+            trade['exit_time'] = datetime.now().isoformat()
+            trade['exit_reason'] = reason
+            trade['profit_pct'] = profit_pct_display
+
+            # 4. 💰 [المحاسبة] تحديث المحفظة (محفظة واحدة فقط)
+            portfolio = await self.r2.get_portfolio_state_async()
+            current_capital = float(portfolio.get('current_capital_usd', 100.0))
             
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc;'>
-                <span>⏳ Uptime:</span>
-                <span style='color: white; font-family: monospace;'>{uptime_str}</span>
-            </div>
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>⏱️ Trade Time:</span>
-                <span style='color: #00e5ff; font-family: monospace;'>{trade_dur_str}</span>
-            </div>
-        </div>
-        """
-
-        # 4. 🧠 [Dynamic Stats] جلب الإحصائيات بناءً على القائمة المنسدلة
-        key_map = {
-            "Hybrid System": "hybrid",
-            "Model V2 (Radar)": "v2",
-            "Model V3 (Sniper)": "v3"
-        }
-        target_key = key_map.get(selected_view, "hybrid")
-        
-        # Get stats safely
-        if hasattr(trade_manager, 'ai_stats'):
-            stats_data = trade_manager.ai_stats.get(target_key, {"total":0, "good":0, "saved":0.0, "missed":0.0})
-        else:
-            stats_data = {"total":0, "good":0, "saved":0.0, "missed":0.0}
+            pnl_usd = current_capital * raw_profit_pct
+            new_capital = current_capital + pnl_usd
+            
+            # تحديث الإحصائيات التراكمية
+            portfolio['current_capital_usd'] = new_capital
+            portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
+            
+            if pnl_usd >= 0:
+                portfolio['winning_trades'] = portfolio.get('winning_trades', 0) + 1
+                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0.0) + pnl_usd
+                trade['result'] = 'WIN'
+            else:
+                portfolio['losing_trades'] = portfolio.get('losing_trades', 0) + 1
+                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0.0) + abs(pnl_usd)
+                trade['result'] = 'LOSS'
+
+            # تحديث نسبة الفوز
+            total_t = portfolio['total_trades']
+            if total_t > 0:
+                portfolio['win_rate'] = (portfolio['winning_trades'] / total_t) * 100
+            
+            trade['pnl_usd'] = pnl_usd 
+            
+            # 5. حفظ البيانات في R2
+            await self.r2.save_portfolio_state_async(portfolio)
+            await self.r2.save_open_trades_async(list(self.open_positions.values()))
+            await self.r2.append_to_closed_trades_history(trade)
+            
+            print(f"✅ [EXIT EXECUTED] {symbol} | Reason: {reason} | PnL: {profit_pct_display:.2f}% (${pnl_usd:.2f}) | New Cap: ${new_capital:.2f}")
 
-        tot_ds = stats_data['total']
-        ds_acc = (stats_data['good'] / tot_ds * 100) if tot_ds > 0 else 0.0
-        
-        # Dynamic Title based on selection
-        title_map = {
-            "hybrid": "🧠 Hybrid Guardian IQ",
-            "v2": "📡 Model V2 (Radar)",
-            "v3": "🎯 Model V3 (Sniper)"
-        }
-        stats_title = title_map.get(target_key, "DeepSteward IQ")
-
-        history_md = f"""
-        <div style='background-color: #1a1a1a; padding: 10px; border-radius: 8px; border: 1px solid #333; font-size: 12px;'>
-            <h3 style='margin:0 0 5px 0; color:#888; font-size:14px;'>📊 Performance</h3>
-            <table style='width:100%; color:white; border-collapse: collapse;'>
-                <tr><td style='padding:2px;'>Total Trades:</td><td style='text-align:right; font-weight:bold;'>{total_t}</td></tr>
-                <tr><td style='padding:2px;'>Win Rate:</td><td style='text-align:right; color:{"#00ff00" if win_rate>=50 else "#ff0000"};'>{win_rate:.1f}%</td></tr>
-                <tr><td style='padding:2px;'>Wins:</td><td style='text-align:right; color:#00ff00;'>{wins} (+${tot_prof:,.2f})</td></tr>
-                <tr><td style='padding:2px;'>Losses:</td><td style='text-align:right; color:#ff0000;'>{losses} (-${tot_loss:,.2f})</td></tr>
-                <tr><td style='border-top:1px solid #444; padding-top:5px;'>Net Profit:</td><td style='border-top:1px solid #444; text-align:right; padding-top:5px; color:{"#00ff00" if net_prof>=0 else "#ff0000"};'>${net_prof:,.2f}</td></tr>
-            </table>
+            # 6. [ 🧠 ] إطلاق المراقب الشبحي إذا كان الخروج بسبب الذكاء الاصطناعي
+            if "AI_" in reason:
+                self._launch_post_exit_analysis(symbol, exit_price, trade['exit_time'], current_capital, ai_scores)
+
+            # 7. تنظيف مهام الحارس
+            if symbol in self.sentry_tasks:
+                self.sentry_tasks[symbol].cancel()
+                del self.sentry_tasks[symbol]
+
+        except Exception as e:
+            print(f"❌ [TradeManager] فشل فادح أثناء تنفيذ الخروج لـ {symbol}: {e}")
+            traceback.print_exc()
+            if symbol not in self.open_positions:
+                 self.open_positions[symbol] = trade 
+
+    # [جديد] دالة للخروج القسري من واجهة المستخدم
+    async def force_exit_by_manager(self, symbol, reason):
+        print(f"⚠️ [Manager Force Exit] طلب خروج إداري لـ {symbol} بسبب: {reason}")
+        current_price = await self.data_manager.get_latest_price_async(symbol)
+        async with self.execution_lock:
+            await self._execute_exit(symbol, current_price, reason)
+
+    async def update_trade_targets(self, symbol, new_tp=None, new_sl=None, reason="MANUAL"):
+        if symbol in self.open_positions:
+            trade = self.open_positions[symbol]
+            old_tp = trade['tp_price']
+            old_sl = trade['sl_price']
             
-            <hr style='border-color:#444; margin: 8px 0;'>
+            if new_tp is not None: trade['tp_price'] = float(new_tp)
+            if new_sl is not None: trade['sl_price'] = float(new_sl)
             
-            <h3 style='margin:0 0 5px 0; color: #00e5ff; font-size:14px;'>{stats_title}</h3>
-            <table style='width:100%; color:white;'>
-                <tr><td>Exits:</td><td style='text-align:right;'>{tot_ds}</td></tr>
-                <tr><td>Accuracy:</td><td style='text-align:right; color:#00e5ff;'>{ds_acc:.1f}%</td></tr>
-                <tr><td>Saved Loss:</td><td style='text-align:right; color:#00ff00;'>${stats_data['saved']:.2f}</td></tr>
-                <tr><td>Missed Profit:</td><td style='text-align:right; color:#ff0000;'>${stats_data['missed']:.2f}</td></tr>
-            </table>
-        </div>
-        """
-
-        # 5. Chart Logic (gr.Plot - No HTML)
-        fig = empty_chart
-        if symbol and curr_p > 0:
-            ohlcv = await data_manager.get_latest_ohlcv(symbol, '5m', 120)
-            if ohlcv and len(ohlcv) > 0:
-                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-                df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
-
-                fig = go.Figure(data=[go.Candlestick(
-                    x=df['datetime'],
-                    open=df['open'], high=df['high'], low=df['low'], close=df['close'],
-                    increasing_line_color='#00ff00', decreasing_line_color='#ff0000',
-                    name=symbol
-                )])
-                
-                # Lines
-                fig.add_hline(y=entry_p, line_dash="dash", line_color="white", opacity=0.5, annotation_text="Entry")
-                fig.add_hline(y=tp_p, line_color="#00ff00", line_width=1, annotation_text="TP")
-                fig.add_hline(y=sl_p, line_color="#ff0000", line_width=1, annotation_text="SL")
-
-                fig.update_layout(
-                    template="plotly_dark",
-                    paper_bgcolor="#0b0f19",
-                    plot_bgcolor="#0b0f19",
-                    margin=dict(l=0, r=50, t=30, b=0),
-                    height=400, # ارتفاع مناسب
-                    xaxis_rangeslider_visible=False,
-                    title=dict(text=f"{symbol} (5m)", x=0.05, font=dict(color="white", size=14)),
-                    yaxis=dict(side='right', gridcolor='#222')
-                )
-
-        # 6. Watchlist Dataframe
-        wl_data = [[k, f"{v.get('final_total_score',0):.2f}"] for k, v in trade_manager.watchlist.items()]
-        wl_df = pd.DataFrame(wl_data, columns=["Coin", "Score"])
-
-        status_txt = sys_state.last_cycle_logs
-        status_line = f"Status: {'READY' if not sys_state.cycle_running else 'SCANNING...'} | Auto-Pilot: {'ON' if sys_state.auto_pilot else 'OFF'}"
-
-        # Return individual items to prevent flicker
-        return (
-            status_txt, 
-            status_line, 
-            fig, 
-            f"{curr_p:.6f}", 
-            f"{entry_p:.6f}", 
-            f"{tp_p:.6f}", 
-            f"{sl_p:.6f}",
-            f"{pnl_pct:+.2f}%", # PnL Percent
-            wl_df, 
-            wallet_md, 
-            history_md
-        )
-
-    except Exception:
-        traceback.print_exc()
-        return "Error", "Error", empty_chart, "0", "0", "0", "0", "0%", wl_df_empty, "Err", "Err"
-
-async def run_cycle_from_gradio():
-    if sys_state.cycle_running: return "الدورة تعمل بالفعل."
-    await run_unified_cycle()
-    return sys_state.last_cycle_logs
-
-# ==============================================================================
-# 🚀 بناء وتثبيت واجهة Gradio (Final Layout)
-# ==============================================================================
-def create_gradio_ui():
-    css = """
-    .gradio-container { background-color: #0b0f19; }
-    .dataframe { color: white !important; background-color: #1a1a1a !important; }
-    thead th { background-color: #333 !important; color: white !important; }
-    /* Fix height for HTML boxes to prevent layout jump */
-    .html-box { min-height: 180px; }
-    """
-
-    with gr.Blocks(title="Titan V22.5 Pro Dashboard", css=css, theme=gr.themes.Monochrome()) as demo:
-        
-        gr.Markdown("# 🚀 Titan V22.5 Pro (Hybrid Guardian Edition)")
-        
-        # --- الصف العلوي: الشارت + الإحصائيات ---
-        with gr.Row():
-            # العمود الأيسر: الشارت + تفاصيل السعر (لتقليل الوميض نفصلها)
-            with gr.Column(scale=3):
-                # 🌟 استخدام gr.Plot هو الحل الجذري لمشكلة الشارت
-                live_chart_plot = gr.Plot(label="Live Chart", container=True)
-                
-                # صف التفاصيل الحية (تحديث نصوص فقط = لا وميض)
-                with gr.Row():
-                    t_price = gr.Textbox(label="Current Price", interactive=False, elem_classes="text-yellow")
-                    t_pnl = gr.Textbox(label="PnL %", interactive=False)
-                
-                with gr.Row():
-                    t_entry = gr.Textbox(label="Entry", interactive=False)
-                    t_tp = gr.Textbox(label="Target (TP)", interactive=False, elem_classes="text-green")
-                    t_sl = gr.Textbox(label="Stop (SL)", interactive=False, elem_classes="text-red")
-
-            # العمود الأيمن: المحفظة والإحصائيات
-            with gr.Column(scale=1):
-                wallet_output = gr.HTML(label="Wallet", elem_classes="html-box")
-                
-                # [جديد] قائمة منسدلة لاختيار عرض الإحصائيات
-                stats_dropdown = gr.Dropdown(
-                    choices=["Hybrid System", "Model V2 (Radar)", "Model V3 (Sniper)"],
-                    value="Hybrid System",
-                    label="Select AI View",
-                    interactive=True
-                )
-                
-                history_output = gr.HTML(label="Stats", elem_classes="html-box")
-                watchlist_output = gr.DataFrame(label="Watchlist", interactive=False)
-                
-        gr.HTML("<hr style='border-color: #333;'>")
-        
-        # --- الصف السفلي: التحكم والسجلات ---
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("## 🎮 Controls")
-                
-                auto_pilot_checkbox = gr.Checkbox(
-                    label="✈️ Auto-Pilot", 
-                    value=True
-                )
-                
-                with gr.Row():
-                    run_cycle_btn = gr.Button("🚀 Scan Now", variant="primary")
-                    close_trade_btn = gr.Button("🚨 Panic Close", variant="stop")
-                    reset_stats_btn = gr.Button("🗑️ Reset Stats", variant="secondary")
-                
-                status_markdown = gr.Markdown("Initializing...")
-                alert_box = gr.Textbox(label="Alerts", interactive=False, visible=True)
-
-            with gr.Column(scale=3):
-                gr.Markdown("## 📜 System Logs")
-                cycle_logs_output = gr.Textbox(
-                    lines=10, 
-                    autoscroll=True,
-                    max_lines=50,
-                    value="..."
-                )
-
-        # --- التفاعلات (Interactions) ---
-        
-        run_cycle_btn.click(fn=run_cycle_from_gradio, inputs=None, outputs=cycle_logs_output)
-        close_trade_btn.click(fn=manual_close_current_trade, inputs=None, outputs=alert_box)
-        reset_stats_btn.click(fn=reset_stats_handler, inputs=None, outputs=alert_box)
-        auto_pilot_checkbox.change(fn=toggle_auto_pilot, inputs=auto_pilot_checkbox, outputs=alert_box)
-        
-        # المؤقت الدوري (كل 3 ثواني) - تم ربط القائمة المنسدلة كـ Input
-        timer = gr.Timer(3) 
-        timer.tick(
-            fn=check_live_pnl_and_status,
-            inputs=[stats_dropdown], # نمرر قيمة القائمة المنسدلة هنا
-            outputs=[
-                cycle_logs_output, 
-                status_markdown, 
-                live_chart_plot,
-                t_price,
-                t_entry,
-                t_tp,
-                t_sl,
-                t_pnl,
-                watchlist_output,
-                wallet_output,   
-                history_output   
-            ]
-        )
-        
-    return demo
-
-gradio_dashboard = create_gradio_ui()
-app = gr.mount_gradio_app(app, gradio_dashboard, path="/")
-
-# ==============================================================================
-# 🏁 تشغيل الخادم
-# ==============================================================================
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+            self.open_positions[symbol] = trade
+            await self.r2.save_open_trades_async(list(self.open_positions.values()))
+            
+            print(f"🎯 [Targets Updated] {symbol} | TP: {old_tp:.8f}->{trade['tp_price']:.8f} | SL: {old_sl:.8f}->{trade['sl_price']:.8f} | Reason: {reason}")
+        else:
+            print(f"⚠️ [Target Update Failed] {symbol} is not currently open.")
+
+    async def start_sentry_loops(self):
+        for symbol in list(self.open_positions.keys()):
+             if symbol not in self.sentry_tasks or self.sentry_tasks[symbol].done():
+                 print(f"🛡️ [Sentry Restart] Activating guardian for existing trade: {symbol}")
+                 self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
+
+    async def stop_sentry_loops(self):
+        print("🛑 [TradeManager] Stopping all sentry loops...")
+        self.running = False
+        for sym, task in self.sentry_tasks.items():
+            task.cancel()
+        
+        await asyncio.sleep(1)
+        print("🛑 [TradeManager] All sentries stopped.")