Update app.py

app.py

@@ -1,10 +1,17 @@
-# app.py (V14.0 - Unified Smart Cycle - Full Production Version)
-import os, sys, traceback, asyncio, gc, json
+# app.py (V14.2 - Final Production Version - FULL CODE)
+import os
+import sys
+import traceback
+import asyncio
+import gc
+import json
 from datetime import datetime
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException, BackgroundTasks
 
-# --- استيراد الوحدات الأساسية ---
+# ==============================================================================
+# 📥 استيراد الوحدات الأساسية (Core Modules Imports)
+# ==============================================================================
 try:
     from r2 import R2Service
     from data_manager import DataManager
@@ -12,24 +19,26 @@ try:
     from trade_manager import TradeManager
     from LLM import LLMService
     from learning_hub.hub_manager import LearningHubManager
-    # وحدات الطبقة الثانية
+    # وحدات الطبقة الثانية المتخصصة
     from whale_monitor.core import EnhancedWhaleMonitor
     from sentiment_news import NewsFetcher
     from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 except ImportError as e:
-    # إيقاف النظام في حال فشل استيراد أي مكون حيوي
-    sys.exit(f"❌ Fatal Init Error: {e}")
+    # إيقاف فوري للنظام في حال فقدان أي مكون حيوي
+    sys.exit(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
 
-# --- المتغيرات العامة (Global Instances) ---
-r2 = None
-data_manager = None
-ml_processor = None
-trade_manager = None
-llm_service = None
-learning_hub = None
-whale_monitor = None
-news_fetcher = None
-vader = None
+# ==============================================================================
+# 🌐 المتغيرات العامة وحالة النظام (Global State)
+# ==============================================================================
+r2: R2Service = None
+data_manager: DataManager = None
+ml_processor: MLProcessor = None
+trade_manager: TradeManager = None
+llm_service: LLMService = None
+learning_hub: LearningHubManager = None
+whale_monitor: EnhancedWhaleMonitor = None
+news_fetcher: NewsFetcher = None
+vader: SentimentIntensityAnalyzer = None
 
 class SystemState:
     def __init__(self):
@@ -39,318 +48,351 @@ class SystemState:
 sys_state = SystemState()
 
 # ==============================================================================
-# 🚀 تهيئة النظام الكاملة (Full System Initialization)
+# 🛠️ تهيئة النظام (Full System Initialization)
 # ==============================================================================
 async def initialize_system():
     global r2, data_manager, ml_processor, trade_manager, llm_service, learning_hub
     global whale_monitor, news_fetcher, vader
     
-    if sys_state.ready: return
-    print("\n🔌 [System V14] Initializing Smart Core...")
+    if sys_state.ready:
+        return
+
+    print("\n🔌 [System V14.2] Starting Full Initialization Sequence...")
     
     try:
-        # 1. الخدمات الأساسية والبنية التحتية
+        # 1. البنية التحتية والبيانات (Infrastructure Layer)
         r2 = R2Service()
-        contracts = await r2.load_contracts_db_async()
+        contracts_db = await r2.load_contracts_db_async()
+        print(f"   ✅ R2 Service connected (Contracts loaded: {len(contracts_db)})")
         
-        whale_monitor = EnhancedWhaleMonitor(contracts_db=contracts, r2_service=r2)
-        data_manager = DataManager(contracts, whale_monitor, r2)
+        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)
         news_fetcher = NewsFetcher()
         vader = SentimentIntensityAnalyzer()
+        print("   ✅ NewsFetcher & VADER initialized.")
         
-        # 2. العقل المركزي (LLM) ومحور التعلم
+        # 3. العقل والتعلم (Intelligence Layer)
         llm_service = LLMService()
-        llm_service.r2_service = r2 # لربط حفظ البرومبتات
-        # سيتم ربط learning_hub لاحقاً لتجنب التبعية الدائرية
+        llm_service.r2_service = r2 # لربط حفظ السجلات
         
         learning_hub = LearningHubManager(r2, llm_service, data_manager)
         await learning_hub.initialize()
