Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (Updated to Sentry/Executor architecture)
+# trade_manager.py (Updated to Sentry/Executor architecture V5.1 - Fixed ccxt import)
 import asyncio
 import json
 import time
@@ -8,20 +8,20 @@ from typing import Dict, Any, List
 from collections import deque
 
 # 🔴 --- START OF CHANGE --- 🔴
-# (استيراد ccxt.pro هو التغيير الأهم)
+# (هذا هو التصحيح بناءً على خطأ البناء)
+# (لقد استبدلنا 'ccxt.pro' بـ 'ccxt.async_support' لأن ccxt v4+ يدمجها)
 try:
-    import ccxt.pro as ccxtpro
+    import ccxt.async_support as ccxtpro
     CCXT_PRO_AVAILABLE = True
 except ImportError:
-    print("❌❌❌ خطأ فادح: مكتبة 'ccxt-pro' غير موجودة. ❌❌❌")
-    print("يرجى تثبيتها فوراً: pip install ccxt-pro")
+    print("❌❌❌ خطأ فادح: فشل استيراد 'ccxt.async_support'. ❌❌❌")
+    print("يرجى التأكد من تثبيت 'ccxt' (الإصدار 4 أو أحدث) بنجاح.")
     CCXT_PRO_AVAILABLE = False
 # 🔴 --- END OF CHANGE --- 🔴
 
+import numpy as np # (نحتاج numpy لتحليل RSI البسيط)
 from helpers import safe_float_conversion
-# (لم نعد بحاجة إلى _DynamicExitEngine القديم أو pandas_ta هنا)
 
-# 🔴 --- START OF CHANGE --- 🔴
 # (فئة مساعد مبسطة لتتبع البيانات اللحظية)
 class TacticalData:
     def __init__(self, symbol):
@@ -30,7 +30,7 @@ class TacticalData:
         self.trades = deque(maxlen=100)
         self.cvd = 0.0 # (Cumulative Volume Delta)
         self.large_trades = []
-        self.one_min_rsi = 50.0 # (سيتم تحديثه)
+        self.one_min_rsi = 50.0 
         self.last_update = time.time()
         self.binance_trades = deque(maxlen=50) # (للبيانات التأكيدية)
         self.binance_cvd = 0.0
@@ -39,7 +39,6 @@ class TacticalData:
         self.trades.append(trade)
         self.last_update = time.time()
         
-        # حساب CVD
         try:
             trade_amount = float(trade['amount'])
             if trade['side'] == 'buy':
@@ -47,14 +46,13 @@ class TacticalData:
             else:
                 self.cvd -= trade_amount
                 
-            # رصد صفقات الحيتان (Taker)
             trade_cost_usd = float(trade['cost'])
             if trade_cost_usd > 20000: # (عتبة 20,000 دولار)
                 self.large_trades.append(trade)
                 if len(self.large_trades) > 20: self.large_trades.pop(0)
                 
         except Exception:
-            pass # (تجاهل أخطاء التحويل)
+            pass 
 
     def add_binance_trade(self, trade):
         self.binance_trades.append(trade)
@@ -80,7 +78,6 @@ class TacticalData:
             bids = self.order_book.get('bids', [])
             asks = self.order_book.get('asks', [])
             
-            # (يمكن إضافة منطق رصد الجدران هنا)
             bids_depth = sum(price * amount for price, amount in bids[:10])
             asks_depth = sum(price * amount for price, amount in asks[:10])
             
@@ -89,23 +86,40 @@ class TacticalData:
             return {"bids_depth": 0, "asks_depth": 0, "top_wall": "Error"}
 
     def get_1m_rsi(self):
-        # (في نظام حقيقي، سنحسب هذا من 1-min OHLCV)
-        # (هنا سنحاكيه بشكل مبسط جداً من آخر 20 صفقة)
+        """حساب RSI مبسط جداً من آخر 20 صفقة (كمؤشر للزخم اللحظي)"""
         try:
             if len(self.trades) < 20:
                 return 50.0
             
-            closes = np.array([trade['price'] for trade in self.trades])
-            if len(closes) < 2: return 50.0
+            # (نستخدم سعر آخر 20 صفقة كبديل لشموع الدقيقة الواحدة)
+            closes = np.array([trade['price'] for trade in self.trades if 'price' in trade])[-20:]
+            if len(closes) < 15: return 50.0
             
             deltas = np.diff(closes)
             seed = deltas[:14]
             gains = np.sum(seed[seed >= 0])
