Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (Fully updated to Learning Hub architecture)
+# app.py (Fully updated with timeout-safe re_analyze_open_trade_async)
 import os
 import traceback
 import signal
@@ -18,10 +18,8 @@ try:
     from data_manager import DataManager
     from ml_engine.processor import MLProcessor 
     
-    # 🔴 --- START OF CHANGE --- 🔴
-    # (Import the new hub manager instead of the old engine)
+    # (Import the new hub manager)
     from learning_hub.hub_manager import LearningHubManager
-    # 🔴 --- END OF CHANGE --- 🔴
     
     from sentiment_news import SentimentAnalyzer
     from trade_manager import TradeManager
@@ -35,9 +33,7 @@ except ImportError as e:
 r2_service_global = None
 data_manager_global = None
 llm_service_global = None
-# 🔴 --- START OF CHANGE --- 🔴
-learning_hub_global = None # (Changed from learning_engine_global)
-# 🔴 --- END OF CHANGE --- 🔴
+learning_hub_global = None
 trade_manager_global = None
 sentiment_analyzer_global = None
 symbol_whale_monitor_global = None
@@ -50,9 +46,7 @@ class StateManager:
         self.initialization_error = None
         self.services_initialized = {
             'r2_service': False, 'data_manager': False, 'llm_service': False,
-            # 🔴 --- START OF CHANGE --- 🔴
-            'learning_hub': False, # (Changed from learning_engine)
-            # 🔴 --- END OF CHANGE --- 🔴
+            'learning_hub': False,
             'trade_manager': False, 'sentiment_analyzer': False,
             'symbol_whale_monitor': False
         }
@@ -80,9 +74,7 @@ state_manager = StateManager()
 async def initialize_services():
     """تهيئة جميع الخدمات بشكل منفصل"""
     global r2_service_global, data_manager_global, llm_service_global
-    # 🔴 --- START OF CHANGE --- 🔴
-    global learning_hub_global # (Changed from learning_engine_global)
-    # 🔴 --- END OF CHANGE --- 🔴
+    global learning_hub_global
     global trade_manager_global, sentiment_analyzer_global
     global symbol_whale_monitor_global
     try:
@@ -106,8 +98,6 @@ async def initialize_services():
         state_manager.set_service_initialized('sentiment_analyzer'); 
         print("   ✅ محلل المشاعر مهيأ")
         