-        llm_service.learning_hub = learning_hub # الربط العكسي
+        llm_service.learning_hub = learning_hub # الربط العكسي للعقل بمركز التعلم
+        print("   ✅ LLM Brain & Learning Hub connected.")
 
-        # 3. محركات التحليل والتنفيذ
+        # 4. محركات المعالجة والتنفيذ (Execution Layer)
         ml_processor = MLProcessor(None, data_manager, learning_hub)
         await ml_processor.initialize()
+        print("   ✅ ML Processor (Titan + Patterns) ready.")
 
         trade_manager = TradeManager(r2, data_manager, ml_processor.titan, ml_processor.pattern_engine)
         await trade_manager.initialize_sentry_exchanges()
-        # بدء حلقات المراقبة الخلفية للحارس
+        # بدء مهام المراقبة الخلفية للحارس
         asyncio.create_task(trade_manager.start_sentry_loops())
+        print("   ✅ TradeManager Sentry loops started.")
 
         sys_state.ready = True
-        print("✅ [System] All Systems GO. Ready for action.")
+        print("\n🚀 [SYSTEM READY] All core systems are online and awaiting orders.")
         
     except Exception as e:
-        print(f"❌ [Init Failed] {e}")
+        print(f"\n❌ [INIT FATAL ERROR] System failed to start: {e}")
         traceback.print_exc()
-        sys.exit(1) # خروج اضطراري في حال فشل التهيئة
+        sys.exit(1)
 
 # ==============================================================================
-# 🧠 الدورة الموحدة الذكية (Unified Smart Cycle Entry Point)
+# 🔄 الدورة الموحدة الذكية (Unified Smart Cycle Dispatcher)
 # ==============================================================================
 async def run_unified_cycle():
     """
-    نقطة الدخول الوحيدة للدورات.
-    تقرر تلقائياً بين وضع 'البحث عن فرص' ووضع 'إدارة الصفقات المفتوحة'.
+    نقطة الدخول المركزية للدورات.
+    تقوم تلقائياً بتوجيه النظام إما لوضع 'إعادة التقييم' (إذا وجدت صفقات) أو وضع 'المستكشف'.
     """
+    # فحوصات الأمان قبل البدء
     if not sys_state.ready:
-        print("⏳ [Cycle Skipped] System not ready yet.")
+        print("⏳ [Cycle Skipped] System is not fully initialized yet.")
         return
     if sys_state.cycle_running:
-        print("⏳ [Cycle Skipped] Another cycle is already running.")
+        print("⏳ [Cycle Skipped] Another cycle is already in progress.")
         return
-
-    # محاولة الحصول على القفل لمنع تداخل العمليات
     if not r2.acquire_lock():
-        print("🔒 [Cycle Skipped] Locked by another process.")
+        print("🔒 [Cycle Skipped] Could not acquire execution lock.")
         return
 
     sys_state.cycle_running = True
     start_time = datetime.now()
     
     try:
-        # فحص حالة الحارس: هل هناك صفقات نشطة؟
+        # التحقق من وجود صفقات نشطة لدى الحارس
         open_trades = list(trade_manager.open_positions.values())
         
-        if open_trades:
-            # --- 🛡️ الفرع الاستراتيجي: وضع إعادة التقييم ---
-            print(f"\n⚔️ [Unified Cycle] Active trades detected ({len(open_trades)}). Engaging STRATEGIC RE-ANALYSIS mode.")
-            await _run_reanalysis_mode(open_trades)
+        if len(open_trades) > 0:
+            # --- مسار 1: وضع إعادة التقييم الاستراتيجي ---
+            print(f"\n⚔️ [Unified Cycle] Active trades detected: {len(open_trades)}. Engaging STRATEGIC RE-ANALYSIS Mode.")
+            await _run_reanalysis_mode_full(open_trades)
         else:
-            # --- 🔭 فرع المستكشف: وضع البحث عن فرص ---
-            print("\n🔭 [Unified Cycle] No active trades. Engaging EXPLORER mode.")
-            await _run_explorer_mode()
+            # --- مسار 2: وضع المستكشف الكامل ---
+            print("\n🔭 [Unified Cycle] No active trades. Engaging FULL EXPLORER Mode (4 Layers).")
+            await _run_explorer_mode_full()
 
     except Exception as e:
-        print(f"❌ [Cycle Error] An unexpected error occurred: {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() # تنظيف الذاكرة
-        print(f"🏁 [Cycle Finished] Duration: {(datetime.now() - start_time).total_seconds():.1f}s")
+        gc.collect() # تنظيف الذاكرة العشوائية
+        duration = (datetime.now() - start_time).total_seconds()
+        print(f"🏁 [Cycle Completed] Execution time: {duration:.2f} seconds.")
 
 # ==============================================================================
-# 🛡️ الفرع 1: وضع إعادة التقييم الاستراتيجي (Strategic Re-analysis Mode)
+# ⚔️ المسار 1: وضع إعادة التقييم الكامل (Full Re-analysis Mode)
 # ==============================================================================
-async def _run_reanalysis_mode(open_trades):
-    """إعادة تقييم جميع الصفقات المفتوحة باستخدام العقل الكلي"""
+async def _run_reanalysis_mode_full(open_trades):
+    """يقوم بإعادة تقييم كل صفقة مفتوحة باستخدام العقل الكلي"""
     for trade in open_trades:
-        symbol = trade['symbol']
-        print(f"   ⚖️  Re-evaluating {symbol} with Omniscient Brain...")
+        symbol = trade.get('symbol')
+        if not symbol: continue
+            
+        print(f"   ⚖️  [Re-eval] Consulting Omniscient Brain for {symbol}...")
         
         try:
-            # 1. جمع البيانات الطازجة (Fresh Data Snapshot)
+            # 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)
             
-            # محاولة الحصول على تحديث سريع لدرجة تيتان (اختياري، يعتمد على توفر البيانات)
-            # هنا نستخدم 0 كقيمة افتراضية إذا لم نتمكن من إجراء تحليل كامل سريعاً
-            titan_score = 0.0 
+            # محاولة الحصول على درجة تيتان سريعة (إذا أمكن)
+            # (يمكن تحسين هذا الجزء لاحقاً لاستدعاء تيتان فعلياً إذا توفرت الموارد)
+            titan_score_now = 0.0 
 
             current_data_packet = {
                 'symbol': symbol,
                 'current_price': current_price,
-                'titan_score': titan_score,
+                'titan_score': titan_score_now,
                 'whale_data': whale_data,
                 'news_text': news_text
             }
             
-            # 2. استشارة العقل الكلي (Omniscient Brain Consultation)
+            # 2. استدعاء العقل الكلي للتقييم
             decision = await llm_service.re_analyze_trade_async(trade, current_data_packet)
             
-            # 3. تنفيذ أوامر العقل فوراً
+            # 3. تنفيذ القرار فوراً
             if decision:
-                action = decision.get('action')
-                reason = decision.get('reasoning', 'Strategic update by Brain')
+                action = decision.get('action', 'HOLD')
+                reason = decision.get('reasoning', 'No reasoning provided')
                 
                 if action == 'EMERGENCY_EXIT':
-                    print(f"      🚨 BRAIN COMMAND: IMMEDIATE EMERGENCY EXIT for {symbol}!")
-                    await trade_manager.execute_emergency_exit(symbol, f"Brain Command: {reason}")
+                    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')
-                    if new_tp or new_sl:
-                        print(f"      🎯 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 Update: {reason}")
-                    else:
-                         print(f"      ⚠️ Brain requested target update for {symbol} but provided no values.")
+                    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 or unknown action
-                    print(f"      ✅ Brain verdict for {symbol}: HOLD. Continuing strategy. ({reason[:50]}...)")
+                    # HOLD أو أي قرار آخر غير حرج
+                    print(f"      ✅ [MAINTAIN] Brain verdict for {symbol}: HOLD. ({reason[:60]}...)")
             else:
-                print(f"      ⚠️ Failed to get a valid re-analysis decision from Brain for {symbol}.")
+                print(f"      ⚠️ [WARNING] Brain returned no valid decision for {symbol}. Holding position.")
 
         except Exception as e:
-            print(f"      ❌ Error re-evaluating {symbol}: {e}")
+            print(f"      ❌ [ERROR] Failed to re-evaluate {symbol}: {e}")
+            traceback.print_exc()
 
 # ==============================================================================
-# 🔭 الفرع 2: وضع المستكشف (The 4-Layer Explorer Mode)
+# 🔭 المسار 2: وضع المستكشف الكامل (Full 4-Layer Explorer Mode)
 # ==============================================================================
-async def _run_explorer_mode():
-    """تنفيذ دورة البحث الكاملة عبر الطبقات الأربع"""
-    try:
-        # ---------------------------------------------------------
-        # Layer 1: Rapid Hybrid Screening (Titan + Patterns + Simple MC)
-        # ---------------------------------------------------------
-        print("\n--- 🛡️ Layer 1: Rapid Screening ---")
-        raw_candidates = await data_manager.layer1_rapid_screening()
-        if not raw_candidates:
-            print("   ⚠️ No initial candidates found in Layer 1.")
-            return
+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
 
-        l1_passed = []
-        data_queue = asyncio.Queue()
-        # بدء بث البيانات ومعالجتها بالتوازي
-        producer = asyncio.create_task(data_manager.stream_ohlcv_data(raw_candidates, data_queue))
+    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
         
-        while True:
-            batch = await data_queue.get()
-            if batch is None:
-                data_queue.task_done()
-                break
-            
-            for raw_data in batch:
-                # المعالجة الأولية باستخدام MLProcessor
-                res = await ml_processor.process_and_score_symbol_enhanced(raw_data)
-                # عتبة مرور أولية مخففة (مثلاً 0.50) للسماح بمرور عدد كافٍ للطبقة الثانية
-                if res and res.get('enhanced_final_score', 0.0) >= 0.50:
-                    l1_passed.append(res)
+        for raw_symbol_data in batch_data:
+            # المعالجة الكاملة لكل عملة
+            analysis_result = await ml_processor.process_and_score_symbol_enhanced(raw_symbol_data)
             
-            data_queue.task_done()
-        await producer
+            if analysis_result:
+                score = analysis_result.get('enhanced_final_score', 0.0)
+                # عتبة المرور الأولية (يمكن تعديلها من الإعدادات)
+                if score >= 0.50:
+                    l1_passed_candidates.append(analysis_result)
         
-        # ترتيب واختيار أفضل 10 فقط للتحليل العميق
-        l1_passed.sort(key=lambda x: x['enhanced_final_score'], reverse=True)
-        layer2_candidates = l1_passed[:10]
-        print(f"✅ Layer 1 Complete. {len(layer2_candidates)} candidates advanced to Layer 2.")
+        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
 
-        if not layer2_candidates: return
+    # طباعة جدول المتأهلين من الطبقة 1
+    print("\n📊 [L1] Top Candidates for Deep Analysis:")
+    for idx, cand in enumerate(layer2_input_candidates, 1):
+        comps = cand.get('components', {})
+        print(f"   #{idx:2d} {cand['symbol']:<10} | Score: {cand['enhanced_final_score']:.4f} "
+              f"[Titan:{comps.get('titan_score',0):.2f}, Pat:{comps.get('patterns_score',0):.2f}, MC:{comps.get('mc_score',0):.2f}]")
 
-        # ---------------------------------------------------------
-        # Layer 2: Deep Analysis (Whales + News + Advanced MC)
-        # ---------------------------------------------------------
-        print("\n--- 🐳 Layer 2: Deep Analysis ---")
-        l2_scored = []
-        for cand in layer2_candidates:
-            symbol = cand['symbol']
-            print(f"   🔎 Deep analyzing {symbol}...")
-            
-            # A. تحليل الحيتان
-            whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
-            
-            # B. تحليل الأخبار والمشاعر
-            news_text = await news_fetcher.get_news_for_symbol(symbol)
-            # تحليل VADER بسيط للمساعدة في الترتيب الأولي (النموذج الضخم سيقرأ النص الخام لاحقاً)
-            news_score = vader.polarity_scores(news_text)['compound'] if news_text else 0.0
-            
-            # C. حساب "النقاط المعززة" (Enhanced Score) لترتيب المرشحين
-            # المعادلة: 50% درجة الطبقة الأولى + 30% بونص حيتان + 20% بونص أخبار
-            l1_score = cand['enhanced_final_score']
-            whale_bonus = 0.15 if whale_data.get('trading_signal', {}).get('action') in ['BUY', 'STRONG_BUY'] else 0.0
-            news_bonus = 0.10 if news_score > 0.25 else (-0.10 if news_score < -0.25 else 0.0)
-            
-            final_l2_score = min(1.0, max(0.0, l1_score + whale_bonus + news_bonus))
+    # ----------------------------------------------------------------------
+    # 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}...")
+        
+        # أ. تحليل الحيتان العميق
+        whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
+        
+        # ب. تحليل الأخبار والمشاعر
+        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)
             