-            losses = np.sum(-seed[seed < 0])
+            losses = np.sum(np.abs(seed[seed < 0]))
             
-            if losses == 0: return 100.0
+            if losses == 0: 
+                self.one_min_rsi = 100.0
+                return 100.0
+            if gains == 0:
+                self.one_min_rsi = 0.0
+                return 0.0
+                
             rs = gains / losses
             rsi = 100.0 - (100.0 / (1.0 + rs))
+            
+            # (تحديث سلس لباقي الصفقات)
+            for delta in deltas[14:]:
+                gain = max(delta, 0)
+                loss = max(-delta, 0)
+                gains = (gains * 13 + gain) / 14
+                losses = (losses * 13 + loss) / 14
+                
+                if losses == 0: rsi = 100.0
+                else: rs = gains / losses; rsi = 100.0 - (100.0 / (1.0 + rs))
+
             self.one_min_rsi = rsi
             return rsi
         except Exception:
@@ -119,49 +133,45 @@ class TacticalData:
             "rsi_1m_approx": self.get_1m_rsi(),
             "ob_analysis": self.analyze_order_book()
         }
-# 🔴 --- END OF CHANGE --- 🔴
 
 
 class TradeManager:
     def __init__(self, r2_service, learning_hub=None, data_manager=None, state_manager=None):
         if not CCXT_PRO_AVAILABLE:
-            raise RuntimeError("مكتبة 'ccxt-pro' غير مثبتة. لا يمكن تشغيل TradeManager.")
+            raise RuntimeError("مكتبة 'ccxt.async_support' (جزء من ccxt) غير متاحة. لا يمكن تشغيل TradeManager.")
             
         self.r2_service = r2_service
         self.learning_hub = learning_hub 
-        self.data_manager = data_manager # (لجلب بيانات Layer 1 مثل OHLCV للتحليل الاستراتيجي)
+        self.data_manager = data_manager 
         self.state_manager = state_manager 
         
         self.is_running = False
-        self.sentry_watchlist = {} # (تتم إدارتها بواسطة app.py) {'SOL/USDT': {'strategy_hint': 'breakout_momentum', ...}}
-        self.sentry_tasks = {}     # (المهام قيد التشغيل) {'SOL/USDT': asyncio.Task}
+        self.sentry_watchlist = {} # (تتم إدارتها بواسطة app.py)
+        self.sentry_tasks = {}     # (المهام قيد التشغيل)
         self.tactical_data_cache = {} # (تخزين بيانات TacticalData)
         
-        # (سيتم تهيئة هذه في initialize_sentry_exchanges)
         self.kucoin_ws = None
-        self.binance_ws = None # (للبيانات التأكيدية)
+        self.binance_ws = None 
 
-    # 🔴 --- START OF CHANGE --- 🔴
     async def initialize_sentry_exchanges(self):
         """تهيئة منصات ccxt.pro (WebSockets)"""
         try:
-            print("🔄 [Sentry] تهيئة منصات WebSocket (ccxt.pro)...")
+            print("🔄 [Sentry] تهيئة منصات WebSocket (ccxt.async_support)...")
+            # (استخدام ccxtpro الذي هو الآن 'ccxt.async_support')
             self.kucoin_ws = ccxtpro.kucoin({'newUpdates': True})
             self.binance_ws = ccxtpro.binance({'newUpdates': True})
-            # (اختبار الاتصال)
+            
             await self.kucoin_ws.load_markets()
             await self.binance_ws.load_markets()
             print("✅ [Sentry] منصات WebSocket (KuCoin, Binance) جاهزة.")
         except Exception as e:
-            print(f"❌ [Sentry] فشل تهيئة ccxt.pro: {e}")
-            print("   -> تأكد من إضافة 'ccxt-pro' إلى requirements.txt")
+            print(f"❌ [Sentry] فشل تهيئة ccxt.async_support: {e}")
             if self.kucoin_ws: await self.kucoin_ws.close()
             if self.binance_ws: await self.binance_ws.close()
             raise
 
     async def start_sentry_and_monitoring_loops(self):
         """
-        (يستبدل start_trade_monitoring)
         الحلقة الرئيسية للحارس (Sentry) ومراقب الخروج (Exit Monitor).
         """
         self.is_running = True
