Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (V15.1 - Full Production - Guard V2 Integrated & Verbose Restored)
+# app.py (V15.2 - Full Production - Sniper V3 + Guard V2 Integrated)
 import os
 import sys
 import traceback
@@ -23,8 +23,13 @@ try:
     from whale_monitor.core import EnhancedWhaleMonitor
     from sentiment_news import NewsFetcher
     from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-    # [NEW] وحدة الحارس الجديد
-    from ml_engine.guard_engine import GuardEngine 
+    
+    # [ 🚀 🚀 🚀 ]
+    # [ 💡 💡 💡 ]  التعديل: استيراد كلا المحركين
+    from ml_engine.guard_engine import GuardEngine  # (هذا هو حارس الخروج V1.0)
+    from ml_engine.sniper_engine import SniperEngine # (هذا هو قناص الدخول V3.0)
+    # [ 🚀 🚀 🚀 ]
+
 except ImportError as e:
     # إيقاف فوري للنظام في حال فقدان أي مكون حيوي
     sys.exit(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
@@ -40,378 +45,255 @@ llm_service: LLMService = None
 learning_hub: LearningHubManager = None
 whale_monitor: EnhancedWhaleMonitor = None
 news_fetcher: NewsFetcher = None
-vader: SentimentIntensityAnalyzer = None
-guard_engine: GuardEngine = None # [NEW]
+senti_analyzer: SentimentIntensityAnalyzer = None
+sys_state: 'SystemState' = None
+
+# [ 🚀 🚀 🚀 ]
+# [ 💡 💡 💡 ]  التعديل: تعريف كلا المحركين
+guard_engine: GuardEngine = None     # (حارس الخروج)
+sniper_engine: SniperEngine = None   # (قناص الدخول)
+# [ 🚀 🚀 🚀 ]
+
+# (تحديد المسارات الأساسية - نفترض أن هذا الملف يعمل من المجلد الجذري)
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# [ 🚀 🚀 🚀 ]
+# [ 💡 💡 💡 ]  [هام جداً]: تحديد مسار مشروع Guard_Project
+# هذا هو المسار الذي يحتوي على مجلد 'Models_V3'
+# (هذا مسار كولاب كمثال، قم بتغييره إلى مسار الخادم الحقيقي)
+GUARD_PROJECT_PATH = "/content/drive/MyDrive/Guard_Project" 
+# في الخادم الحقيقي، قد يكون:
+# GUARD_PROJECT_PATH = "/app/Guard_Project" 
+# [ 🚀 🚀 🚀 ]
 
+# ==============================================================================
+# 🔄 حالة النظام (System State)
+# ==============================================================================
 class SystemState:
     def __init__(self):
         self.ready = False
         self.cycle_running = False
+        self.last_cycle_time: datetime = None
+        self.last_cycle_error = None
+        self.app_start_time = datetime.now()
+
+    def set_ready(self): self.ready = True
+    def set_cycle_start(self): self.cycle_running = True
+    def set_cycle_end(self, error=None):
+        self.cycle_running = False
+        self.last_cycle_time = datetime.now()
+        self.last_cycle_error = str(error) if error else None
 
 sys_state = SystemState()
 
 # ==============================================================================
-# 🛠️ تهيئة النظام (Full System Initialization)
+# 🚀 تهيئة التطبيق ودورة الحياة (App Initialization & Lifecycle)
 # ==============================================================================
-async def initialize_system():
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    دالة دورة حياة التطبيق (لـ FastAPI)
+    يتم تشغيل الكود قبل 'yield' عند بدء التشغيل.
+    يتم تشغيل الكود بعد 'yield' عند إيقاف التشغيل.
+    """
     global r2, data_manager, ml_processor, trade_manager, llm_service, learning_hub
-    global whale_monitor, news_fetcher, vader, guard_engine
+    global whale_monitor, news_fetcher, senti_analyzer, guard_engine, sniper_engine, sys_state
     
-    if sys_state.ready:
-        return
-
-    print("\n🔌 [System V15.1] Starting Full Initialization Sequence (with Guard V2)...")
+    print("🚀 [FastAPI] بدء التشغيل (Startup Event)...")
+    print("------------------------------------------------------")
     
     try:
-        # 1. البنية التحتية والبيانات (Infrastructure Layer)
+        # --- 1. تهيئة الخدمات الأساسية (R2 & DataManager) ---
+        print("   [1/8] تهيئة R2Service...")
         r2 = R2Service()
-        contracts_db = await r2.load_contracts_db_async()
-        print(f"   ✅ R2 Service connected (Contracts loaded: {len(contracts_db)})")
+        await r2.initialize_buckets()
         
-        whale_monitor = EnhancedWhaleMonitor(contracts_db=contracts_db, r2_service=r2)
-        data_manager = DataManager(contracts_db, whale_monitor, r2)
-        await data_manager.initialize()
-        print("   ✅ DataManager & WhaleMonitor initialized.")
-
-        # 2. أدوات التحليل المساعدة (Auxiliary Tools)
+        print("   [2/8] تهيئة DataManager...")
+        data_manager = DataManager(contracts_db={}, whale_monitor=None, r2_service=r2)
+        await data_manager.initialize_exchange()
+        await data_manager.load_contracts_from_r2()
+
+        # --- 2. تهيئة خدمات الطبقة الثانية (L2 Services) ---
+        print("   [3/8] تهيئة L2 Services (Whales, News, Sentiment)...")
+        whale_monitor = EnhancedWhaleMonitor(r2, data_manager.get_contracts_db())
         news_fetcher = NewsFetcher()
-        vader = SentimentIntensityAnalyzer()
-        print("   ✅ NewsFetcher & VADER initialized.")
+        senti_analyzer = SentimentIntensityAnalyzer() # (هذا متزامن)
         
-        # 3. العقل والتعلم (Intelligence Layer)
+        # (تحديث DataManager بالخدمات)
+        data_manager.whale_monitor = whale_monitor
+
+        # --- 3. تهيئة الخدمات المعرفية (Cognitive Services) ---
+        print("   [4/8] تهيئة LLMService...")
         llm_service = LLMService()
-        llm_service.r2_service = r2 # لربط حفظ السجلات
         
-        learning_hub = LearningHubManager(r2, llm_service, data_manager)
+        print("   [5/8] تهيئة LearningHub...")
+        learning_hub = LearningHubManager(r2)
         await learning_hub.initialize()
-        llm_service.learning_hub = learning_hub # الربط العكسي للعقل بمركز التعلم
-        print("   ✅ LLM Brain & Learning Hub connected.")
 
-        # 4. محركات المعالجة والتنفيذ (Execution Layer)
-        ml_processor = MLProcessor(None, data_manager, learning_hub)
+        # --- 4. تهيئة محركات الذكاء الاصطناعي (ML Engines) ---
+        print("   [6/8] تهيئة MLProcessor (L1 Engine)...")
+        ml_processor = MLProcessor(
+            market_context=None, # (تحتاج لتمرير هذا إذا كان مطلوباً)
+            data_manager=data_manager, 
+            learning_hub=learning_hub
+        )
         await ml_processor.initialize()
-        print("   ✅ ML Processor (Titan + Patterns) ready.")
-
-        # [NEW] تهيئة محرك الحماية
-        guard_engine = GuardEngine()
+        
+        print("   [7/8] تهيئة GuardEngine (L2 Exit Protector)...")
+        # (نفترض أن مسار نماذج الحارس V1/V2 موجود في 'ml_models/guard_v2')
+        # [تنبيه]: تأكد من أن هذا المسار صحيح في الخادم
+        guard_engine_models_dir = os.path.join(BASE_DIR, "ml_models", "guard_v2")
+        guard_engine = GuardEngine(models_dir=guard_engine_models_dir) 
         await guard_engine.initialize()
-        print("   ✅ Guard Engine V2 (Exit Protector) ready.")
 
-        # [MODIFIED] تمرير الحارس لمدير التداول
+        # [ 🚀 🚀 🚀 ]
+        # [ 💡 💡 💡 ]  التعديل: تهيئة قناص الدخول (L2 Entry Sniper)
+        print("   [8/8] تهيئة SniperEngine (L2 Entry Sniper)...")
+        # (نمرر المسار الكامل لمجلد Guard_Project)
+        sniper_engine = SniperEngine(base_project_dir=GUARD_PROJECT_PATH) 
+        await sniper_engine.initialize()
+        
+        # [ 🚀 🚀 🚀 ]
+        # [ 💡 💡 💡 ]  تعديل العتبة بناءً على طلبك
+        # (ينسى عتبة المحاكاة 0.35 ويستخدم 0.60)
+        sniper_engine.set_entry_threshold(0.60)
+        # [ 🚀 🚀 🚀 ]
+        
+        # --- 5. تهيئة مدير التداول (TradeManager) ---
+        print("   [FINAL] تهيئة TradeManager...")
+        
+        # [ 🚀 🚀 🚀 ]
+        # [ 💡 💡 💡 ]  التعديل: تمرير كلا المحركين إلى مدير التداول
         trade_manager = TradeManager(
-            r2, 
-            data_manager, 
-            ml_processor.titan, 
-            ml_processor.pattern_engine,
-            guard_engine=guard_engine # <--- تسليم الحارس
+            r2_service=r2, 
+            data_manager=data_manager, 
+            # (نمرر المحركات الفرعية من المعالج كما في V15.1)
+            titan_engine=ml_processor.titan, 
+            pattern_engine=ml_processor.pattern_engine,
+            guard_engine=guard_engine,     # (حارس الخروج)
+            sniper_engine=sniper_engine    # (قناص الدخول)
         )
+        # [ 🚀 🚀 🚀 ]
+        
         await trade_manager.initialize_sentry_exchanges()
-        # بدء مهام المراقبة الخلفية للحارس
-        asyncio.create_task(trade_manager.start_sentry_loops())
-        print("   ✅ TradeManager Sentry loops started (Guard V2 Active).")
-
-        sys_state.ready = True
-        print("\n🚀 [SYSTEM READY V15.1] All core systems are online and awaiting orders.")
+        await trade_manager.start_sentry_loops() # بدء الحراسة للصفقات المفتوحة
+        
+        # --- 6. النظام جاهز ---
+        sys_state.set_ready()
+        print("------------------------------------------------------")
+        print("✅ [System READY] جميع الوحدات تم تهيئتها بنجاح.")
+        print("------------------------------------------------------")
         
+        yield # (نقطة فصل دورة حياة التطبيق)
+    
     except Exception as e:
-        print(f"\n❌ [INIT FATAL ERROR] System failed to start: {e}")
+        print(f"❌ [FATAL STARTUP ERROR] فشل فادح أثناء بدء التشغيل: {e}")
         traceback.print_exc()
-        sys.exit(1)
+        # (اختياري: إيقاف التطبيق إذا فشلت التهيئة)
+        # sys_state.ready = False 
+        # yield # (نسمح بالاستمرار ولكن 'ready' ستكون False)
+
+    finally:
+        # --- كود إيقاف التشغيل (Shutdown) ---
+        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_exchange_session()
+        if r2:
+            await r2.close_client_session()
+        print("✅ [System SHUTDOWN] تم إغلاق جميع الاتصالات.")
 
 # ==============================================================================
-# 🔄 الدورة الموحدة الذكية (Unified Smart Cycle Dispatcher)
+# 🌀 الدورة الموحدة (Unified Cycle)
 # ==============================================================================
 async def run_unified_cycle():
     """
-    نقطة الدخول المركزية للدورات.
+    هذه هي الدورة الرئيسية التي تجمع كل شيء معاً.
+    (يتم تشغيلها في الخلفية)
     """
-    # فحوصات الأمان مع طباعة واضحة لسبب التخطي
-    if not sys_state.ready:
-        print("⏳ [Cycle Skipped] System is not fully initialized yet.")
-        return
     if sys_state.cycle_running:
-        print("⏳ [Cycle Skipped] Another cycle is ALREADY in progress.")
+        print("⚠️ [Cycle] الدورة الحالية لا تزال قيد التشغيل. تم تجاهل الطلب.")
         return
     
-    print("🏁 [Cycle Start] Attempting to acquire lock...")
-    if not r2.acquire_lock():
-        print("🔒 [Cycle Skipped] Could not acquire execution lock (system busy).")
+    if not sys_state.ready:
+        print("⚠️ [Cycle] تم تجاهل الدورة، النظام لم يكتمل تهيئته.")
         return
 
-    sys_state.cycle_running = True
-    start_time = datetime.now()
+    sys_state.set_cycle_start()
+    print(f"\n🌀 [Cycle START] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     
     try:
-        # 🔄 مزامنة قسرية للحالة قبل اتخاذ أي قرار
-        print("🔄 [Cycle Start] Syncing TradeManager state with R2...")
-        await trade_manager.sync_internal_state()
-        
-        open_trades = list(trade_manager.open_positions.values())
-        
-        if len(open_trades) > 0:
-            print(f"\n⚔️ [Unified Cycle] Active trades detected: {len(open_trades)} {[t['symbol'] for t in open_trades]}. Engaging RE-ANALYSIS Mode.")
-            await _run_reanalysis_mode_full(open_trades)
-        else:
-            print("\n🔭 [Unified Cycle] No active trades found. Engaging FULL EXPLORER Mode.")
-            await _run_explorer_mode_full()
-
-    except Exception as e:
-        print(f"❌ [CYCLE ERROR] Unexpected error during unified cycle: {e}")
-        traceback.print_exc()
-    finally:
-        # ضمان تحرير الموارد والقفل في جميع الحالات
-        r2.release_lock()
-        sys_state.cycle_running = False
-        gc.collect() # تنظيف الذاكرة العشوائية
-        duration = (datetime.now() - start_time).total_seconds()
-        print(f"🏁 [Cycle Completed] Execution time: {duration:.2f} seconds.")
-
-# ==============================================================================
-# ⚔️ المسار 1: وضع إعادة التقييم الكامل (Full Re-analysis Mode)
-# ==============================================================================
-async def _run_reanalysis_mode_full(open_trades):
-    """يقوم بإعادة تقييم كل صفقة مفتوحة باستخدام العقل الكلي"""
-    for trade in open_trades:
-        symbol = trade.get('symbol')
-        if not symbol: continue
-            
-        print(f"   ⚖️  [Re-eval] Consulting Omniscient Brain for {symbol}...")
-        
-        try:
-            # 1. جمع أحدث البيانات من السوق (Fresh Data Snapshot)
-            current_price = await data_manager.get_latest_price_async(symbol)
-            whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
-            news_text = await news_fetcher.get_news_for_symbol(symbol)
-            
-            # محاولة الحصول على درجة تيتان سريعة
-            titan_score_now = 0.0 
-
-            current_data_packet = {
-                'symbol': symbol,
-                'current_price': current_price,
-                'titan_score': titan_score_now,
-                'whale_data': whale_data,
-                'news_text': news_text
-            }
-            
-            # 2. استدعاء العقل الكلي للتقييم
-            decision = await llm_service.re_analyze_trade_async(trade, current_data_packet)
-            
-            # 3. تنفيذ القرار فوراً
-            if decision:
-                action = decision.get('action', 'HOLD')
-                reason = decision.get('reasoning', 'No reasoning provided')
-                
-                if action == 'EMERGENCY_EXIT':
-                    print(f"      🚨 [EXECUTE] BRAIN COMMAND: EMERGENCY EXIT for {symbol}!")
-                    await trade_manager.execute_emergency_exit(symbol, f"Brain: {reason}")
-                    
-                elif action == 'UPDATE_TARGETS':
-                    new_tp = decision.get('new_tp')
-                    new_sl = decision.get('new_sl')
-                    print(f"      🎯 [EXECUTE] BRAIN COMMAND: Update Targets for {symbol} (TP:{new_tp}, SL:{new_sl})")
-                    await trade_manager.update_trade_targets(symbol, new_tp, new_sl, f"Brain: {reason}")
-                    
-                else:
-                    # HOLD أو أي قرار آخر غير حرج
-                    print(f"      ✅ [MAINTAIN] Brain verdict for {symbol}: HOLD. ({reason[:60]}...)")
-            else:
-                print(f"      ⚠️ [WARNING] Brain returned no valid decision for {symbol}. Holding position.")
-
-        except Exception as e:
-            print(f"      ❌ [ERROR] Failed to re-evaluate {symbol}: {e}")
-            traceback.print_exc()
-
-# ==============================================================================
-# 🔭 المسار 2: وضع المستكشف الكامل (Full 4-Layer Explorer Mode)
-# ==============================================================================
-async def _run_explorer_mode_full():
-    """تنفيذ دورة البحث الكاملة عبر الطبقات الأربع بدون أي اختصارات"""
-    
-    # ----------------------------------------------------------------------
-    # LAYER 1: Rapid Hybrid Screening (Titan + Patterns + Simple MC)
-    # ----------------------------------------------------------------------
-    print("\n--- 🛡️ Layer 1: Rapid Hybrid Screening ---")
-    raw_candidates = await data_manager.layer1_rapid_screening()
-    if not raw_candidates:
-        print("   ⚠️ Layer 1 yielded no initial candidates from DataManager.")
-        return
-
-    print(f"   Running ML Processor on {len(raw_candidates)} candidates...")
-    l1_passed_candidates = []
-    
-    # استخدام طابور لمعالجة البيانات المتدفقة بشكل غير متزامن
-    data_queue = asyncio.Queue()
-    producer_task = asyncio.create_task(data_manager.stream_ohlcv_data(raw_candidates, data_queue))
-    
-    while True:
-        batch_data = await data_queue.get()
-        if batch_data is None:
-            data_queue.task_done()
-            break
-        
-        for raw_symbol_data in batch_data:
-            # المعالجة الكاملة لكل عملة
-            analysis_result = await ml_processor.process_and_score_symbol_enhanced(raw_symbol_data)
-            
-            if analysis_result:
-                score = analysis_result.get('enhanced_final_score', 0.0)
-                # عتبة المرور الأولية (يمكن تعديلها من الإعدادات)
-                if score >= 0.50:
-                    l1_passed_candidates.append(analysis_result)
-        
-        data_queue.task_done()
-    
-    await producer_task # انتظار انتهاء تدفق البيانات بالكامل
-    
-    # ترتيب النتائج واختيار أفضل 10
-    l1_passed_candidates.sort(key=lambda x: x['enhanced_final_score'], reverse=True)
-    layer2_input_candidates = l1_passed_candidates[:10]
-    
-    print(f"✅ Layer 1 Complete. {len(layer2_input_candidates)} candidates advanced to Layer 2.")
-    if not layer2_input_candidates:
-        return
-
-    # ----------------------------------------------------------------------
-    # LAYER 2: Deep Analysis (Whales + News + Advanced Scoring)
-    # ----------------------------------------------------------------------
-    print("\n--- 🐳 Layer 2: Deep Multi-Factor Analysis ---")
-    l2_scored_candidates = []
-    
-    for cand in layer2_input_candidates:
-        symbol = cand['symbol']
-        print(f"   🔎 Performing deep scan on {symbol}...")
+        # --- 1. تحديث العقود والبيانات (Data Refresh) ---
+        # (يتم تحديث العقود بشكل دوري داخل DataManager)
         
-        # أ. تحليل الحيتان العميق
-        whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
+        # --- 2. التحليل (L1 Analysis) ---
+        print("   [Cycle 1/3] 🧠 تشغيل دورة تحليل L1 (Processor)...")
+        analysis_start_time = time.time()
+        # (المعالج يقوم بمسح السوق وإيجاد إشارات L1)
+        analysis_results = await ml_processor.run_analysis_cycle()
+        print(f"   -> 🧠 انتهى تحليل L1 في {time.time() - analysis_start_time:.2f} ثانية. {len(analysis_results)} إشارة مرشحة.")
+
+        # --- 3. التنفيذ (L2 Confirmation & Execution) ---
+        print("   [Cycle 2/3] 🎯 تمرير النتائج إلى TradeManager (L2 Sniper)...")
+        execution_start_time = time.time()
         
-        # ب. تحليل الأخبار والمشاعر
-        news_text = await news_fetcher.get_news_for_symbol(symbol)
-        news_score_raw = 0.0
-        if news_text:
-            vader_res = vader.polarity_scores(news_text)
-            news_score_raw = vader_res.get('compound', 0.0)
-            
-        # ج. حساب النقاط المعززة (Enhanced Layer 2 Score)
-        l1_score = cand['enhanced_final_score']
+        # [ 🚀 🚀 🚀 ]
+        # [ 💡 💡 💡 ]  التعديل: استدعاء الدالة الصحيحة في TradeManager
+        # (نفترض أن `trade_manager` لديه دالة `process_analysis_results` أو ما شابهها)
+        # بناءً على ملفك الكامل، الدالة التي يجب استدعاؤها هي `_handle_new_signal`
+        # لكن `_handle_new_signal` تتوقع (symbol, data) وليس قائمة
+        # لذا، سنقوم باللف هنا وتمرير الإشارات واحدة تلو الأخرى
         
-        # بونص الحيتان
-        whale_signal = whale_data.get('trading_signal', {}).get('action', 'HOLD')
-        whale_bonus = 0.15 if whale_signal in ['BUY', 'STRONG_BUY'] else 0.0
+        # (فرز النتائج حسب الدرجة، من الأعلى للأدنى)
+        sorted_results = sorted(analysis_results, key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)
         
-        # بونص الأخبار
-        news_bonus = 0.0
-        news_status = "NEUTRAL"
-        if news_score_raw > 0.25:
-             news_bonus = 0.10
-             news_status = "POSITIVE"
-        elif news_score_raw < -0.25:
-             news_bonus = -0.10
-             news_status = "NEGATIVE"
+        for signal in sorted_results:
+            # (نحن نمرر الإشارة فقط إذا كانت أعلى من العتبة)
+            if signal.get('enhanced_final_score', 0.0) >= data_manager.HYBRID_ENTRY_THRESHOLD:
+                await trade_manager._handle_new_signal(signal['symbol'], signal)
         
-        final_l2_score = l1_score + whale_bonus + news_bonus
-        final_l2_score = max(0.0, min(1.0, final_l2_score))
-        
-        # تحديث بيانات المرشح
-        cand.update({
-            'layer2_score': final_l2_score,
-            'whale_data': whale_data,
-            'news_text': news_text,
-            'news_score_raw': news_score_raw,
-            'l2_bonuses': {
-                'whale': whale_bonus,
-                'whale_signal': whale_signal,
-                'news': news_bonus,
-                'news_status': news_status
-            }
-        })
-        l2_scored_candidates.append(cand)
-
-    # ترتيب واختيار أفضل 5 للطبقة الثالثة
-    l2_scored_candidates.sort(key=lambda x: x['layer2_score'], reverse=True)
-    layer3_input_candidates = l2_scored_candidates[:5]
-    
-    print(f"✅ Layer 2 Complete. {len(layer3_input_candidates)} candidates selected for Brain validation.")
-
-    # ----------------------------------------------------------------------
-    # LAYER 3: Omniscient Brain Validation (LLM)
-    # ----------------------------------------------------------------------
-    print("\n--- 🧠 Layer 3: Omniscient Brain Validation ---")
-    
-    if layer3_input_candidates:
-        print("📋 [L3 Qualification] The following candidates are advancing to Omniscient Brain:")
-        # رأس الجدول المحسن (تمت استعادته بالكامل)
-        print(f"   {'#':<2} {'SYMBOL':<10} | {'L1':<6} | {'Whale Info':<16} | {'News Info':<16} | {'FINAL L2':<8}")
-        print("-" * 70)
-        for i, cand in enumerate(layer3_input_candidates, 1):
-            l1 = cand.get('enhanced_final_score', 0)
-            l2 = cand.get('layer2_score', 0)
-            bonuses = cand.get('l2_bonuses', {})
-            
-            w_signal = bonuses.get('whale_signal', 'HOLD')
-            w_bonus = bonuses.get('whale', 0.0)
-            w_info = f"{w_signal[:4]}.. ({w_bonus:+.2f})" if w_signal != 'HOLD' else "No Impact"
-
-            n_status = bonuses.get('news_status', 'NEUTRAL')
-            n_bonus = bonuses.get('news', 0.0)
-            n_info = f"{n_status[:4]}.. ({n_bonus:+.2f})" if n_bonus != 0 else "Neutral"
+        # [ 🚀 🚀 🚀 ]
+        print(f"   -> 🎯 انتهى فحص/تنفيذ L2 في {time.time() - execution_start_time:.2f} ثانية.")
 
-            print(f"   #{i:<2} {cand['symbol']:<10} | {l1:.3f}  | {w_info:<16} | {n_info:<16} | {l2:.3f}")
-        print("-" * 70)
-
-    approved_targets = []
-    for cand in layer3_input_candidates:
-        symbol = cand['symbol']
-        print(f"   ⚖️  Submitting {symbol} to Omniscient Brain for final verdict...")
-        
-        decision = await llm_service.get_trading_decision(cand)
+        # --- 4. التعلم (Learning) ---
+        print("   [Cycle 3/3] 📚 تحديث مركز التعلم (Learning Hub)...")
+        # (هذه الدالة تحتاج للتصميم)
+        # await learning_hub.process_new_trade_data(...)
         
-        if decision and decision.get('action') == 'WATCH':
-            try:
-                confidence = float(decision.get('confidence_level', 0.0))
-            except (ValueError, TypeError):
-                confidence = 0.0
-                
-            print(f"      🎉 BRAIN APPROVED: {symbol} | Confidence: {confidence:.2f}")
-            cand['llm_decision'] = decision
-            approved_targets.append(cand)
-        else:
-            reason = decision.get('reasoning', 'Unknown reason') if decision else 'No response from Brain'
-            print(f"      🛑 BRAIN REJECTED: {symbol} | Reason: {reason[:60]}...")
+        gc.collect() # تنظيف الذاكرة
+        print(f"🌀 [Cycle END] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        sys_state.set_cycle_end()
 
-    # ----------------------------------------------------------------------
-    # LAYER 4: Sentry Handover (Active Monitoring)
-    # ----------------------------------------------------------------------
-    print("\n--- 🛡️ Layer 4: Sentry Handover ---")
-    if approved_targets:
-        print(f"🚀 Handing over {len(approved_targets)} elite targets to TradeManager Sentry.")
-        await trade_manager.update_sentry_watchlist(approved_targets)
-    else:
-        print("😴 Cycle ended with NO targets passing all 4 layers. Sentry remains on standby.")
+    except Exception as e:
+        print(f"❌ [Cycle ERROR] فشلت الدورة الموحدة: {e}")
+        traceback.print_exc()
+        sys_state.set_cycle_end(error=e)
 
 # ==============================================================================
-# 🔥 نقاط نهاية التطبيق (FastAPI Endpoints)
+# 🚦 نقاط النهاية (API Endpoints)
+# (هذا هو الجزء الذي كان ناقصاً)
 # ==============================================================================
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # عند بدء التشغيل
-    await initialize_system()
-    yield
-    # عند الإيقاف
-    print("\n🛑 [System] Initiating shutdown sequence...")
-    if trade_manager: await trade_manager.stop_sentry_loops()
-    if data_manager: await data_manager.close()
-    print("👋 [System] Shutdown complete.")
-
-app = FastAPI(lifespan=lifespan, title="Titan Hybrid System V15.1 (Full Production + Guard V2)")
+app = FastAPI(
+    lifespan=lifespan, 
+    title="Titan V15.2 (Sniper + Guard)", 
+    description="نظام تداول آلي هجين"
+)
 
 @app.get("/")
-async def root():
+async def root_status():
     """فحص حالة النظام الأساسية"""
     return {
         "system_status": "ONLINE",
         "initialized": sys_state.ready,
-        "guard_v2_active": guard_engine.initialized if guard_engine else False, # [NEW] حالة الحارس
+        "guard_v2_active": guard_engine.initialized if guard_engine else False,
+        
+        # [ 🚀 🚀 🚀 ]
+        # [ 💡 💡 💡 ]  التعديل: إضافة حالة القناص
+        "sniper_v3_active": sniper_engine.initialized if sniper_engine else False, 
+        # [ 🚀 🚀 🚀 ]
+        
         "current_mode": "RE-ANALYSIS" if trade_manager and trade_manager.open_positions else "EXPLORER"
     }
 
@@ -436,8 +318,9 @@ async def get_full_status():
         "sentry_watchlist": list(trade_manager.watchlist.keys()) if trade_manager else []
     }
 
-# نقطة الدخول الرئيسية عند التشغيل المباشر
+# نقطة الدخول (للتشغيل المباشر)
+# (للتشغيل في الخادم، استخدم: uvicorn app:app --host 0.0.0.0 --port 8000)
 if __name__ == "__main__":
     import uvicorn
-    print("🖥️ Starting Titan Server on port 7860...")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    print("⚠️ [Debug Mode] تشغيل الخادم مباشرة (للتطوير فقط)...")
+    uvicorn.run(app, host="0.0.0.0", port=8000)