-            # تحديث سجل المرشح بكل البيانات الجديدة (ليراها النموذج الضخم)
-            cand.update({
-                'layer2_score': final_l2_score,
-                'whale_data': whale_data,
-                'news_text': news_text,
-                'news_score_raw': news_score
-            })
-            l2_scored.append(cand)
-
-        # اختيار أفضل 5 للطبقة الثالثة
-        l2_scored.sort(key=lambda x: x['layer2_score'], reverse=True)
-        layer3_candidates = l2_scored[:5]
-        print(f"✅ Layer 2 Complete. Top 5 candidates selected for Brain validation.")
+        # ج. حساب النقاط المعززة (Enhanced Layer 2 Score)
+        l1_score = cand['enhanced_final_score']
+        
+        # بونص الحيتان (إضافة 15% إذا كانت الإشارة إيجابية)
+        whale_signal = whale_data.get('trading_signal', {}).get('action', 'HOLD')
+        whale_bonus = 0.15 if whale_signal in ['BUY', 'STRONG_BUY'] else 0.0
+        
+        # بونص الأخبار (إضافة/خصم 10% بناءً على المشاعر)
+        news_bonus = 0.0
+        if news_score_raw > 0.25: news_bonus = 0.10
+        elif news_score_raw < -0.25: news_bonus = -0.10
+        
+        final_l2_score = l1_score + whale_bonus + news_bonus
+        # ضمان بقاء النتيجة بين 0 و 1
+        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_scored_candidates.append(cand)
 
-        # ---------------------------------------------------------
-        # Layer 3: The Brain Filter (LLM Validation)
-        # ---------------------------------------------------------
-        print("\n--- 🧠 Layer 3: Omniscient Brain Validation ---")
-        approved_targets = []
-        for cand in layer3_candidates:
-            symbol = cand['symbol']
-            print(f"   ⚖️  Consulting Brain for {symbol}...")
-            
-            # استشارة العقل الكلي بوجبة البيانات الكاملة
-            decision = await llm_service.get_trading_decision(cand)
-            
-            if decision and decision.get('action') == 'WATCH':
-                confidence = decision.get('confidence_level', 0)
-                print(f"      🎉 APPROVED by Brain! Confidence: {confidence:.2f}")
-                cand['llm_decision'] = decision
-                approved_targets.append(cand)
-            else:
-                reason = decision.get('reasoning', 'Unknown reason') if decision else 'Brain Consultation Failed'
-                print(f"      🛑 REJECTED by Brain: {reason[:60]}...")
+    # ترتيب واختيار أفضل 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 4: Active Sentry Handover
-        # ---------------------------------------------------------
-        print("\n--- 🛡️ Layer 4: Sentry Handover ---")
-        if approved_targets:
-            print(f"🚀 Handing over {len(approved_targets)} elite targets to Sentry for tactical execution.")
-            await trade_manager.update_sentry_watchlist(approved_targets)
+    # ----------------------------------------------------------------------
+    # LAYER 3: Omniscient Brain Validation (LLM)
+    # ----------------------------------------------------------------------
+    print("\n--- 🧠 Layer 3: Omniscient Brain Validation ---")
+    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)
+        
+        if decision and decision.get('action') == 'WATCH':
+            confidence = decision.get('confidence_level', 0.0)
+            print(f"      🎉 BRAIN APPROVED: {symbol} | Confidence: {confidence:.2f}")
+            cand['llm_decision'] = decision
+            approved_targets.append(cand)
         else:
-            print("😴 No candidates passed all 4 layers this cycle. Sentry remains on standby.")
+            reason = decision.get('reasoning', 'Unknown reason') if decision else 'No response from Brain'
+            print(f"      🛑 BRAIN REJECTED: {symbol} | Reason: {reason[:60]}...")
 
-    except Exception as e:
-         print(f"❌ [Explorer Mode Error] {e}")
-         traceback.print_exc()
+    # ----------------------------------------------------------------------
+    # 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.")
 
 # ==============================================================================
-# 🔥 تطبيق FastAPI (نقاط النهاية)
+# 🔥 نقاط نهاية التطبيق (FastAPI 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 Gracefully.")
+    print("👋 [System] Shutdown complete.")
 
-app = FastAPI(lifespan=lifespan, title="Titan 4-Layer Hybrid System V14")
+app = FastAPI(lifespan=lifespan, title="Titan Hybrid System V14.2 (Full Production)")
 
 @app.get("/")
-def root():
+async def root():
+    """فحص حالة النظام الأساسية"""
     return {
-        "status": "Smart Hybrid System Online",
+        "system_status": "ONLINE",
         "initialized": sys_state.ready,
-        "mode": "Re-analysis" if trade_manager and trade_manager.open_positions else "Explorer"
+        "current_mode": "RE-ANALYSIS" if trade_manager and trade_manager.open_positions else "EXPLORER"
     }
 
 @app.get("/run-cycle")
-async def trigger_cycle(background_tasks: BackgroundTasks):
-    """نقطة الاستدعاء الخارجية (مثلاً كل 15 دقيقة)"""
+async def trigger_cycle_endpoint(background_tasks: BackgroundTasks):
+    """نقطة الاستدعاء الخارجية لتشغيل الدورة الموحدة"""
     if not sys_state.ready:
-        raise HTTPException(status_code=503, detail="System is still initializing...")
+        raise HTTPException(status_code=503, detail="System is still initializing, please wait.")
     
-    # إضافة الدورة الموحدة إلى مهام الخلفية
     background_tasks.add_task(run_unified_cycle)
-    return {"message": "Unified smart cycle triggered in background."}
+    return {"status": "ACCEPTED", "message": "Unified smart cycle has been triggered in background."}
 
 @app.get("/status")
-async def get_status():
-    """جلب حالة النظام التفصيلية"""
+async def get_full_status():
+    """جلب تفاصيل حالة النظام الحالية"""
     return {
         "initialized": sys_state.ready,
         "cycle_running": sys_state.cycle_running,
-        "open_positions_count": len(trade_manager.open_positions) if trade_manager else 0,
-        "open_positions": list(trade_manager.open_positions.keys()) if trade_manager else [],
-        "watchlist_count": len(trade_manager.watchlist) if trade_manager else 0,
-        "watchlist": list(trade_manager.watchlist.keys()) if trade_manager else []
+        "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 []
     }
 
+# نقطة الدخول الرئيسية عند التشغيل المباشر
 if __name__ == "__main__":
     import uvicorn
-    # تشغيل السيرفر
+    print("🖥️ Starting Titan Server on port 7860...")
     uvicorn.run(app, host="0.0.0.0", port=7860)