@@ -169,31 +179,20 @@ class TradeManager:
         
         while self.is_running:
             try:
-                # 1. جلب قائمة المراقبة (من المستكشف)
-                # (sentry_watchlist يتم تحديثه بواسطة update_sentry_watchlist)
                 watchlist_symbols = set(self.sentry_watchlist.keys())
-                
-                # 2. جلب الصفقات المفتوحة (لمراقبة الخروج)
                 open_trades = await self.get_open_trades()
                 open_trade_symbols = {t['symbol'] for t in open_trades}
-                
-                # 3. دمج القائمتين: كل ما نحتاج لمراقبته
                 symbols_to_monitor = watchlist_symbols.union(open_trade_symbols)
                 
-                # 4. بدء المهام للرموز الجديدة
                 for symbol in symbols_to_monitor:
                     if symbol not in self.sentry_tasks:
                         print(f"   [Sentry] بدء المراقبة التكتيكية لـ {symbol}")
                         strategy_hint = self.sentry_watchlist.get(symbol, {}).get('strategy_hint', 'generic')
-                        
-                        # (إنشاء مخزن بيانات تكتيكية)
                         if symbol not in self.tactical_data_cache:
                             self.tactical_data_cache[symbol] = TacticalData(symbol)
-                            
                         task = asyncio.create_task(self._monitor_symbol_activity(symbol, strategy_hint))
                         self.sentry_tasks[symbol] = task
 
-                # 5. إيقاف المهام للرموز القديمة
                 for symbol in list(self.sentry_tasks.keys()):
                     if symbol not in symbols_to_monitor:
                         print(f"   [Sentry] إيقاف المراقبة التكتيكية لـ {symbol}")
@@ -202,7 +201,7 @@ class TradeManager:
                         if symbol in self.tactical_data_cache:
                             del self.tactical_data_cache[symbol]
 
-                await asyncio.sleep(15) # (التحقق من التغييرات في القائمة كل 15 ثانية)
+                await asyncio.sleep(15) 
                 
             except Exception as error:
                 print(f"❌ [Sentry] خطأ في الحلقة الرئيسية: {error}")
@@ -229,7 +228,6 @@ class TradeManager:
         (يتم استدعاؤها من app.py)
         تحديث قائمة المراقبة التي يستخدمها الحارس (Sentry).
         """
-        # (تحويل القائمة إلى قاموس لسهولة البحث)
         self.sentry_watchlist = {c['symbol']: c for c in candidates}
         print(f"ℹ️ [Sentry] تم تحديث Watchlist. عدد المرشحين: {len(self.sentry_watchlist)}")
 
@@ -242,8 +240,6 @@ class TradeManager:
             'monitored_symbols': list(self.sentry_tasks.keys())
         }
 
-    # 🔴 --- (نهاية دوال الإدارة، بدء دوال المراقبة) --- 🔴
-
     async def _monitor_symbol_activity(self, symbol: str, strategy_hint: str):
         """
         (قلب الحارس)
@@ -252,16 +248,14 @@ class TradeManager:
         if symbol not in self.tactical_data_cache:
             self.tactical_data_cache[symbol] = TacticalData(symbol)
             
-        # (تحويل الرمز لـ Binance)
-        binance_symbol = symbol
-        if symbol == 'BTC/USDT': binance_symbol = 'BTC/USDT' # (مثال، قد نحتاج لآلية أفضل)
+        binance_symbol = symbol.replace('/USDT', 'USDT')
         
         try:
             await asyncio.gather(
                 self._watch_kucoin_trades(symbol),
                 self._watch_kucoin_orderbook(symbol),
-                self._watch_binance_trades(binance_symbol), # (بيانات تأكيدية)
-                self._run_tactical_analysis_loop(symbol, strategy_hint) # (المحلل)
+                self._watch_binance_trades(binance_symbol),
+                self._run_tactical_analysis_loop(symbol, strategy_hint)
             )
         except asyncio.CancelledError:
             print(f"ℹ️ [Sentry] تم إيقاف المراقبة لـ {symbol}.")
@@ -296,17 +290,16 @@ class TradeManager:
 
     async def _watch_binance_trades(self, symbol):
         """حلقة مراقبة الصفقات (Binance - تأكيدية)"""
-        if symbol.endswith('/USDT'):
-            symbol = symbol.replace('/USDT', 'USDT')
-        
         while self.is_running:
             try:
                 trades = await self.binance_ws.watch_trades(symbol)
                 if symbol in self.tactical_data_cache:
-                    for trade in trades:
-                        self.tactical_data_cache[symbol].add_binance_trade(trade)
+                    # (يجب تحويل الرمز مرة أخرى ليتطابق مع مفتاح القاموس)
+                    cache_key = symbol.replace('USDT', '/USDT')
+                    if cache_key in self.tactical_data_cache:
+                        for trade in trades:
+                            self.tactical_data_cache[cache_key].add_binance_trade(trade)
             except Exception as e:
-                # (نتجاهل الأخطاء هنا لأنها بيانات تأكيدية)
                 await asyncio.sleep(30)
 
     async def _run_tactical_analysis_loop(self, symbol: str, strategy_hint: str):
@@ -318,44 +311,36 @@ class TradeManager:
             await asyncio.sleep(1) # (التحليل كل ثانية)
             
             try:
-                # (تجنب التحليل إذا كانت هناك إعادة تحليل استراتيجي)
                 if self.state_manager.trade_analysis_lock.locked():
                     continue
                     
-                # 1. جلب الصفقة المفتوحة (إن وجدت)
                 trade = await self.get_trade_by_symbol(symbol)
                 tactical_data = self.tactical_data_cache.get(symbol)
                 if not tactical_data:
                     continue
                 
-                # 2. جلب أحدث البيانات التكتيكية
                 snapshot = tactical_data.get_tactical_snapshot()
 
                 if trade:
                     # --- وضع مراقب الخروج (Exit Monitor) ---
-                    # (هنا نستخدم snapshot للتحقق من شروط الخروج)
                     exit_reason = self._check_exit_trigger(trade, snapshot)
                     if exit_reason:
                         print(f"🛑 [Sentry] زناد خروج تكتيكي لـ {symbol}: {exit_reason}")
-                        # (جلب السعر الحالي من دفتر الطلبات لتجنب استدعاء API)
-                        current_price = tactical_data.order_book['bids'][0][0] if tactical_data.order_book else None
+                        current_price = tactical_data.order_book['bids'][0][0] if tactical_data.order_book and tactical_data.order_book['bids'] else None
                         if current_price:
-                            # (استدعاء دالة الإغلاق الفوري)
                             await self.immediate_close_trade(symbol, current_price, f"Tactical Exit: {exit_reason}")
-                            # (بعد الإغلاق، ستتم إزالة الرمز من المراقبة في الحلقة الرئيسية)
                 
                 else:
                     # --- وضع الحارس (Sentry Mode) ---
-                    # (التحقق مما إذا كان الرمز لا يزال في قائمة المراقبة)
                     if symbol in self.sentry_watchlist:
                         trigger = self._check_entry_trigger(symbol, strategy_hint, snapshot)
                         if trigger:
                             print(f"✅ [Sentry] زناد دخول تكتيكي لـ {symbol} (استراتيجية: {strategy_hint})")
-                            # (إزالة الرمز من قائمة المراقبة لمنع الدخول المتعدد)
-                            del self.sentry_watchlist[symbol] 
+                            watchlist_entry = self.sentry_watchlist.pop(symbol) # (إزالة الرمز لمنع الدخول المتعدد)
                             
-                            # (استدعاء المنفذ)
-                            await self._execute_smart_entry(symbol, strategy_hint, snapshot)
+                            # (تمرير سياق المستكشف (LLM) إلى المنفذ)
+                            explorer_context = watchlist_entry.get('llm_decision_context', {})
+                            await self._execute_smart_entry(symbol, strategy_hint, snapshot, explorer_context)
             
             except Exception as e:
                 print(f"❌ [Sentry] خطأ في حلقة التحليل التكتيكي لـ {symbol}: {e}")
@@ -366,7 +351,6 @@ class TradeManager:
         (دماغ الزناد التكتيكي)
         يحدد ما إذا كان يجب الدخول الآن بناءً على الاستراتيجية.
         """
-        # (هذا هو المكان الذي يتم فيه دمج المؤشرات اللحظية)
         rsi = data.get('rsi_1m_approx', 50)
         cvd_kucoin = data.get('cvd_kucoin', 0)
         cvd_binance = data.get('cvd_binance', 0)
@@ -375,18 +359,22 @@ class TradeManager:
         # (يمكننا قراءة "الدلتا التكتيكية" من LearningHub هنا)
         
         if strategy_hint == 'breakout_momentum':
-            # (مثال: نريد زخم قوي على المنصتين + اختراق RSI)
             if (cvd_kucoin > 0 and cvd_binance > 0 and 
                 large_trades > 0 and rsi > 60):
                 print(f"   [Trigger] {symbol} Breakout: CVD K={cvd_kucoin:.0f}, B={cvd_binance:.0f}, RSI={rsi:.1f}")
                 return True
                 
         elif strategy_hint == 'mean_reversion':
-            # (مثال: نريد هبوطاً حاداً مع انعكاس CVD)
             if (rsi < 30 and (cvd_kucoin > 0 or cvd_binance > 0)):
                 print(f"   [Trigger] {symbol} Reversion: RSI={rsi:.1f}, CVD K={cvd_kucoin:.0f}")
                 return True
         
+        # (إضافة استراتيجيات أخرى)
+        elif strategy_hint == 'volume_spike':
+             if (large_trades > 2 and cvd_kucoin > 0):
+                 print(f"   [Trigger] {symbol} Volume Spike: LargeTrades={large_trades}, CVD K={cvd_kucoin:.0f}")
+                 return True
+
         return False
 
     def _check_exit_trigger(self, trade: Dict, data: Dict) -> str:
@@ -394,39 +382,49 @@ class TradeManager:
         rsi = data.get('rsi_1m_approx', 50)
         cvd_kucoin = data.get('cvd_kucoin', 0)
         
-        # (مثال: خروج سريع إذا انعكس الزخم)
+        # (مثال لخروج تكتيكي لاستراتيجية الاختراق)
         if trade.get('strategy') == 'breakout_momentum':
             if rsi < 40 and cvd_kucoin < 0:
                 return "Momentum reversal (RSI < 40 + CVD Negative)"
         
-        # (مثال: خروج إذا وصل RSI إلى ذروة الشراء المفرط)
+        # (مثال لخروج تكتيكي لاستراتيجية الانعكاس)
         if trade.get('strategy') == 'mean_reversion':
             if rsi > 75:
                 return "Mean Reversion Target Hit (RSI > 75)"
+        
+        # (التحقق من وقف الخسارة/الهدف الاستراتيجي)
+        # (نحتاج إلى سعر حالي دقيق)
+        if self.tactical_data_cache.get(trade['symbol']) and self.tactical_data_cache[trade['symbol']].order_book:
+            ob = self.tactical_data_cache[trade['symbol']].order_book
+            if ob['bids']:
+                current_price = ob['bids'][0][0] # (أفضل سعر شراء)
                 
-        return None # (لا يوجد سبب للخروج التكتيكي)
+                hard_stop = trade.get('stop_loss')
+                take_profit = trade.get('take_profit')
 
-    # 🔴 --- (نهاية الحارس، بدء المنفذ) --- 🔴
+                if hard_stop and current_price <= hard_stop:
+                    return f"Strategic Stop Loss hit: {current_price} <= {hard_stop}"
+                if take_profit and current_price >= take_profit:
+                    return f"Strategic Take Profit hit: {current_price} >= {take_profit}"
 
-    async def _execute_smart_entry(self, symbol: str, strategy_hint: str, tactical_data: Dict):
+        return None # (لا يوجد سبب للخروج التكتيكي)
+
+    async def _execute_smart_entry(self, symbol: str, strategy_hint: str, tactical_data: Dict, explorer_context: Dict):
         """
         (المنفذ - Layer 3)
         تنفيذ الصفقة بذكاء مع آلية انزلاق.
         """
         print(f"🚀 [Executor] بدء تنفيذ الدخول الذكي لـ {symbol}...")
         
-        # (التحقق من عدم وجود قفل استراتيجي)
         if self.state_manager.trade_analysis_lock.locked():
             print(f"⚠️ [Executor] تم إلغاء الدخول لـ {symbol} بسبب قفل التحليل الاستراتيجي.")
             return
 
-        # (الحصول على قفل R2 لضمان عدم وجود تداخل)
         if not self.r2_service.acquire_lock():
             print(f"⚠️ [Executor] فشل في الحصول على قفل R2 لـ {symbol}. تم الإلغاء.")
             return
             
         try:
-            # (التحقق مرة أخرى من عدم فتح الصفقة أثناء اتخاذ القرار)
             if await self.get_trade_by_symbol(symbol):
                 print(f"ℹ️ [Executor] الصفقة {symbol} مفتوحة بالفعل. تم الإلغاء.")
                 return
@@ -437,57 +435,59 @@ class TradeManager:
                 print(f"❌ [Executor] رأس مال غير كافٍ لـ {symbol}.")
                 return
 
-            # (جلب السعر الحالي من البيانات اللحظية)
-            current_price = self.tactical_data_cache[symbol].order_book['asks'][0][0]
-            if not current_price:
+            # (جلب السعر الحالي من البيانات اللحظية - سعر البيع)
+            current_ask_price = self.tactical_data_cache[symbol].order_book['asks'][0][0]
+            if not current_ask_price:
                 print(f"❌ [Executor] لا يمكن الحصول على السعر الحالي لـ {symbol}.")
                 return
                 
-            amount_to_buy = available_capital / current_price
+            amount_to_buy = available_capital / current_ask_price
             
-            # (تحديد أهداف الخروج - يمكن تحسينها باستخدام LearningHub)
-            # (هنا نستخدم قيم ثابتة كمثال)
-            stop_loss_price = current_price * 0.98 # (وقف خسارة 2%)
-            take_profit_price = current_price * 1.03 # (هدف ربح 3%)
-            exit_profile = "ATR_TRAILING" # (افتراضي من LearningHub)
+            # (تحديد أهداف الخروج بناءً على سياق المستكشف)
+            llm_decision = explorer_context.get('llm_decision_context', {}).get('decision', {})
+            stop_loss_price = llm_decision.get("stop_loss", current_ask_price * 0.98) # (افتراضي 2%)
+            take_profit_price = llm_decision.get("take_profit", current_ask_price * 1.03) # (افتراضي 3%)
+            exit_profile = llm_decision.get('exit_profile', 'ATR_TRAILING')
+            exit_parameters = llm_decision.get('exit_parameters', {})
             
             # --- آلية الانزلاق (Slippage Mechanism) ---
             max_slippage_percent = 0.005 # (0.5%)
-            target_price = current_price * (1 + max_slippage_percent)
+            max_buy_price = current_ask_price * (1 + max_slippage_percent)
             
-            print(f"   [Executor] {symbol}: وضع أمر محدد (Limit Buy) بسعر {current_price} (الحد الأقصى {target_price})")
+            print(f"   [Executor] {symbol}: وضع أمر محدد (Limit Buy) بسعر {current_ask_price} (الحد الأقصى {max_buy_price})")
             
-            # (تنفيذ الأمر - استخدام KuCoin الرئيسي)
-            order = await self.kucoin_ws.create_limit_buy_order(symbol, amount_to_buy, current_price)
+            order = await self.kucoin_ws.create_limit_buy_order(symbol, amount_to_buy, current_ask_price)
             
-            # (انتظار التنفيذ - "مطاردة" مبسطة)
             await asyncio.sleep(5) # (الانتظار 5 ثوانٍ)
             
             order_status = await self.kucoin_ws.fetch_order(order['id'], symbol)
             
             if order_status['status'] == 'closed':
-                # --- نجح التنفيذ ---
                 final_entry_price = order_status['average']
                 print(f"✅ [Executor] تم التنفيذ! {symbol} بسعر {final_entry_price}")
                 
-                # (تسجيل الصفقة في R2 - استخدام الدالة الداخلية)
                 await self._save_trade_to_r2(
                     symbol=symbol,
                     entry_price=final_entry_price,
                     position_size_usd=available_capital,
                     strategy=strategy_hint,
                     exit_profile=exit_profile,
+                    exit_parameters=exit_parameters,
                     stop_loss=stop_loss_price,
                     take_profit=take_profit_price,
-                    tactical_context=tactical_data # (تخزين بيانات الزناد)
+                    tactical_context=tactical_data,
+                    explorer_context=explorer_context
                 )
 
             else:
                 # --- فشل التنفيذ (الانزلاق) ---
                 print(f"⚠️ [Executor] فشل تنفيذ الأمر المحدد لـ {symbol} في الوقت المناسب. إلغاء الأمر.")
                 await self.kucoin_ws.cancel_order(order['id'], symbol)
-                # (يمكن إضافة منطق "المطاردة" هنا - إعادة المحاولة بسعر أعلى)
-                # (للبساطة، سنلغي هذه المحاولة)
+                # (إعادة العملة إلى قائمة المراقبة بعد فترة هدوء)
+                await asyncio.sleep(60)
+                if symbol not in await self.get_open_trades():
+                     self.sentry_watchlist[symbol] = {"symbol": symbol, "strategy_hint": strategy_hint, "llm_decision_context": explorer_context}
+
 
         except Exception as e:
             print(f"❌ [Executor] فشل فادح أثناء التنفيذ لـ {symbol}: {e}")
@@ -503,45 +503,44 @@ class TradeManager:
             strategy = kwargs.get('strategy')
             exit_profile = kwargs.get('exit_profile')
             
-            # (إنشاء كائن الصفقة)
-            expected_target_time = (datetime.now() + timedelta(minutes=15)).isoformat() # (افتراضي قصير)
+            expected_target_time = (datetime.now() + timedelta(minutes=15)).isoformat() 
             
+            # (دمج سياق المستكشف (Layer 1) مع سياق الحارس (Layer 2))
+            decision_data = {
+                "reasoning": f"Tactical entry by Sentry based on {strategy}",
+                "strategy": strategy,
+                "exit_profile": exit_profile,
+                "exit_parameters": kwargs.get('exit_parameters', {}),
+                "tactical_context_at_decision": kwargs.get('tactical_context', {}),
+                "explorer_decision_context": kwargs.get('explorer_context', {})
+            }
+
             new_trade = {
                 "id": str(int(datetime.now().timestamp())),
                 "symbol": symbol,
                 "entry_price": kwargs.get('entry_price'),
                 "entry_timestamp": datetime.now().isoformat(),
-                "decision_data": {
-                    # (هنا نضع بيانات المنفذ والحارس)
-                    "reasoning": f"Tactical entry by Sentry based on {strategy}",
-                    "strategy": strategy,
-                    "exit_profile": exit_profile,
-                    "exit_parameters": {}, # (يمكن ملؤها)
-                    "tactical_context_at_decision": kwargs.get('tactical_context', {}),
-                    # (البيانات من المستكشف (Layer 1) يجب تمريرها أيضاً)
-                    "explorer_decision_context": self.sentry_watchlist.get(symbol, {}).get('llm_decision_context', {})
-                },
+                "decision_data": decision_data,
                 "status": "OPEN",
                 "stop_loss": kwargs.get('stop_loss'),
                 "take_profit": kwargs.get('take_profit'),
-                "dynamic_stop_loss": kwargs.get('stop_loss'), # (البدء بوقف الخسارة الأولي)
+                "dynamic_stop_loss": kwargs.get('stop_loss'),
                 "trade_type": "LONG", 
                 "position_size_usd": kwargs.get('position_size_usd'),
                 "expected_target_minutes": 15,
                 "expected_target_time": expected_target_time,
-                "is_monitored": True, # (سيتم مراقبتها بواسطة Sentry للخروج)
+                "is_monitored": True,
                 "strategy": strategy,
-                "monitoring_started": True # (لأن Sentry يراقبها بالفعل)
+                "monitoring_started": True
             }
             
-            # (تحديث R2)
             trades = await self.r2_service.get_open_trades_async()
             trades.append(new_trade)
             await self.r2_service.save_open_trades_async(trades)
             
             portfolio_state = await self.r2_service.get_portfolio_state_async()
             portfolio_state["invested_capital_usd"] = kwargs.get('position_size_usd')
-            portfolio_state["current_capital_usd"] = 0.0 # (نفترض استخدام كل الرصيد)
+            portfolio_state["current_capital_usd"] = 0.0 
             portfolio_state["total_trades"] = portfolio_state.get("total_trades", 0) + 1
             await self.r2_service.save_portfolio_state_async(portfolio_state)
 
@@ -557,9 +556,6 @@ class TradeManager:
             print(f"❌ [R2] فشل حفظ الصفقة لـ {symbol}: {e}")
             traceback.print_exc()
 
-
-    # 🔴 --- (الدوال المتبقية هي من trade_manager القديم، مع تعديلات طفيفة) --- 🔴
-
     async def close_trade(self, trade_to_close, close_price, reason="System Close"):
         """(لا تغيير جوهري) - لا يزال مسؤولاً عن حساب PnL وتحديث R2 وتشغيل LearningHub"""
         try:
@@ -585,11 +581,9 @@ class TradeManager:
             trade_to_close['pnl_usd'] = pnl
             trade_to_close['pnl_percent'] = pnl_percent
 
-            # (الأرشيف وتحديث الملخص - لا تغيير)
             await self._archive_closed_trade(trade_to_close)
             await self._update_trade_summary(trade_to_close)
 
-            # (تحديث المحفظة - لا تغيير)
             portfolio_state = await self.r2_service.get_portfolio_state_async()
             current_capital = portfolio_state.get("current_capital_usd", 0)
             new_capital = current_capital + position_size + pnl
@@ -602,12 +596,10 @@ class TradeManager:
                 portfolio_state["total_loss_usd"] = portfolio_state.get("total_loss_usd", 0.0) + abs(pnl)
             await self.r2_service.save_portfolio_state_async(portfolio_state)
 
-            # (إزالة الصفقة من open_trades.json - لا تغيير)
             open_trades = await self.r2_service.get_open_trades_async()
             trades_to_keep = [t for t in open_trades if t.get('id') != trade_to_close.get('id')]
             await self.r2_service.save_open_trades_async(trades_to_keep)
             
-            # (إيقاف المراقبة - الحلقة الرئيسية ستلتقط هذا)
             if symbol in self.sentry_tasks:
                 print(f"ℹ️ [Sentry] الصفقة {symbol} أغلقت، ستتوقف المراقبة.")
             
@@ -616,7 +608,7 @@ class TradeManager:
                 "new_capital": new_capital, "strategy": strategy, "reason": reason
             })
 
-            # (تشغيل التعلم - لا تغيير، هذا هو قلب النظام)
+            # (تشغيل التعلم - لا تغيير)
             if self.learning_hub and self.learning_hub.initialized:
                 print(f"🧠 [LearningHub] تشغيل التعلم (Reflector+Stats) لـ {symbol}...")
                 await self.learning_hub.analyze_trade_and_learn(trade_to_close, reason)
@@ -662,19 +654,16 @@ class TradeManager:
             if re_analysis_decision.get('action') == "UPDATE_TRADE":
                 trade_to_update['stop_loss'] = re_analysis_decision['new_stop_loss']
                 trade_to_update['take_profit'] = re_analysis_decision['new_take_profit']
-                # (ملاحظة: dynamic_stop_loss يُدار بواسطة Sentry، لكننا نحدث القيمة الأولية)
                 trade_to_update['dynamic_stop_loss'] = re_analysis_decision['new_stop_loss'] 
                 trade_to_update['decision_data']['exit_profile'] = re_analysis_decision['new_exit_profile']
                 trade_to_update['decision_data']['exit_parameters'] = re_analysis_decision['new_exit_parameters']
                 print(f"   🔄 (Explorer) {symbol}: Exit profile updated to {re_analysis_decision['new_exit_profile']}")
             
-            # (تحديثات أخرى)
             new_expected_minutes = re_analysis_decision.get('new_expected_minutes', 15)
             trade_to_update['expected_target_minutes'] = new_expected_minutes
             trade_to_update['expected_target_time'] = (datetime.now() + timedelta(minutes=new_expected_minutes)).isoformat()
             trade_to_update['decision_data']['reasoning'] = re_analysis_decision.get('reasoning')
 
-            # (حفظ التغييرات في R2)
             open_trades = await self.r2_service.get_open_trades_async()
             for i, trade in enumerate(open_trades):
                 if trade.get('id') == trade_to_update.get('id'):
@@ -733,4 +722,4 @@ class TradeManager:
         except Exception as e: print(f"❌ Failed to get trade by symbol {symbol}: {e}"); return None
 
 
-print(f"✅ Trade Manager loaded - V5 (Sentry/Executor with ccxt.pro: {CCXT_PRO_AVAILABLE})")
+print(f"✅ Trade Manager loaded - V5.1 (Sentry/Executor with ccxt.async_support: {CCXT_PRO_AVAILABLE})")