Update trade_manager.py

trade_manager.py

@@ -1,517 +1,883 @@
-# trade_manager.py (V22.4 - GEM-Architect: Full Logic + Multi-Stats + 300 Candle Fix)
+# app.py (V22.5 - GEM-Architect: FULL ORIGINAL SOURCE + Hybrid Guardian & Multi-Stats UI)
+import os
+import sys
+import traceback
 import asyncio
+import gc
 import json
-import uuid
-import traceback
-from datetime import datetime
+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
 from typing import List, Dict, Any
 
-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}
-        }
-        
-        # للإبقاء على التوافق مع الكود القديم الذي قد يطلب ds_stats مباشرة
-        self.ds_stats = self.ai_stats["hybrid"]
+# [ 💡 مكتبات الواجهة والرسم البياني ]
+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())
         
-        self.execution_lock = asyncio.Lock()
+        days = total_seconds // 86400
+        hours = (total_seconds % 86400) // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
         
-        print(f"🛡️ [TradeManager V22.4] Initialized. Hybrid Guardian Active (Limit: 300).")
+        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)
 
-    async def initialize_sentry_exchanges(self):
-        print("🛡️ [TradeManager] Initializing and syncing state with R2...")
-        await self.sync_internal_state_with_r2()
+            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 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"❌ [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(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()
         
-        if not self.sniper or not self.sniper.initialized:
-            print("⚠️ [TradeManager] SniperEngine V3 غير جاهز للفرز. تم الإلغاء.")
-            return
-
-        sniper_candidates = []
+        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) 
         
-        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)
+        # [ 🧠 ] تهيئة 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
+        )
         
-        best_signal = sniper_candidates[0]
+        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()
         
-        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} (Sniper: {best_signal['sniper_confidence']:.2f}, L2: {best_signal['final_total_score']:.2f})")
+        sys_state.set_ready()
         
-        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}))")
-
-        async with self.execution_lock:
-            if len(self.open_positions) > 0:
-                print(f"⛔ [TradeManager] تم إلغاء التنفيذ في اللحظة الأخيرة. توجد صفقة مفتوحة.")
-                return
+        asyncio.create_task(auto_pilot_loop())
+        print("   -> 🤖 تم تشغيل خدمة الطيار الآلي (Auto-Pilot Daemon).")
 
-            if best_signal['symbol'] in self.open_positions:
-                print(f"   -> [L4 EXEC SKIP] {best_signal['symbol']} تم فتحها بواسطة عملية أخرى للتو.")
-                return
-            
-            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
+        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
 
-            trade_id = str(uuid.uuid4())
-            current_price = float(signal_data.get('current_price', 0.0))
-            
-            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)
-            
-            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(),
-                
-                '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),
-            }
-            
-            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 '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
             
-            if symbol in self.sentry_tasks:
-                self.sentry_tasks[symbol].cancel()
+        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]
             
-            self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
+            log_and_print(f"🔒 [HybridGuardian] الصفقة {symbol} نشطة وتحت الحراسة المشددة.")
+            log_and_print(f"   -> المراقبة تتم كل 60 ثانية في الخلفية (V2 Radar + V3 Sniper).")
+            log_and_print(f"   -> باقي نماذج البحث (L1/L2/L3) في وضع السكون لتوفير الموارد.")
             
-            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}")
-
-        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
-            
-        if self.open_positions:
-            print("   -> [Watchlist] تم تخطي البحث (توجد صفقة مفتوحة). مسح المراقب...")
-            self.watchlist.clear()
-            return
+            # فحص طوارئ سريع (فقط للتأكيد)
+            current_price = await data_manager.get_latest_price_async(symbol)
+            log_and_print(f"   -> السعر الحالي: {format_crypto_price(current_price)}")
             
-        if self.sniper and not self.sniper.initialized:
+            # --- [NEW] استشارة الحارس وعرض الطوابع في السجلات ---
             try:
-                print("   -> [Lazy Load] 🎯 تهيئة SniperEngine V3 (Watchlist) عند الطلب...")
-                await self.sniper.initialize()
+                log_and_print("   -> 📡 جاري طلب تقرير الحارس المباشر (Consultation Scan)...")
+                
+                # [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:
-                print(f"❌ [Lazy Load] فشل فادح في تهيئة SniperEngine (Watchlist): {e}")
-                self.sniper = None
-        
-        if not self.sniper or not self.sniper.initialized:
+                log_and_print(f"   ⚠️ تعذر عرض تقرير الحارس: {e}")
+            
+            sys_state.set_cycle_end(logs=log_buffer.getvalue())
             return 
 
-        watchlist_symbols = list(self.watchlist.keys())
-        if not watchlist_symbols:
-            return
-
-        print(f"   -> [Watchlist] فحص {len(watchlist_symbols)} عملة في قائمة المراقبة لـ L4...")
+        # ============================================================
+        # 🔍 وضع البحث (Scanning Mode) - Normal Flow (مستعاد بالكامل)
+        # ============================================================
         
-        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)
+        # --- 1. الغربلة الأولية (L1) ---
+        log_and_print("   [Cycle 1/5] 🔍 بدء الغربلة السريعة (L1 Screening)...")
+        candidates_to_analyze = await data_manager.layer1_rapid_screening()
         
-        if signals_from_watchlist:
-            await self.select_and_execute_best_signal(signals_from_watchlist)
+        if not candidates_to_analyze:
+            log_and_print("⚠️ [Cycle] لا توجد مرشحات من L1. إنهاء.")
+            sys_state.set_cycle_end(logs=log_buffer.getvalue()); 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)
+        
+        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]
+        
+        log_and_print(f"   -> 🧠 انتهى تحليل L1 في {time.time() - analysis_start_time:.2f} ثانية.")
+        log_and_print(f"       - ✅ نجح: {len(valid_l1_results)} إشارة مرشحة.")
+        
+        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
 
-    # ==============================================================================
-    # 🛡️ دوال حارس الخروج (Hybrid Sentry)
-    # ==============================================================================
-    async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry Activated] بدء الحراسة لـ {symbol} (فحص كل 60 ثانية).")
+        # --- 2. التعزيز وحساب نقاط الطبقة الثانية (L2 Boosting) ---
+        log_and_print(f"\n   [Cycle 2/5] 🚀 بدء تعزيز النقاط (L2 Boosting) لأفضل 10 عملات...")
+        l2_enriched_candidates = []
         
-        while self.running and symbol in self.open_positions:
+        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"
+            
+            # (أ. بيانات الحيتان)
             try:
-                # 🚀 1. الانتظار لمدة 60 ثانية
-                await asyncio.sleep(60) 
+                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}")
                 
-                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}). تخطي الدورة.")
+            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)
                 else:
-                    pass # لا يوجد نموذج فعال
-
-                self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
-            
-            except asyncio.CancelledError:
-                print(f"🛡️ [Sentry STOP] تم إيقاف الحارس لـ {symbol}.")
-                break
+                    log_and_print(f"       🛑 [Oracle REJECTED] {symbol} (Conf: {confidence:.2f})")
+                    log_and_print(f"           📝 Reason: {reason[:200]}...")
             except Exception as e:
-                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 Error] فشل تحليل Oracle لـ {symbol}: {e}")
+                traceback.print_exc(file=log_buffer)
+                continue
         
-        try:
-            current_price = await self.data_manager.get_latest_price_async(symbol)
-            if current_price == 0: return
+        log_and_print(f"   -> 🧠 انتهى فحص Oracle في {time.time() - oracle_start_time:.2f} ثانية. (تمت الموافقة على {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 # جيد إذا السعر هبط بعد الخروج
-            
-            # 1. تحديث إحصائيات النظام الهجين (الكل)
-            self._update_specific_stat("hybrid", is_good_exit, usd_impact)
+        # (إرسال المجموعة إلى TradeManager للفرز النهائي والتنفيذ)
+        if oracle_approved_signals:
+            log_and_print(f"   -> 🎯 [L4 Sniper Batch] إرسال {len(oracle_approved_signals)} إشارة للقناص للفرز النهائي واختيار الأفضل...")
             
-            # 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()
-            }
+            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)
             
-            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_price = float(trade['entry_price'])
-            exit_price = float(price)
-            
-            # 2. حساب نسبة الربح
-            raw_profit_pct = (exit_price - entry_price) / entry_price
-            profit_pct_display = raw_profit_pct * 100
-            
-            # 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))
-            
-            pnl_usd = current_capital * raw_profit_pct
-            new_capital = current_capital + pnl_usd
+            tm_logs = tm_log_buffer.getvalue()
+            print(tm_logs) 
+            log_buffer.write(tm_logs + '\n')
+        else:
+            log_and_print("   -> 🎯 [L4 Sniper Batch] لا توجد إشارات معتمدة من العقل لإرسالها للقناص.")
             
-            # تحديث الإحصائيات التراكمية
-            portfolio['current_capital_usd'] = new_capital
-            portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
+        # --- 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]
             
-            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
+            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))
             
-            trade['pnl_usd'] = pnl_usd 
+            # 🕒 حساب مدة الصفقة الحالية في بايثون
+            trade_dur_str = calculate_duration_str(trade.get('entry_time'))
             
-            # 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)
+            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;'>
             
-            print(f"✅ [EXIT EXECUTED] {symbol} | Reason: {reason} | PnL: {profit_pct_display:.2f}% (${pnl_usd:.2f}) | New Cap: ${new_capital:.2f}")
-
-            # 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]
+            <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}
 
-        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']
-            
-            if new_tp is not None: trade['tp_price'] = float(new_tp)
-            if new_sl is not None: trade['sl_price'] = float(new_sl)
+        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>
             
-            self.open_positions[symbol] = trade
-            await self.r2.save_open_trades_async(list(self.open_positions.values()))
+            <hr style='border-color:#444; margin: 8px 0;'>
             
-            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.")
+            <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)