-        # 🔴 --- START OF CHANGE --- 🔴
-        # (Initialize the new Learning Hub Manager)
         print("   🔄 تهيئة محور التعلم (Learning Hub)..."); 
         learning_hub_global = LearningHubManager(
             r2_service=r2_service_global,
@@ -118,28 +108,25 @@ async def initialize_services():
         state_manager.set_service_initialized('learning_hub'); 
         print("   ✅ محور التعلم (Hub) مهيأ")
 
-        # (Connect the Hub to the LLM service)
         llm_service_global.learning_hub = learning_hub_global
         state_manager.set_service_initialized('llm_service');
         print("   ✅ LLMService مهيأة (ومربوطة بمحور التعلم)")
 
         print("   🔄 تهيئة مدير الصفقات..."); 
-        # (Pass the new Learning Hub to the Trade Manager)
         trade_manager_global = TradeManager(
             r2_service_global, 
-            learning_hub_global, # (Passing the new hub)
+            learning_hub_global,
             data_manager_global,
             state_manager
         )
         state_manager.set_service_initialized('trade_manager'); 
         print("   ✅ مدير الصفقات مهيأ (ومربوط بمحور التعلم)")
-        # 🔴 --- END OF CHANGE --- 🔴
-
+        
         print("🎯 اكتملت تهيئة جميع الخدمات بنجاح"); return True
     except Exception as e: error_msg = f"فشل تهيئة الخدمات: {str(e)}"; print(f"❌ {error_msg}"); state_manager.set_initialization_error(error_msg); return False
 
 async def monitor_market_async():
-    """(Unchanged)"""
+    """مراقبة السوق"""
     global data_manager_global, sentiment_analyzer_global
     try:
         if not await state_manager.wait_for_initialization(): print("❌ فشل تهيئة الخدمات - إيقاف مراقبة السوق"); return
@@ -160,8 +147,6 @@ async def monitor_market_async():
             except Exception as error: print(f"❌ خطأ أثناء مراقبة السوق: {error}"); state.MARKET_STATE_OK = True; await asyncio.sleep(60)
     except Exception as e: print(f"❌ فشل تشغيل مراقبة السوق: {e}")
 
-# 🔴 --- START OF CHANGE --- 🔴
-# (New background task for periodic distillation - Point 6)
 async def run_periodic_distillation():
     """
     Runs the Learning Hub's distillation process periodically.
@@ -185,10 +170,12 @@ async def run_periodic_distillation():
             print(f"❌ [Scheduler] Error in periodic distillation task: {e}")
             traceback.print_exc()
             await asyncio.sleep(60 * 60) # (Wait 1 hour on error)
-# 🔴 --- END OF CHANGE --- 🔴
 
 async def process_batch_parallel(batch, ml_processor, batch_num, total_batches, preloaded_whale_data):
-    """(Unchanged)"""
+    """
+    (معدلة) معالجة دفعة من الرموز بشكل متوازي وإرجاع نتائج مفصلة
+    - تستخدم بيانات الحيتان المحملة مسبقًا
+    """
     try:
         batch_tasks = []
         for symbol_data in batch:
@@ -222,13 +209,18 @@ async def process_batch_parallel(batch, ml_processor, batch_num, total_batches,
         return {'success': successful_results, 'low_score': low_score_results, 'failures': failed_results}
         
     except Exception as error:
-        print(f"❌ [Consumer] Error processing batch {batch_num}: {error}")
+        print(f"❌ [المستهلك] خطأ في معالجة الدفعة {batch_num}: {error}")
         return {'success': [], 'low_score': [], 'failures': []}
 
 
 async def run_3_layer_analysis():
     """
-    (Updated to pass LearningHub to MLProcessor and save context for Reflector)
+    (معدلة) تشغيل النظام الطبقي (مع فصل جلب الحيتان)
+    الطبقة 1: data_manager - الفحص السريع
+    الطبقة 1.5: جلب بيانات الحيتان بشكل منفصل (غير معرقل)
+    الطبقة 2: MLProcessor - التحليل المتدفق (يستخدم مونت كارلو المرحلة 1)
+    الطبقة 2.5: (جديد) مونت كارلو (المرحلة 2+3) لأفضل 10 عملات
+    الطبقة 3: LLMService - النموذج الضخم (يستخدم نتائج المرحلة 2.5)
     """
     
     layer1_candidates = []
@@ -240,20 +232,20 @@ async def run_3_layer_analysis():
     preloaded_whale_data_dict = {} 
     
     try:
-        print("🎯 Starting 3-Layer Analysis (with Learning Hub integration)...")
+        print("🎯 بدء النظام الطبقي المكون من 3 طبقات (مع فصل جلب الحيتان)...")
         
-        if not await state_manager.wait_for_initialization(): print("❌ Services not fully initialized"); return None
+        if not await state_manager.wait_for_initialization(): print("❌ الخدمات غير مهيأة بالكامل"); return None
 
-        # (Layer 1 - Unchanged)
-        print("\n🔍 Layer 1: Rapid Screening (data_manager)...")
+        # الطبقة 1
+        print("\n🔍 الطبقة 1: الفحص السريع (data_manager)...")
         layer1_candidates = await data_manager_global.layer1_rapid_screening()
-        if not layer1_candidates: print("❌ No candidates found in Layer 1"); return None
-        print(f"✅ Selected {len(layer1_candidates)} symbols for Layer 2")
+        if not layer1_candidates: print("❌ لم يتم العثور على مرشحين في الطبقة 1"); return None
+        print(f"✅ تم اختيار {len(layer1_candidates)} عملة للطبقة 2")
         layer1_symbols = [c['symbol'] for c in layer1_candidates]
 
-        # (Layer 1.5 - Unchanged)
+        # الطبقة 1.5: جلب بيانات الحيتان
         start_whale_fetch = time.time()
-        print(f"\n🐋 Layer 1.5: Fetching whale data for {len(layer1_symbols)} symbols (async)...")
+        print(f"\n🐋 الطبقة 1.5: بدء جلب بيانات الحيتان لـ {len(layer1_symbols)} عملة (بشكل غير معرقل)...")
         async def fetch_whale_data_task(symbols, results_dict):
             WHALE_FETCH_CONCURRENCY = 3 
             semaphore = asyncio.Semaphore(WHALE_FETCH_CONCURRENCY)
@@ -264,59 +256,68 @@ async def run_3_layer_analysis():
                         data = await data_manager_global.get_whale_data_for_symbol(symbol)
                         if data: results_dict[symbol] = data
                     except Exception as e:
+                        print(f"   ❌ [Whale Fetch] فشل جلب بيانات الحيتان لـ {symbol}: {e}")
                         results_dict[symbol] = {'data_available': False, 'error': str(e)} 
             for symbol in symbols: tasks.append(asyncio.create_task(get_data_with_semaphore(symbol)))
             await asyncio.gather(*tasks) 
         whale_fetcher_task = asyncio.create_task(fetch_whale_data_task(layer1_symbols, preloaded_whale_data_dict))
+        print("   ⏳ مهمة جلب بيانات الحيتان تعمل في الخلفية...")
 
-        # (Producer/Consumer Setup - Unchanged)
+        # إعداد المنتج/المستهلك (OHLCV/ML)
         DATA_QUEUE_MAX_SIZE = 2
         ohlcv_data_queue = asyncio.Queue(maxsize=DATA_QUEUE_MAX_SIZE)
         ml_results_list = []
         market_context = await data_manager_global.get_market_context_async()
-        
-        # 🔴 --- START OF CHANGE --- 🔴
-        # (Pass the global Learning Hub to the MLProcessor)
         ml_processor = MLProcessor(market_context, data_manager_global, learning_hub_global)
-        # 🔴 --- END OF CHANGE --- 🔴
-        
         batch_size = 15 
         total_batches = (len(layer1_candidates) + batch_size - 1) // batch_size
-        
-        # (ML Consumer Task - Unchanged)
+        print(f"   🚀 إعداد المنتج/المستهلك (OHLCV/ML): {total_batches} دفعة متوقعة (بحجم {batch_size})")
+
+        # وظ��فة المستهلك (ML Consumer)
         async def ml_consumer_task(queue: asyncio.Queue, results_list: list, whale_data_store: dict):
             batch_num = 0
             while True:
                 try:
                     batch_data = await queue.get()
-                    if batch_data is None: queue.task_done(); break
+                    if batch_data is None: queue.task_done(); print("   🛑 [ML Consumer] تلقى إشارة التوقف."); break
                     batch_num += 1
+                    print(f"   📬 [ML Consumer] استلم دفعة OHLCV {batch_num}/{total_batches} ({len(batch_data)} عملة)")
+                    # 🔴 هنا يتم استخدام مونت كارلو (المرحلة 1) السريع
                     batch_results_dict = await process_batch_parallel(
                         batch_data, ml_processor, batch_num, total_batches, whale_data_store
                     )
                     results_list.append(batch_results_dict)
                     queue.task_done()
-                except Exception as e: print(f"❌ [ML Consumer] Fatal Error: {e}"); traceback.print_exc(); queue.task_done() 
+                    print(f"   ✅ [ML Consumer] أكمل معالجة الدفعة {batch_num}/{total_batches}") 
+                except Exception as e: print(f"❌ [ML Consumer] خطأ فادح: {e}"); traceback.print_exc(); queue.task_done() 
 
-        # (Run Producer/Consumer - Unchanged)
+        # تشغيل المستهلك (ML Consumer) والمنتج (OHLCV Producer)
+        print("   ▶️ [ML Consumer] بدء تشغيل مهمة المستهلك...")
         consumer_task = asyncio.create_task(ml_consumer_task(ohlcv_data_queue, ml_results_list, preloaded_whale_data_dict))
+        print("   ▶️ [OHLCV Producer] بدء تشغيل مهمة المنتج (تدفق بيانات OHLCV)...")
         producer_task = asyncio.create_task(data_manager_global.stream_ohlcv_data(layer1_symbols, ohlcv_data_queue))
-        await producer_task;
-        await ohlcv_data_queue.put(None) 
+        
+        # انتظار انتهاء المنتج والمستهلك
+        await producer_task; print("   ✅ [OHLCV Producer] أنهى جلب جميع بيانات OHLCV.")
         await ohlcv_data_queue.join() 
-        await consumer_task;
+        await consumer_task; print("   ✅ [ML Consumer] أنهى معالجة جميع الدفعات.")
         
-        # (Wait for Whale Fetch - Unchanged)
+        # انتظار اكتمال مهمة جلب الحيتان (مع Timeout)
+        print("   ⏳ انتظار اكتمال مهمة جلب بيانات الحيتان (بحد أقصى للمهلة)...")
         WHALE_FETCH_TIMEOUT_SECONDS = 180 
         try:
             await asyncio.wait_for(whale_fetcher_task, timeout=WHALE_FETCH_TIMEOUT_SECONDS)
+            end_whale_fetch = time.time()
+            print(f"   ✅ اكتمل جلب بيانات الحيتان في {end_whale_fetch - start_whale_fetch:.2f} ثانية. تم جلب/محاولة جلب بيانات لـ {len(preloaded_whale_data_dict)} عملة.")
         except asyncio.TimeoutError:
-            print(f"   ⚠️ Whale fetch timeout ({WHALE_FETCH_TIMEOUT_SECONDS}s)!")
+            end_whale_fetch = time.time()
+            print(f"   ⚠️ انتهت مهلة انتظار جلب بيانات الحيتان ({WHALE_FETCH_TIMEOUT_SECONDS} ثانية)! تم جلب/محاولة جلب بيانات لـ {len(preloaded_whale_data_dict)} عملة حتى الآن.")
         except Exception as whale_task_err:
-             print(f"   ❌ Whale fetch task error: {whale_task_err}")
+             end_whale_fetch = time.time()
+             print(f"   ❌ حدث خطأ غير متوقع أثناء انتظار مهمة جلب الحيتان: {whale_task_err}")
 
-        # (Aggregate Results - Unchanged)
-        print("🔄 Aggregating all results...")
+        # تجميع النتائج
+        print("🔄 تجميع جميع النتائج...")
         for batch_result in ml_results_list:
             for success_item in batch_result['success']:
                 symbol = success_item['symbol']
@@ -329,127 +330,215 @@ async def run_3_layer_analysis():
                 layer2_candidates.append(success_item)
             all_low_score_candidates.extend(batch_result['low_score'])
             all_failed_candidates.extend(batch_result['failures'])
+
+        print(f"✅ اكتمل التحليل المتقدم (MC-Phase1): {len(layer2_candidates)} نجاح (عالي) | {len(all_low_score_candidates)} نجاح (منخفض) | {len(all_failed_candidates)} فشل")
+        if not layer2_candidates: print("❌ لم يتم العثور على مرشحين في الطبقة 2")
         
-        if not layer2_candidates: print("❌ No candidates found in Layer 2")
-        
-        # (Sort and Filter - Unchanged)
+        # الترتيب والفلترة (بناءً على الدرجة التي تتضمن MC-Phase1)
         layer2_candidates.sort(key=lambda x: x.get('enhanced_final_score', 0), reverse=True)
         target_count = min(10, len(layer2_candidates))
         final_layer2_candidates = layer2_candidates[:target_count]
+        print(f"🎯 تم اختيار {len(final_layer2_candidates)} عملة للطبقة 2.5 (الأقوى فقط)")
+        
+        # 🔴 --- بدء الطبقة 2.5: التحليل المتقدم (GARCH+LGBM) --- 🔴
+        print(f"\n🔬 الطبقة 2.5: تشغيل التحليل المتقدم (GARCH+LGBM) على أفضل {len(final_layer2_candidates)} مرشح...")
+        advanced_mc_analyzer = ml_processor.monte_carlo_analyzer # الحصول على محلل مونت كارلو
         
-        # (Layer 2.5: Advanced MC - Unchanged)
-        print(f"\n🔬 Layer 2.5: Running Advanced MC (GARCH+LGBM) on top {len(final_layer2_candidates)} candidates...")
-        advanced_mc_analyzer = ml_processor.monte_carlo_analyzer
         updated_candidates_for_llm = []
         for candidate in final_layer2_candidates:
             symbol = candidate.get('symbol', 'UNKNOWN')
             try:
+                print(f"   🔄 [Advanced MC] تحليل {symbol}...")
+                # استدعاء الدالة الجديدة المتقدمة
                 advanced_mc_results = await advanced_mc_analyzer.generate_1h_distribution_advanced(
                     candidate.get('ohlcv')
                 )
+                
                 if advanced_mc_results and advanced_mc_results.get('simulation_model') == 'Phase2_GARCH_LGBM':
+                    print(f"   ✅ [Advanced MC] {symbol} - تم التحديث بنموذج GARCH/LGBM.")
+                    # استبدال نتائج المرحلة 1 بنتائج المرحلة 2+3
                     candidate['monte_carlo_distribution'] = advanced_mc_results
                     candidate['monte_carlo_probability'] = advanced_mc_results.get('probability_of_gain', 0)
-                    candidate['advanced_mc_run'] = True
+                    candidate['advanced_mc_run'] = True # إضافة علامة للتدقيق
                 else:
-                    candidate['advanced_mc_run'] = False
+                    print(f"   ⚠️ [Advanced MC] {symbol} - فشل التحليل المتقدم، استخدام نتائج المرحلة 1.")
+                    candidate['advanced_mc_run'] = False # إضافة علامة للتدقيق
+                
                 updated_candidates_for_llm.append(candidate)
+                
             except Exception as e:
-                print(f"   ❌ [Advanced MC] {symbol} - Error: {e}. Using Phase 1 results.")
+                print(f"   ❌ [Advanced MC] {symbol} - خطأ فادح: {e}. استخدام نتائج المرحلة 1.")
                 candidate['advanced_mc_run'] = False
                 updated_candidates_for_llm.append(candidate)
-        final_layer2_candidates = updated_candidates_for_llm
+        
+        final_layer2_candidates = updated_candidates_for_llm # استخدام القائمة المحدثة للطبقة 3
+        # 🔴 --- نهاية الطبقة 2.5 --- 🔴
 
         await r2_service_global.save_candidates_async(final_layer2_candidates)
-        # (Printing results omitted for brevity)
+        print("\n🏆 أفضل 10 عملات (بعد التدقيق) جاهزة للطبقة 3:")
+        for i, candidate in enumerate(final_layer2_candidates):
+            score=candidate.get('enhanced_final_score',0); strategy=candidate.get('target_strategy','GENERIC'); mc_dist=candidate.get('monte_carlo_distribution'); pattern=candidate.get('pattern_analysis',{}).get('pattern_detected','no_pattern'); timeframes=candidate.get('successful_timeframes',0); symbol=candidate.get('symbol','UNKNOWN')
+            print(f"   {i+1}. {symbol}: 📊 {score:.3f} | الأطر: {timeframes}/6")
+            
+            if mc_dist:
+                mc_model = mc_dist.get('simulation_model', 'Phase1')
+                mc_pi_90 = mc_dist.get('prediction_interval_90', [0,0])
+                mc_var = mc_dist.get('risk_metrics', {}).get('VaR_95_value', 0)
+                print(f"      🎯 مونت كارلو ({mc_model}): 90% PI [{mc_pi_90[0]:.4f} - {mc_pi_90[1]:.4f}] | VaR: ${mc_var:.4f}")
+            
+            print(f"      🎯 استراتيجية: {strategy} | نمط: {pattern}")
+            whale_data = candidate.get('whale_data')
+            if whale_data and whale_data.get('data_available'): signal = whale_data.get('trading_signal', {}); print(f"      🐋 حيتان: {signal.get('action', 'HOLD')} (ثقة: {signal.get('confidence', 0):.2f}){' ⚠️' if signal.get('critical_alert') else ''}")
+            elif whale_data and whale_data.get('error'): print(f"      🐋 حيتان: خطأ ({whale_data.get('error')[:50]}...)")
 
-        # (Layer 3 - LLM)
-        print("\n🧠 Layer 3: LLM Service Analysis...")
+        # الطبقة 3
+        print("\n🧠 الطبقة 3: التحليل بالنموذج الضخم (LLMService)...")
         for candidate in final_layer2_candidates: 
             try:
-                symbol = candidate['symbol']
+                symbol = candidate['symbol']; print(f"   🤔 تحليل {symbol} بالنموذج الضخم (بيانات MC متقدمة)...")
                 ohlcv_data = candidate.get('ohlcv'); 
-                if not ohlcv_data: continue
+                if not ohlcv_data: print(f"      ⚠️ لا توجد بيانات شموع لـ {symbol}"); continue
                 candidate['raw_ohlcv'] = ohlcv_data
-                total_candles = sum(len(data) for data in ohlcv_data.values()) if ohlcv_data else 0
-                if total_candles < 30: continue
+                timeframes_count = candidate.get('successful_timeframes', 0); total_candles = sum(len(data) for data in ohlcv_data.values()) if ohlcv_data else 0
+                if total_candles < 30: print(f"      ⚠️ بيانات شموع غير كافية لـ {symbol}: {total_candles} شمعة فقط"); continue
+                print(f"      📊 إرسال {symbol} للنموذج: {total_candles} شمعة في {timeframes_count} إطار زمني")
                 
-                # (Add latest market context for LLM)
-                candidate['sentiment_data'] = await data_manager_global.get_market_context_async() 
+                candidate['sentiment_data'] = await data_manager_global.get_market_context_async()
                 
                 llm_analysis = await llm_service_global.get_trading_decision(candidate) 
                 
                 if llm_analysis and llm_analysis.get('action') in ['BUY']: 
-                    # 🔴 --- START OF CHANGE --- 🔴
-                    # (Save the 'candidate' object, which is the full context for the Reflector)
-                    opportunity={
-                        'symbol': symbol, 
-                        'current_price': candidate.get('current_price', 0), 
-                        'decision': llm_analysis, 
-                        'enhanced_score': candidate.get('enhanced_final_score', 0), 
-                        'llm_confidence': llm_analysis.get('confidence_level', 0), 
-                        'strategy': llm_analysis.get('strategy', 'GENERIC'), 
-                        'analysis_timestamp': datetime.now().isoformat(),
-                        'decision_context_data': candidate # (This is the snapshot)
-                    }
-                    # 🔴 --- END OF CHANGE --- 🔴
+                    opportunity={'symbol': symbol, 'current_price': candidate.get('current_price', 0), 'decision': llm_analysis, 'enhanced_score': candidate.get('enhanced_final_score', 0), 'llm_confidence': llm_analysis.get('confidence_level', 0), 'strategy': llm_analysis.get('strategy', 'GENERIC'), 'analysis_timestamp': datetime.now().isoformat(), 'timeframes_count': timeframes_count, 'total_candles': total_candles, 'decision_context_data': candidate.copy()} # (نسخ السياق)
                     final_opportunities.append(opportunity)
-                    print(f"   ✅ {symbol}: {llm_analysis.get('action')} - Conf: {llm_analysis.get('confidence_level', 0):.2f}")
-                else: 
-                    action = llm_analysis.get('action', 'NO_DECISION') if llm_analysis else 'NO_RESPONSE'; print(f"   ⚠️ {symbol}: No trade decision from LLM ({action})")
-            except Exception as e: print(f"❌ Error in LLM analysis for {candidate.get('symbol')}: {e}"); traceback.print_exc(); continue
+                    print(f"   ✅ {symbol}: {llm_analysis.get('action')} - ثقة: {llm_analysis.get('confidence_level', 0):.2f} (ملف خروج: {llm_analysis.get('exit_profile')})")
+                else: action = llm_analysis.get('action', 'NO_DECISION') if llm_analysis else 'NO_RESPONSE'; print(f"   ⚠️ {symbol}: لا يوجد قرار تداول من النموذج الضخم ({action})")
+            except Exception as e: print(f"❌ خطأ في تحليل النموذج الضخم لـ {candidate.get('symbol')}: {e}"); traceback.print_exc(); continue
 
         if final_opportunities:
             final_opportunities.sort(key=lambda x: (x['llm_confidence'] + x['enhanced_score']) / 2, reverse=True)
+            print(f"\n🏆 النظام الطبقي اكتمل: {len(final_opportunities)} فرصة تداول")
+            for i, opportunity in enumerate(final_opportunities[:5]): print(f"   {i+1}. {opportunity['symbol']}: {opportunity['decision'].get('action')} - ثقة: {opportunity['llm_confidence']:.2f} - أطر: {opportunity['timeframes_count']}")
         
-        # (Audit log saving omitted for brevity - unchanged)
+        # (Audit log saving - unchanged)
+        try:
+            top_10_detailed_summary = []
+            for c in final_layer2_candidates:
+                whale_summary = "Not Available"; whale_data = c.get('whale_data') 
+                if whale_data and whale_data.get('data_available'): signal = whale_data.get('trading_signal', {}); action = signal.get('action', 'HOLD'); confidence = signal.get('confidence', 0); reason_preview = signal.get('reason', 'N/A')[:75] + "..." if signal.get('reason') else 'N/A'; whale_summary = f"Action: {action}, Conf: {confidence:.2f}, Alert: {signal.get('critical_alert', False)}, Reason: {reason_preview}"
+                elif whale_data and whale_data.get('error'): whale_summary = f"Error: {whale_data['error'][:50]}..."
+                mc_summary = "N/A"
+                mc_dist = c.get('monte_carlo_distribution')
+                if mc_dist:
+                    mc_model = mc_dist.get('simulation_model', 'Unknown')
+                    if mc_model == 'Phase2_GARCH_LGBM':
+                        drift = mc_dist.get('forecasted_drift_lgbm', 0); vol = mc_dist.get('forecasted_vol_garch', 0); mc_summary = f"Phase2_GARCH(vol={vol:.5f})_LGBM(drift={drift:.5f})"
+                    else: 
+                        var_val = mc_dist.get('risk_metrics', {}).get('VaR_95_value', 0); mc_summary = f"{mc_model}_VaR({var_val:.4f})"
+                top_10_detailed_summary.append({ "symbol": c.get('symbol'), "score": c.get('enhanced_final_score', 0), "timeframes": f"{c.get('successful_timeframes', 'N/A')}/6", "whale_data_summary": whale_summary, "strategy": c.get('target_strategy', 'N/A'), "pattern": c.get('pattern_analysis', {}).get('pattern_detected', 'N/A'), "mc_analysis_level": mc_summary })
+            other_successful_candidates = layer2_candidates[target_count:]; other_success_summary = [{"symbol": c['symbol'], "score": c.get('enhanced_final_score', 0), "timeframes": f"{c.get('successful_timeframes', 'N/A')}/6", "whale_data": "Available" if c.get('whale_data', {}).get('data_available') else ("Error" if c.get('whale_data', {}).get('error') else "Not Available")} for c in other_successful_candidates]; low_score_summary = [{"symbol": c['symbol'], "score": c.get('enhanced_final_score', 0), "timeframes": f"{c.get('successful_timeframes', 'N/A')}/6", "whale_data": "Available" if c.get('whale_data', {}).get('data_available') else ("Error" if c.get('whale_data', {}).get('error') else "Not Available")} for c in all_low_score_candidates]
+            audit_data = { "timestamp": datetime.now().isoformat(), "total_layer1_candidates": len(layer1_candidates), "total_processed_in_layer2": len(layer2_candidates) + len(all_low_score_candidates) + len(all_failed_candidates), "counts": {"sent_to_llm": len(final_layer2_candidates), "success_not_top_10": len(other_successful_candidates), "success_low_score": len(all_low_score_candidates), "failures": len(all_failed_candidates)}, "top_candidates_for_llm": top_10_detailed_summary, "other_successful_candidates": other_success_summary, "low_score_candidates": low_score_summary, "failed_candidates": all_failed_candidates, }
+            await r2_service_global.save_analysis_audit_log_async(audit_data)
+            print(f"✅ تم حفظ سجل تدقيق التحليل في R2 (مع تفاصيل MC المتقدمة).")
+        except Exception as audit_error: print(f"❌ فشل حفظ سجل تدقيق التحليل: {audit_error}"); traceback.print_exc()
         
-        if not final_opportunities: print("❌ No suitable trading opportunities found"); return None
+        if not final_opportunities: print("❌ لم يتم العثور على فرص تداول مناسبة"); return None
         return final_opportunities[0] if final_opportunities else None
         
     except Exception as error:
-        print(f"❌ Fatal error in 3-layer system: {error}"); traceback.print_exc()
+        print(f"❌ خطأ فادح في النظام الطبقي: {error}"); traceback.print_exc()
+        try: 
+            audit_data = { "timestamp": datetime.now().isoformat(), "status": "FAILED", "error": str(error), "traceback": traceback.format_exc(), "total_layer1_candidates": len(layer1_candidates), "counts": {"sent_to_llm": 0, "success_not_top_10": 0, "success_low_score": len(all_low_score_candidates), "failures": len(all_failed_candidates)}, "failed_candidates": all_failed_candidates }
+            await r2_service_global.save_analysis_audit_log_async(audit_data)
+            print("⚠️ تم حفظ سجل تدقيق جزئي بعد الفشل.")
+        except Exception as audit_fail_error: print(f"❌ فشل حفظ سجل التدقيق أثناء معالجة خطأ آخر: {audit_fail_error}")
         return None
 
+# 🔴 --- START OF CHANGE --- 🔴
+# (This function is now hardened with timeouts and correct queue handling)
 async def re_analyze_open_trade_async(trade_data):
-    """(Updated to pass LearningHub to MLProcessor)"""
+    """إعادة تحليل الصفقة المفتوحة (نسخة محصنة ضد التعليق)"""
     symbol = trade_data.get('symbol')
+    
+    # تعريف المهلات الزمنية (بالثواني)
+    OHLCV_PRODUCER_TIMEOUT = 30.0
+    OHLCV_QUEUE_TIMEOUT = 10.0
+    WHALE_DATA_TIMEOUT = 20.0
+    LLM_REANALYSIS_TIMEOUT = 60.0
+    
     try:
         async with state_manager.trade_analysis_lock:
-            print(f"🔄 [Re-Analyze] Starting strategic analysis for {symbol}...")
+            print(f"🔄 [Re-Analyze] بدء التحليل الاستراتيجي لـ {symbol}...")
             market_context = await data_manager_global.get_market_context_async()
+            
+            # (إصلاح نمط المنتج/المستهلك لبيانات OHLCV)
             ohlcv_data_list = []
-            temp_queue = asyncio.Queue()
-            await data_manager_global.stream_ohlcv_data([symbol], temp_queue)
-            while True:
-                try:
-                    batch = await asyncio.wait_for(temp_queue.get(), timeout=1.0) 
-                    if batch is None: temp_queue.task_done(); break
-                    ohlcv_data_list.extend(batch)
-                    temp_queue.task_done()
-                except asyncio.TimeoutError:
-                    if temp_queue.empty(): break 
-                except Exception: break 
-
-            if not ohlcv_data_list: print(f"⚠️ Failed to get re-analysis data for {symbol}"); return None
+            temp_queue = asyncio.Queue(maxsize=2)
+            
+            print(f"   🔄 [Re-Analyze] بدء جلب بيانات OHLCV لـ {symbol} (مهلة {OHLCV_PRODUCER_TIMEOUT} ثانية)...")
+            producer_task = asyncio.create_task(
+                data_manager_global.stream_ohlcv_data([symbol], temp_queue)
+            )
+
+            try:
+                # (تشغيل المنتج والمستهلك بالتوازي مع مهلة زمنية)
+                async with asyncio.timeout(OHLCV_PRODUCER_TIMEOUT):
+                    while True:
+                        try:
+                            # (انتظار المستهلك مع مهلة أقصر)
+                            batch = await asyncio.wait_for(temp_queue.get(), timeout=OHLCV_QUEUE_TIMEOUT)
+                            
+                            if batch is None: # (هذا يعمل الآن بسبب الإصلاح في data_manager.py)
+                                temp_queue.task_done()
+                                print("   ✅ [Re-Analyze] تلقى إشارة إنهاء OHLCV.")
+                                break # الخروج من حلقة المستهلك
+                            
+                            ohlcv_data_list.extend(batch)
+                            temp_queue.task_done()
+                            
+                        except asyncio.TimeoutError:
+                            print(f"   ⚠️ [Re-Analyze] مهلة انتظار طابور OHLCV لـ {symbol}. (المنتج قد يكون معلقاً)")
+                            if producer_task.done():
+                                break # المنتج انتهى والطابور فارغ
+                            
+            except asyncio.TimeoutError:
+                print(f"   ❌ [Re-Analyze] فشل جلب OHLCV بالكامل (مهلة {OHLCV_PRODUCER_TIMEOUT} ثانية). إلغاء المهمة.")
+                if not producer_task.done():
+                    producer_task.cancel()
+            
+            await producer_task # (التأكد من انتهاء المنتج)
+
+            if not ohlcv_data_list: 
+                print(f"⚠️ فشل جلب بيانات إعادة التحليل لـ {symbol}"); 
+                return None
+            
             ohlcv_data = ohlcv_data_list[0]
             
             l1_data = await data_manager_global._get_detailed_symbol_data(symbol)
             if l1_data: ohlcv_data.update(l1_data); ohlcv_data['reasons_for_candidacy'] = ['re-analysis']
             
-            re_analysis_whale_data = await data_manager_global.get_whale_data_for_symbol(symbol)
+            # (إضافة مهلة زمنية لمكالمة الحيتان)
+            re_analysis_whale_data = None
+            try:
+                print(f"   🔄 [Re-Analyze] بدء جلب بيانات الحيتان لـ {symbol} (مهلة {WHALE_DATA_TIMEOUT} ثانية)...")
+                re_analysis_whale_data = await asyncio.wait_for(
+                    data_manager_global.get_whale_data_for_symbol(symbol),
+                    timeout=WHALE_DATA_TIMEOUT
+                )
+                print(f"   ✅ [Re-Analyze] تم جلب بيانات الحيتان.")
+            except asyncio.TimeoutError:
+                print(f"   ⚠️ [Re-Analyze] مهلة جلب بيانات الحيتان لـ {symbol}. المتابعة بدونها.")
+            except Exception as whale_e:
+                print(f"   ❌ [Re-Analyze] خطأ في جلب بيانات الحيتان: {whale_e}. المتابعة بدونها.")
 
-            # 🔴 --- START OF CHANGE --- 🔴
-            # (Pass the global Learning Hub to the MLProcessor)
             ml_processor = MLProcessor(market_context, data_manager_global, learning_hub_global)
-            # 🔴 --- END OF CHANGE --- 🔴
             
-            print(f"🔄 [Re-Analyze] Using Advanced MC (Phase 2+3) for {symbol}...")
+            print(f"🔄 [Re-Analyze] استخدام مونت كارلو (Phase 2+3) لـ {symbol}...")
             advanced_mc_results = await ml_processor.monte_carlo_analyzer.generate_1h_distribution_advanced(
                 ohlcv_data.get('ohlcv')
             )
             
             processed_data = await ml_processor.process_and_score_symbol_enhanced(ohlcv_data, {symbol: re_analysis_whale_data} if re_analysis_whale_data else {})
+            
             if not processed_data: return None
             
             if advanced_mc_results:
@@ -460,39 +549,61 @@ async def re_analyze_open_trade_async(trade_data):
             processed_data['ohlcv'] = processed_data['raw_ohlcv']
             processed_data['sentiment_data'] = market_context
             
-            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+            # (إضافة مهلة زمنية لمكالمة النموذج الضخم)
+            re_analysis_decision = None
+            try:
+                print(f"   🔄 [Re-Analyze] بدء استدعاء النموذج الضخم لـ {symbol} (مهلة {LLM_REANALYSIS_TIMEOUT} ثانية)...")
+                re_analysis_decision = await asyncio.wait_for(
+                    llm_service_global.re_analyze_trade_async(trade_data, processed_data),
+                    timeout=LLM_REANALYSIS_TIMEOUT
+                )
+            except asyncio.TimeoutError:
+                print(f"   ❌ [Re-Analyze] مهلة استدعاء النموذج الضخم لـ {symbol}. اتخاذ قرار HOLD افتراضي.")
+                return None
+            except Exception as llm_e:
+                 print(f"   ❌ [Re-Analyze] خطأ في استدعاء النموذج الضخم: {llm_e}.")
+                 return None
             
             if re_analysis_decision:
                 await r2_service_global.save_system_logs_async({ "trade_reanalyzed": True, "symbol": symbol, "action": re_analysis_decision.get('action'), 'strategy': re_analysis_decision.get('strategy', 'GENERIC') })
-                print(f"✅ [Re-Analyze] Strategic analysis complete for {symbol}. Decision: {re_analysis_decision.get('action')}")
+                print(f"✅ [Re-Analyze] اكتمل التحليل الاستراتيجي لـ {symbol}. القرار: {re_analysis_decision.get('action')}")
                 return {"symbol": symbol, "decision": re_analysis_decision, "current_price": processed_data.get('current_price')}
-            else: return None
-    except Exception as error: await r2_service_global.save_system_logs_async({ "reanalysis_error": True, "symbol": symbol, "error": str(error) }); print(f"❌ Error in re_analyze_open_trade_async for {symbol}: {error}"); traceback.print_exc(); return None
+            else: 
+                print(f"   ⚠️ [Re-Analyze] النموذج الضخم لم يُرجع قراراً لـ {symbol}.")
+                return None
+                
+    except Exception as error: 
+        await r2_service_global.save_system_logs_async({ "reanalysis_error": True, "symbol": symbol, "error": str(error) }); 
+        print(f"❌ Error in re_analyze_open_trade_async for {symbol}: {error}"); 
+        traceback.print_exc(); 
+        return None
+# 🔴 --- END OF CHANGE --- 🔴
 
 
 async def run_bot_cycle_async():
-    """(Updated to pass decision_context to open_trade)"""
+    """دورة التداول الرئيسية"""
     try:
-        if not await state_manager.wait_for_initialization(): print("❌ Services not fully initialized - skipping cycle"); return
-        print("🔄 Starting trading cycle..."); await r2_service_global.save_system_logs_async({"cycle_started": True})
-        if not r2_service_global.acquire_lock(): print("❌ Failed to acquire lock - skipping cycle"); return
+        if not await state_manager.wait_for_initialization(): print("❌ الخدمات غير مهيأة بالكامل - تخطي الدورة"); return
+        print("🔄 بدء دورة التداول..."); await r2_service_global.save_system_logs_async({"cycle_started": True})
+        if not r2_service_global.acquire_lock(): print("❌ فشل الحصول على القفل - تخطي الدورة"); return
         
         open_trades = [] 
         try:
-            open_trades = await trade_manager_global.get_open_trades(); print(f"📋 Open trades: {len(open_trades)}")
+            open_trades = await trade_manager_global.get_open_trades(); print(f"📋 الصفقات المفتوحة: {len(open_trades)}")
+            should_look_for_new_trade = len(open_trades) == 0
             if open_trades:
                 now = datetime.now()
                 trades_to_reanalyze = [t for t in open_trades if now >= datetime.fromisoformat(t.get('expected_target_time', now.isoformat()))]
                 if trades_to_reanalyze:
-                    print(f"🔄 Re-analyzing {len(trades_to_reanalyze)} trades (using Advanced MC)")
+                    print(f"🔄 إعادة تحليل {len(trades_to_reanalyze)} صفقة (باستخدام MC المتقدم)")
                     reanalysis_results = await asyncio.gather(*[re_analyze_open_trade_async(trade) for trade in trades_to_reanalyze], return_exceptions=True)
                     for i, result in enumerate(reanalysis_results):
                          trade = trades_to_reanalyze[i] 
-                         if isinstance(result, Exception): print(f"   ❌ Re-analysis failed for {trade.get('symbol')}: {result}")
-                         elif result and result['decision'].get('action') == "CLOSE_TRADE": print(f"   ✅ Closing {trade.get('symbol')} based on re-analysis."); await trade_manager_global.close_trade(trade, result['current_price'], 'CLOSED_BY_REANALYSIS'); 
-                         elif result and result['decision'].get('action') == "UPDATE_TRADE": print(f"   ✅ Updating {trade.get('symbol')} based on re-analysis."); await trade_manager_global.update_trade(trade, result['decision'])
-                         elif result: print(f"   ℹ️ Holding {trade.get('symbol')} based on re-analysis.")
-                         else: print(f"   ⚠️ Re-analysis for {trade.get('symbol')} yielded no decision.")
+                         if isinstance(result, Exception): print(f"   ❌ فشل إعادة تحليل {trade.get('symbol')}: {result}")
+                         elif result and result['decision'].get('action') == "CLOSE_TRADE": print(f"   ✅ إغلاق {trade.get('symbol')} بناءً على إعادة التحليل."); await trade_manager_global.close_trade(trade, result['current_price'], 'CLOSED_BY_REANALYSIS'); 
+                         elif result and result['decision'].get('action') == "UPDATE_TRADE": print(f"   ✅ تحديث {trade.get('symbol')} بناءً على إعادة التحليل."); await trade_manager_global.update_trade(trade, result['decision'])
+                         elif result: print(f"   ℹ️ الاحتفاظ بـ {trade.get('symbol')} بناءً على إعادة التحليل.")
+                         else: print(f"   ⚠️ إعادة تحليل {trade.get('symbol')} لم تنتج قرارًا.")
             
             current_open_trades_count = len(await trade_manager_global.get_open_trades())
             should_look_for_new_trade = current_open_trades_count == 0
@@ -500,22 +611,19 @@ async def run_bot_cycle_async():
             if should_look_for_new_trade:
                 portfolio_state = await r2_service_global.get_portfolio_state_async(); current_capital = portfolio_state.get("current_capital_usd", 0)
                 if current_capital > 1:
-                    print("🎯 Looking for new trading opportunities (Dual-Phase MC)...")
+                    print("🎯 البحث عن فرص تداول جديدة (نظام MC ثنائي المراحل)...")
                     best_opportunity = await run_3_layer_analysis()
-                    
-                    # 🔴 --- START OF CHANGE --- 🔴
-                    # (Pass the decision_context to open_trade for the Reflector)
                     if best_opportunity: 
-                        print(f"✅ Opening new trade: {best_opportunity['symbol']}")
+                        print(f"✅ فتح صفقة جديدة: {best_opportunity['symbol']}")
                         
                         symbol = best_opportunity['symbol']
                         decision = best_opportunity['decision']
                         price = best_opportunity['current_price']
                         
-                        # (Extract the snapshot saved by run_3_layer_analysis)
+                        # (استخراج اللقطة (snapshot) التي تم حفظها)
                         context_data = best_opportunity.get('decision_context_data', {})
                         
-                        # (Build the snapshot for the Reflector)
+                        # (بناء اللقطة (snapshot) للمنعكس (Reflector))
                         decision_context_snapshot = {
                             "market": context_data.get('sentiment_data', {}),
                             "indicators": context_data.get('advanced_indicators', {}),
@@ -531,14 +639,13 @@ async def run_bot_cycle_async():
                             price, 
                             decision_context=decision_context_snapshot
                         )
-                    # 🔴 --- END OF CHANGE --- 🔴
-                    else: print("❌ No suitable trading opportunities found")
-                else: print("❌ Insufficient capital to open new trades")
-            else: print("ℹ️ A trade is already open, skipping new trade search.")
+                    else: print("❌ لم يتم العثور على فرص تداول مناسبة")
+                else: print("❌ رأس المال غير كافي لفتح صفقات جديدة")
+            else: print("ℹ️ يوجد صفقة مفتوحة بالفعل، تخطي البحث عن صفقة جديدة.")
         finally:
             if r2_service_global.lock_acquired: r2_service_global.release_lock()
             await r2_service_global.save_system_logs_async({ "cycle_completed": True, "open_trades": len(open_trades)}) 
-            print("✅ Trading cycle complete")
+            print("✅ اكتملت دورة التداول")
             
     except Exception as error:
         print(f"❌ Unhandled error in main cycle: {error}"); traceback.print_exc() 
@@ -547,24 +654,21 @@ async def run_bot_cycle_async():
 
 @asynccontextmanager
 async def lifespan(application: FastAPI):
-    """Application lifecycle management"""
-    print("🚀 Starting application initialization...")
+    """إدارة دورة حياة التطبيق"""
+    print("🚀 بدء تهيئة التطبيق...")
     try:
         success = await initialize_services()
-        if not success: print("❌ Application initialization failed - shutting down..."); yield; return
-        
+        if not success: print("❌ فشل تهيئة التطبيق - إغلاق..."); yield; return
         asyncio.create_task(monitor_market_async())
         asyncio.create_task(trade_manager_global.start_trade_monitoring())
         
-        # 🔴 --- START OF CHANGE --- 🔴
-        # (Start the new periodic distillation task)
+        # (بدء مهمة التقطير الدوري الجديدة)
         asyncio.create_task(run_periodic_distillation())
-        # 🔴 --- END OF CHANGE --- 🔴
         
         await r2_service_global.save_system_logs_async({"application_started": True})
-        print("🎯 Application ready - 3-Layer System (Learning Hub Enabled) is active")
-        print("   -> 📈 Tactical Monitor (Dynamic Exit) is active")
-        print("   -> 🧠 Periodic Distillation (Curator) is scheduled")
+        print("🎯 التطبيق جاهز للعمل - نظام الطبقات 3 (محور التعلم V4) فعال")
+        print("   -> 📈 المراقب التكتيكي (Dynamic Exit) نشط الآن")
+        print("   -> 🧠 التقطير الدوري (Curator) مجدول الآن")
         yield
     except Exception as error: 
         print(f"❌ Application startup failed: {error}"); 
@@ -576,48 +680,41 @@ async def lifespan(application: FastAPI):
         await cleanup_on_shutdown()
 
 
-application = FastAPI(lifespan=lifespan, title="AI Trading Bot", description="Intelligent Trading System with 3-Layer Analysis and full Operational Learning Hub (Reflexion Architecture)", version="4.0.0")
+application = FastAPI(lifespan=lifespan, title="AI Trading Bot", description="نظام تداول ذكي بتحليل مونت كارلو ثنائي المراحل (GARCH+LGBM) مع محور تعلم تشغيلي (Reflexion Architecture)", version="4.0.0")
 
-# (Endpoints remain unchanged)
 @application.get("/")
-async def root(): return {"message": "Welcome to the AI Trading System", "system": "3-Layer Analysis (Learning Hub Enabled)", "status": "running" if state_manager.initialization_complete else "initializing", "timestamp": datetime.now().isoformat()}
+async def root(): return {"message": "مرحباً بك في نظام التداول الذكي", "system": "3-Layer Analysis System (Learning Hub Enabled)", "status": "running" if state_manager.initialization_complete else "initializing", "timestamp": datetime.now().isoformat()}
 @application.get("/run-cycle")
 async def run_cycle_api():
-    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="Services not fully initialized")
+    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
     asyncio.create_task(run_bot_cycle_async())
     return {"message": "Bot cycle initiated (Learning Hub Enabled)", "system": "3-Layer Analysis"}
 @application.get("/health")
-async def health_check(): return {"status": "healthy" if state_manager.initialization_complete else "initializing", "initialization_complete": state_manager.initialization_complete, "services_initialized": state_manager.services_initialized, "initialization_error": state_manager.initialization_error, "timestamp": datetime.now().isoformat(), "system_architecture": "3-Layer Analysis (Learning Hub V4.0)"}
+async def health_check(): return {"status": "healthy" if state_manager.initialization_complete else "initializing", "initialization_complete": state_manager.initialization_complete, "services_initialized": state_manager.services_initialized, "initialization_error": state_manager.initialization_error, "timestamp": datetime.now().isoformat(), "system_architecture": "3-Layer Analysis System (Learning Hub V4.0)"}
 @application.get("/analyze-market")
 async def analyze_market_api():
-    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="Services not fully initialized")
+    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
     result = await run_3_layer_analysis()
     if result: return {"opportunity_found": True, "symbol": result['symbol'], "action": result['decision'].get('action'), "confidence": result['llm_confidence'], "strategy": result['strategy'], "exit_profile": result['decision'].get('exit_profile')}
     else: return {"opportunity_found": False, "message": "No suitable opportunities found"}
 @application.get("/portfolio")
 async def get_portfolio_api():
-    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="Services not fully initialized")
+    if not state_manager.initialization_complete: raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
     try: portfolio_state = await r2_service_global.get_portfolio_state_async(); open_trades = await trade_manager_global.get_open_trades(); return {"portfolio": portfolio_state, "open_trades": open_trades, "timestamp": datetime.now().isoformat()}
-    except Exception as e: raise HTTPException(status_code=500, detail=f"Error getting portfolio: {str(e)}")
+    except Exception as e: raise HTTPException(status_code=500, detail=f"خطأ في جلب بيانات المحفظة: {str(e)}")
 @application.get("/system-status")
 async def get_system_status(): monitoring_status = trade_manager_global.get_monitoring_status() if trade_manager_global else {}; return {"initialization_complete": state_manager.initialization_complete, "services_initialized": state_manager.services_initialized, "initialization_error": state_manager.initialization_error, "market_state_ok": state.MARKET_STATE_OK, "monitoring_status": monitoring_status, "timestamp": datetime.now().isoformat()}
 
 async def cleanup_on_shutdown():
-    # 🔴 --- START OF CHANGE --- 🔴
     global r2_service_global, data_manager_global, trade_manager_global, learning_hub_global
-    # 🔴 --- END OF CHANGE --- 🔴
-    
     print("🛑 Shutdown signal received. Cleaning up...")
     if trade_manager_global: trade_manager_global.stop_monitoring(); print("✅ Trade monitoring stopped")
     
-    # 🔴 --- START OF CHANGE --- 🔴
-    # (Call the new hub's shutdown method)
     if learning_hub_global and learning_hub_global.initialized:
         try: 
             await learning_hub_global.shutdown() 
             print("✅ Learning hub data saved")
         except Exception as e: print(f"❌ Failed to save learning hub data: {e}")
-    # 🔴 --- END OF CHANGE --- 🔴
         
     if data_manager_global: await data_manager_global.close(); print("✅ Data manager closed")
     if r2_service_global: