Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (Updated to V6.5 - Added Sanity Check to Executor)
+# trade_manager.py (Updated to V6.6 - Fixed Take-Profit Execution Logic)
 import asyncio
 import json
 import time
@@ -6,10 +6,9 @@ import traceback
 import os 
 from datetime import datetime, timedelta
 from typing import Dict, Any, List
-from collections import deque, defaultdict # (إضافة defaultdict)
+from collections import deque, defaultdict 
 
 try:
-    # (نستخدم async_support لوظائف fetch غير المتزامنة)
     import ccxt.async_support as ccxtasync
     CCXT_ASYNC_AVAILABLE = True
 except ImportError:
@@ -20,7 +19,6 @@ except ImportError:
 import numpy as np
 from helpers import safe_float_conversion
 
-# (TacticalData - لا تغيير)
 class TacticalData:
     """
     (محدث) لتخزين بيانات تأكيد من مصادر متعددة بدلاً من Binance فقط.
@@ -34,7 +32,6 @@ class TacticalData:
         self.one_min_rsi = 50.0
         self.last_update = time.time()
         
-        # (بيانات التأكيد الجديدة)
         self.confirmation_trades = defaultdict(lambda: deque(maxlen=50))
         self.confirmation_cvd = defaultdict(float)
         
@@ -134,35 +131,31 @@ class TradeManager:
         self.sentry_tasks = {}
         self.tactical_data_cache = {}
         
-        self.sentry_lock = asyncio.Lock() # (إصلاح V5.8)
+        self.sentry_lock = asyncio.Lock()
         
-        self.kucoin_rest = None # (المنصة الأساسية)
-        self.confirmation_exchanges = {} # (المنصات الثانوية للتأكيد)
-        self.polling_interval = 1.5 # (KuCoin - سريع)
-        self.confirmation_polling_interval = 3.0 # (منصات التأكيد - أبطأ قليلاً)
+        self.kucoin_rest = None
+        self.confirmation_exchanges = {}
+        self.polling_interval = 1.5
+        self.confirmation_polling_interval = 3.0
 
-    async def initialize_sentry_exchanges(self): # (محدث V6.1)
+    async def initialize_sentry_exchanges(self): 
         """
         (محدث V6.1) تهيئة KuCoin (أساسي) ومنصات تأكيد متعددة (ثانوية).
-        (تمت إزالة المصادقة - الوضع الوهمي)
         """
         try:
             print("🔄 [Sentry] تهيئة منصات التداول (KuCoin REST ومنصات التأكيد)...")
             
-            # 1. تهيئة KuCoin (الأساسي) - (بدون مصادقة، للبيانات العامة فقط)
             print("   [Sentry] تهيئة KuCoin للبيانات العامة (وضع المحاكاة).")
             self.kucoin_rest = ccxtasync.kucoin()
             await self.kucoin_rest.load_markets()
             print("✅ [Sentry] منصة REST الأساسية (KuCoin) جاهزة (بيانات عامة فقط).")
 
-            # 2. تهيئة منصات التأكيد (الثانوية)
             self.confirmation_exchanges = {}
             confirmation_exchange_ids = ['bybit', 'okx', 'gateio'] 
             
             print(f"   [Sentry] تهيئة منصات التأكيد (Confirmation Exchanges): {', '.join(confirmation_exchange_ids)}")
             for ex_id in confirmation_exchange_ids:
                 try:
-                    # (التهيئة بدون مفاتيح API للبيانات العامة)
                     exchange = getattr(ccxtasync, ex_id)()
                     await exchange.load_markets()
                     self.confirmation_exchanges[ex_id] = exchange
@@ -185,37 +178,31 @@ class TradeManager:
             for ex in self.confirmation_exchanges.values(): await ex.close()
             raise
 
-    async def start_sentry_and_monitoring_loops(self): # (محدث V5.8)
+    async def start_sentry_and_monitoring_loops(self):
         """الحلقة الرئيسية للحارس (Sentry) ومراقب الخروج (Exit Monitor)."""
         self.is_running = True
         print(f"✅ [Sentry] بدء حلقات المراقبة التكتيكية (Layer 2 - API Polling)...")
         while self.is_running:
             try:
-                # الحصول على قائمة الرموز المطلوب مراقبتها (داخل القفل)
                 async with self.sentry_lock:
                     watchlist_symbols = set(self.sentry_watchlist.keys())
                 
-                # (جلب الصفقات المفتوحة - هذا I/O، نتركه خارج القفل)
                 open_trades = await self.get_open_trades()
                 open_trade_symbols = {t['symbol'] for t in open_trades}
                 
                 symbols_to_monitor = watchlist_symbols.union(open_trade_symbols)
                 current_tasks = set(self.sentry_tasks.keys())
 
-                # الرموز التي يجب إضافتها
                 symbols_to_add = symbols_to_monitor - current_tasks
                 for symbol in symbols_to_add:
                     print(f"   [Sentry] بدء المراقبة التكتيكية (Polling) لـ {symbol}")
                     
-                    # (الحصول على التلميح داخل القفل لضمان عدم تغييره أثناء القراءة)
-                    strategy_hint = 'generic' # قيمة افتراضية
+                    strategy_hint = 'generic' 
                     if symbol in watchlist_symbols:
                          async with self.sentry_lock:
-                            # (التأكد من أن الرمز لا يزال موجوداً بعد تحرير القفل)
                             if symbol in self.sentry_watchlist:
                                 strategy_hint = self.sentry_watchlist.get(symbol, {}).get('strategy_hint', 'generic')
                     elif symbol in open_trade_symbols:
-                        # (إذا كانت صفقة مفتوحة، احصل على الاستراتيجية من بيانات الصفقة)
                         trade = next((t for t in open_trades if t['symbol'] == symbol), None)
                         if trade:
                             strategy_hint = trade.get('strategy', 'generic')
@@ -226,7 +213,6 @@ class TradeManager:
                     task = asyncio.create_task(self._monitor_symbol_activity_polling(symbol, strategy_hint))
                     self.sentry_tasks[symbol] = task
 
-                # الرموز التي يجب إزالتها
                 symbols_to_remove = current_tasks - symbols_to_monitor
                 for symbol in symbols_to_remove:
                     print(f"   [Sentry] إيقاف المراقبة التكتيكية (Polling) لـ {symbol}")
@@ -236,13 +222,13 @@ class TradeManager:
                     if symbol in self.tactical_data_cache: 
                         del self.tactical_data_cache[symbol]
 
-                await asyncio.sleep(15) # فاصل زمني للحلقة الرئيسية
+                await asyncio.sleep(15)
                 
             except Exception as error:
                 print(f"❌ [Sentry] خطأ في الحلقة الرئيسية: {error}"); traceback.print_exc(); await asyncio.sleep(60)
 
     async def stop_sentry_loops(self):
-        """(محدث) إيقاف جميع مهام المراقبة وإغلاق جميع اتصالات REST"""
+        """إيقاف جميع مهام المراقبة وإغلاق جميع اتصالات REST"""
         self.is_running = False
         print("🛑 [Sentry] إيقاف جميع حلقات المراقبة...")
         for task in self.sentry_tasks.values(): task.cancel()
@@ -262,15 +248,14 @@ class TradeManager:
             print("✅ [Sentry] تم إغلاق اتصالات التداول (REST).")
         except Exception as e: print(f"⚠️ [Sentry] خطأ أثناء إغلاق الاتصالات: {e}")
 
-    async def update_sentry_watchlist(self, candidates: List[Dict]): # (محدث V5.8)
+    async def update_sentry_watchlist(self, candidates: List[Dict]):
         """تحديث قائمة المراقبة التي يستخدمها الحارس (Sentry)."""
-        async with self.sentry_lock: # (استخدام القفل قبل الكتابة)
+        async with self.sentry_lock: 
             self.sentry_watchlist = {c['symbol']: c for c in candidates}
             print(f"ℹ️ [Sentry] تم تحديث Watchlist. عدد المرشحين: {len(self.sentry_watchlist)}")
 
     def get_sentry_status(self):
-        """(محدث) لواجهة برمجة التطبيقات /system-status"""
-        # (لا حاجة للقفل هنا، هذه قراءة سريعة لعدد العناصر فقط)
+        """لواجهة برمجة التطبيقات /system-status"""
         active_monitoring_count = len(self.sentry_tasks)
         watchlist_symbols_list = list(self.sentry_watchlist.keys())
         
@@ -284,16 +269,15 @@ class TradeManager:
 
     async def _monitor_symbol_activity_polling(self, symbol: str, strategy_hint: str):
         """
-        (محدث)
         يشغل حلقات Polling متوازية (KuCoin + منصات التأكيد) ويشغل منطق التحليل.
         """
         if symbol not in self.tactical_data_cache:
             self.tactical_data_cache[symbol] = TacticalData(symbol)
 
         tasks_to_gather = [
-            self._poll_kucoin_data(symbol), # (الأساسي)
-            self._poll_confirmation_data(symbol), # (الجديد - للتأكيد)
-            self._run_tactical_analysis_loop(symbol, strategy_hint) # (الدماغ)
+            self._poll_kucoin_data(symbol), 
+            self._poll_confirmation_data(symbol), 
+            self._run_tactical_analysis_loop(symbol, strategy_hint)
         ]
 
         try:
@@ -305,14 +289,13 @@ class TradeManager:
             traceback.print_exc()
         finally:
             print(f"🛑 [Sentry] إنهاء جميع مهام (Polling) {symbol}")
-            # (التنظيف يحدث بالفعل في الحلقة الرئيسية، ولكن هذا ضمان إضافي)
             if symbol in self.sentry_tasks: 
                 self.sentry_tasks.pop(symbol, None)
             if symbol in self.tactical_data_cache: 
                 del self.tactical_data_cache[symbol]
 
     async def _poll_kucoin_data(self, symbol):
-        """(لا تغيير) حلقة استقصاء (Polling) لبيانات KuCoin (الأساسية)"""
+        """حلقة استقصاء (Polling) لبيانات KuCoin (الأساسية)"""
         while self.is_running:
             try:
                 if not self.kucoin_rest:
@@ -326,7 +309,7 @@ class TradeManager:
                     self.tactical_data_cache[symbol].set_order_book(ob)
 
                 # 2. جلب آخر الصفقات
-                since_timestamp = int((time.time() - 60) * 1000) # (آخر 60 ثانية)
+                since_timestamp = int((time.time() - 60) * 1000) 
                 trades = await self.kucoin_rest.fetch_trades(symbol, since=since_timestamp, limit=50)
                 if symbol in self.tactical_data_cache:
                     trades.sort(key=lambda x: x['timestamp'])
@@ -339,7 +322,7 @@ class TradeManager:
                 print(f"⏳ [Sentry Polling] {symbol} KuCoin Rate Limit Exceeded: {e}. زيادة فترة الانتظار...")
                 await asyncio.sleep(10)
             except asyncio.CancelledError:
-                raise # تمرير الإلغاء
+                raise 
             except Exception as e:
                 print(f"⚠️ [Sentry Polling] خطأ في {symbol} KuCoin data polling: {e}")
                 await asyncio.sleep(5)
@@ -348,59 +331,50 @@ class TradeManager:
         """(جديد) حلقة استقصاء (Polling) لبيانات منصات التأكيد (Bybit, OKX, etc.)"""
         if not self.confirmation_exchanges:
             print(f"   [Sentry Conf] {symbol} - لا توجد منصات تأكيد، سيتم الاعتماد على KuCoin فقط.")
-            return # إنهاء المهمة إذا لم يتم تهيئة أي منصة
+            return 
 
-        # (ننتظر قليلاً قبل بدء حلقة التأكيد لتوزيع الحمل)
         await asyncio.sleep(self.confirmation_polling_interval / 2) 
 
         while self.is_running:
             try:
                 tasks = []
-                # (إنشاء مهام لجلب البيانات من كل منصة تأكيد بالتوازي)
                 for ex_id, exchange in self.confirmation_exchanges.items():
                     tasks.append(self._fetch_confirmation_trades(ex_id, exchange, symbol))
                 
                 await asyncio.gather(*tasks)
-
-                # (الانتظار قبل الدورة التالية)
                 await asyncio.sleep(self.confirmation_polling_interval)
 
             except asyncio.CancelledError:
-                raise # (تمرير الإلغاء للخارج)
+                raise 
             except Exception as e:
                 print(f"⚠️ [Sentry Conf] خطأ في حلقة التأكيد لـ {symbol}: {e}")
-                await asyncio.sleep(10) # انتظار عند حدوث خطأ عام في الحلقة
+                await asyncio.sleep(10) 
 
     async def _fetch_confirmation_trades(self, ex_id: str, exchange: ccxtasync.Exchange, symbol: str):
         """(جديد) دالة مساعدة لجلب الصفقات من منصة تأكيد واحدة"""
         try:
-            # التحقق مما إذا كانت المنصة تدعم هذا الرمز
             if symbol not in exchange.markets:
-                # print(f"   [Sentry Conf] {ex_id} لا تدعم {symbol}. إزالة من المراقبة.")
-                # (الأفضل هو مجرد التجاهل)
                 return
 
-            since_timestamp = int((time.time() - 60) * 1000) # (آخر 60 ثانية)
+            since_timestamp = int((time.time() - 60) * 1000) 
             trades = await exchange.fetch_trades(symbol, since=since_timestamp, limit=50)
             
             if symbol in self.tactical_data_cache:
                 trades.sort(key=lambda x: x['timestamp'])
                 for trade in trades:
-                    # (إضافة البيانات إلى الكاش المخصص)
                     self.tactical_data_cache[symbol].add_confirmation_trade(ex_id, trade)
         
         except ccxtasync.RateLimitExceeded:
             print(f"⏳ [Sentry Conf] {ex_id} Rate Limit لـ {symbol}. الانتظار...")
-            await asyncio.sleep(15) # انتظار أطول لهذه المنصة
+            await asyncio.sleep(15) 
         except asyncio.CancelledError:
-            raise # تمرير الإلغاء
+            raise 
         except Exception as e:
-            # (الفشل في منصة واحدة لا يجب أن يوقف الحلقة، فقط نتجاهل بياناتها هذه المرة)
             pass
     
 
     async def _run_tactical_analysis_loop(self, symbol: str, strategy_hint: str):
-        """(محدث V6.4) (دماغ الحارس) يشغل التحليل التكتيكي كل ثانية."""
+        """(محدث V6.6) (دماغ الحارس) يشغل التحليل التكتيكي كل ثانية."""
         while self.is_running:
             await asyncio.sleep(1) # (التحليل السريع كل ثانية)
             try:
@@ -412,22 +386,30 @@ class TradeManager:
                 snapshot = tactical_data.get_tactical_snapshot()
                 
                 if trade:
-                    # 🔴 --- LOGIC CHANGE (V6.4) --- 🔴
-                    # (منطق الخروج الآن يتحقق فقط من SL/TP)
-                    exit_reason = self._check_exit_trigger(trade, snapshot)
+                    # 🔴 --- (الإصلاح V6.6) --- 🔴
+                    # (سيتم تمرير snapshot إلى الدالة المحدثة)
+                    exit_reason = self._check_exit_trigger(trade, snapshot, tactical_data)
                     if exit_reason:
                         print(f"🛑 [Sentry] زناد خروج استراتيجي لـ {symbol}: {exit_reason}")
-                        current_price = tactical_data.order_book['bids'][0][0] if tactical_data.order_book and tactical_data.order_book.get('bids') and len(tactical_data.order_book['bids']) > 0 else None
-                        if current_price: 
-                            await self.immediate_close_trade(symbol, current_price, f"Strategic Exit: {exit_reason}")
+                        
+                        # (تحديد السعر الحقيقي للإغلاق)
+                        current_price_to_close = None
+                        if "Take Profit" in exit_reason:
+                            # إذا كان جني الأرباح، نستخدم السعر الذي حقق الهدف
+                            current_price_to_close = trade.get('take_profit')
+                        elif tactical_data.order_book and tactical_data.order_book.get('bids') and len(tactical_data.order_book['bids']) > 0:
+                            # إذا كان وقف الخسارة، نستخدم أفضل سعر شراء (Bid)
+                            current_price_to_close = tactical_data.order_book['bids'][0][0]
                         else:
-                            # (احتياطي: إذا فشل دفتر الطلبات، استخدم آخر سعر صفقة)
+                            # (احتياطي: إذا فشل كل شيء، استخدم آخر سعر صفقة)
                             if tactical_data.trades:
-                                current_price = tactical_data.trades[-1].get('price')
-                                if current_price:
-                                    await self.immediate_close_trade(symbol, current_price, f"Strategic Exit (Fallback Price): {exit_reason}")
+                                current_price_to_close = tactical_data.trades[-1].get('price')
+
+                        if current_price_to_close: 
+                            await self.immediate_close_trade(symbol, current_price_to_close, f"Strategic Exit: {exit_reason}")
+                        else:
+                            print(f"⚠️ [Sentry] {symbol} زناد خروج ولكن لا يمكن تحديد سعر الإغلاق!")
                 else:
-                    # (منطق الدخول - محدث V5.8)
                     async with self.sentry_lock:
                         is_still_on_watchlist = symbol in self.sentry_watchlist
 
@@ -436,7 +418,6 @@ class TradeManager:
                         if trigger:
                             print(f"✅ [Sentry] زناد دخول تكتيكي لـ {symbol} (استراتيجية: {strategy_hint})")
                             
-                            # (إزالة العنصر من قائمة المراقبة باستخدام القفل)
                             watchlist_entry = None
                             async with self.sentry_lock:
                                 watchlist_entry = self.sentry_watchlist.pop(symbol, None)
@@ -445,10 +426,10 @@ class TradeManager:
                                 explorer_context = watchlist_entry.get('llm_decision_context', {})
                                 await self._execute_smart_entry(symbol, strategy_hint, snapshot, explorer_context)
             except asyncio.CancelledError:
-                raise # تمرير الإلغاء
+                raise 
             except Exception as e: print(f"❌ [Sentry] خطأ في حلقة التحليل التكتيكي لـ {symbol}: {e}"); traceback.print_exc()
 
-    def _check_entry_trigger(self, symbol: str, strategy_hint: str, data: Dict) -> bool: # (محدث V5.9)
+    def _check_entry_trigger(self, symbol: str, strategy_hint: str, data: Dict) -> bool:
         """(محدث V5.9) إضافة trend_following إلى منطق الزناد."""
         
         rsi = data.get('rsi_1m_approx', 50)
@@ -458,15 +439,10 @@ class TradeManager:
         cvd_conf_agg = data.get('cvd_confirmation_aggregate', 0)
         cvd_conf_sources_count = len(data.get('cvd_confirmation_sources', {}))
         
-        # (إصلاح V5.9: دمج trend_following مع breakout_momentum)
         if strategy_hint in ['breakout_momentum', 'trend_following']:
-            # استراتيجية الزخم *تتطلب* تدفقاً إيجابياً
             if cvd_kucoin <= 0:
-                return False # (لا يوجد زخم إذا كان CVD سلبياً)
-
-            # (الشروط المخففة: RSI > 55)
+                return False 
             if (rsi > 55):
-                 # (الفيتو المخفf: نوقف فقط إذا كانت المنصات الأخرى تبيع ضدنا بقوة)
                  if cvd_conf_sources_count > 0 and cvd_conf_agg < (cvd_kucoin * -0.5):
                      print(f"   [Trigger Hold] {symbol} Breakout/Trend: KuCoin CVD ({cvd_kucoin:.0f}) إيجابي، لكن منصات التأكيد ({cvd_conf_agg:.0f}) تبيع بقوة.")
                      return False
@@ -475,52 +451,69 @@ class TradeManager:
                  return True
                  
         elif strategy_hint == 'mean_reversion':
-            # استراتيجية الانعكاس *لا* تتطلب CVD إيجابي
-            # (الشروط المخففة: RSI < 35)
             if (rsi < 35): 
                 print(f"   [Trigger] {symbol} Reversion: RSI={rsi:.1f}, K_CVD={cvd_kucoin:.0f} (CVD check ignored)")
                 return True
                 
         elif strategy_hint == 'volume_spike':
-             # طفرة الحجم قد تكون بيعاً أو شراءً
-             # (الشروط المخففة: large_trades > 0)
              if (large_trades > 0): 
                  print(f"   [Trigger] {symbol} Volume Spike: LargeTrades={large_trades}, K_CVD={cvd_kucoin:.0f} (CVD check ignored)")
                  return True
                  
         return False
 
-    # 🔴 --- START OF CHANGE (V6.4 - STRATEGIC EXITS ONLY) --- 🔴
-    def _check_exit_trigger(self, trade: Dict, data: Dict) -> str:
-        """(محدث V6.4) يراقب فقط وقف الخسارة وجني الأرباح الاستراتيجي."""
+    # 🔴 --- START OF CHANGE (V6.6 - TP FIX) --- 🔴
+    def _check_exit_trigger(self, trade: Dict, data: Dict, tactical_data: TacticalData) -> str:
+        """(محدث V6.6) يراقب وقف الخسارة وجني الأرباح باستخدام (Bid) و (Last Trade Price)"""
         
         symbol = trade['symbol']
+        hard_stop = trade.get('stop_loss')
+        take_profit = trade.get('take_profit')
         
-        # --- 1. التحقق من وقف الخسارة/جني الأرباح الاستراتيجي (دائماً فعال) ---
-        if symbol in self.tactical_data_cache and self.tactical_data_cache[symbol].order_book:
-            ob = self.tactical_data_cache[symbol].order_book
-            if ob and ob.get('bids') and len(ob['bids']) > 0: # (تحقق إضافي)
-                current_price = ob['bids'][0][0]
-                hard_stop = trade.get('stop_loss')
-                take_profit = trade.get('take_profit')
-                
-                # (التأكد من أن القيم ليست None وقابلة للمقارنة)
-                if hard_stop and current_price and current_price <= hard_stop: 
-                    return f"Strategic Stop Loss hit: {current_price} <= {hard_stop}"
-                if take_profit and current_price and current_price >= take_profit: 
-                    return f"Strategic Take Profit hit: {current_price} >= {take_profit}"
+        # --- 1. جلب الأسعار المتاحة ---
         
-        # --- 2. (تمت إزالة الخروج التكتيكي المستند إلى RSI/CVD بالكامل) ---
+        # السعر 1: أفضل سعر شراء (Bid) - (الأكثر أماناً لوقف الخسارة)
+        best_bid_price = None
+        if tactical_data.order_book and tactical_data.order_book.get('bids') and len(tactical_data.order_book['bids']) > 0:
+            best_bid_price = tactical_data.order_book['bids'][0][0]
+
+        # السعر 2: آخر سعر تداول (Last Trade) - (الأكثر دقة لجني الأرباح)
+        last_trade_price = None
+        if tactical_data.trades: # (trades هو deque)
+            try:
+                last_trade_price = tactical_data.trades[-1].get('price')
+            except (IndexError, AttributeError):
+                pass # (يبقى None إذا كان deque فارغاً)
+
+        # (يجب أن يكون لدينا سعر واحد على الأقل للمتابعة)
+        if best_bid_price is None and last_trade_price is None:
+            return None # لا يمكن تحديد السعر، انتظر الدورة التالية
+
+        # (استخدم bid إذا فشل last_trade، أو العكس)
+        current_price_for_sl = best_bid_price if best_bid_price is not None else last_trade_price
+        
+        # (استخدم السعر الأعلى بينهما لجني الأرباح)
+        current_price_for_tp = max(
+            filter(None, [best_bid_price, last_trade_price]), 
+            default=None
+        )
+
+        # --- 2. التحقق من وقف الخسارة الاستراتيجي (يستخدم سعر Bid الآمن) ---
+        if hard_stop and current_price_for_sl and current_price_for_sl <= hard_stop: 
+            return f"Strategic Stop Loss hit: {current_price_for_sl} <= {hard_stop}"
+        
+        # --- 3. التحقق من جني الأرباح الاستراتيجي (يستخدم السعر الأعلى المتاح) ---
+        if take_profit and current_price_for_tp and current_price_for_tp >= take_profit: 
+            return f"Strategic Take Profit hit: {current_price_for_tp} >= {take_profit}"
         
         return None # لا يوجد سبب للخروج
     # 🔴 --- END OF CHANGE --- 🔴
 
 
-    async def _execute_smart_entry(self, symbol: str, strategy_hint: str, tactical_data: Dict, explorer_context: Dict): # (محدث V6.5)
+    async def _execute_smart_entry(self, symbol: str, strategy_hint: str, tactical_data: Dict, explorer_context: Dict):
         """(المنفذ الوهمي - Layer 3) يحاكي تنفيذ الصفقة ويحفظها في R2."""
         print(f"🚀 [Executor] بدء تنفيذ الدخول الذكي (وهمي) لـ {symbol}...")
         
-        # (إضافة explorer_context إلى متغير محلي لإعادة الاستخدام عند الفشل)
         context_for_retry = explorer_context 
         
         if self.state_manager.trade_analysis_lock.locked(): 
@@ -532,12 +525,10 @@ class TradeManager:
             return
 
         try:
-            # 1. التحقق من الصفقات المفتوحة ورأس المال (من R2)
             if await self.get_trade_by_symbol(symbol): 
                 print(f"ℹ️ [Executor] الصفقة {symbol} مفتوحة بالفعل (وهمياً). تم الإلغاء."); 
                 return
             
-            # (تحقق إضافي للتأكد من عدم وجود أي صفقات أخرى مفتوحة قبل استهلاك رأس المال)
             all_open_trades = await self.get_open_trades()
             if len(all_open_trades) > 0:
                 print(f"❌ [Executor] يوجد صفقة أخرى مفتوحة ({all_open_trades[0]['symbol']}). لا يمكن فتح {symbol}.");
@@ -550,7 +541,6 @@ class TradeManager:
                 print(f"❌ [Executor] رأس مال وهمي غير كافٍ لـ {symbol}."); 
                 return
 
-            # 2. الحصول على السعر الحالي من البيانات العامة
             current_ask_price = None
             if symbol in self.tactical_data_cache and self.tactical_data_cache[symbol].order_book:
                  ob = self.tactical_data_cache[symbol].order_book
@@ -561,15 +551,13 @@ class TradeManager:
                 print(f"❌ [Executor] لا يمكن الحصول على السعر الحالي (من البيانات العامة) لـ {symbol}."); 
                 return
 
-            # 3. تحديد تفاصيل الصفقة الوهمية
             llm_decision = explorer_context.get('decision', {}) 
             stop_loss_price = llm_decision.get("stop_loss", current_ask_price * 0.98)
             take_profit_price = llm_decision.get("take_profit", current_ask_price * 1.03)
             exit_profile = llm_decision.get('exit_profile', 'ATR_TRAILING')
             exit_parameters = llm_decision.get('exit_parameters', {})
 
-            # 🔴 --- START OF CHANGE (V6.5 - SANITY CHECK) --- 🔴
-            # 4. فحص السلامة: التحقق من أن السعر الحالي يقع بين وقف الخسارة وجني الأرباح
+            # (V6.5 - فحص السلامة)
             if not (stop_loss_price and take_profit_price):
                 print(f"❌ [Executor] {symbol}: بيانات SL/TP غير صالحة من النموذج. تم الإلغاء.")
                 return
@@ -581,13 +569,10 @@ class TradeManager:
             if current_ask_price <= stop_loss_price:
                 print(f"⚠️ [Executor] {symbol}: السعر الحالي ({current_ask_price}) أقل من وقف الخسارة ({stop_loss_price}). الصفقة فاشلة. تم الإلغاء.")
                 return
-            # 🔴 --- END OF CHANGE --- 🔴
             
-            # 5. (المحاكاة) - نفترض أن الصفقة تمت بنجاح فوري
             final_entry_price = current_ask_price
             print(f"✅ [Executor] (SIMULATED) تم التنفيذ! {symbol} بسعر {final_entry_price}")
 
-            # 6. حفظ الصفقة الوهمية في 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,
@@ -595,7 +580,6 @@ class TradeManager:
                 tactical_context=tactical_data, explorer_context=explorer_context
             )
             
-            # 7. مسح قائمة المراقبة بعد فتح الصفقة بنجاح
             print(f"   [Executor] الصفقة {symbol} فُتحت. مسح باقي قائمة المراقبة (Watchlist)...")
             async with self.sentry_lock:
                 self.sentry_watchlist.clear()
@@ -605,14 +589,12 @@ class TradeManager:
             print(f"❌ [Executor] فشل فادح أثناء التنفيذ (SIM) لـ {symbol}: {e}"); 
             traceback.print_exc()
             
-            # (إصلاح V6.0 / V6.1)
-            # إذا فشلت عملية الحفظ في R2 (أو أي خطأ آخر)، أعد العملة إلى قائمة المراقبة
             print(f"   [Sentry] إعادة {symbol} إلى Watchlist بعد فشل التنفيذ الوهمي.")
             async with self.sentry_lock:
                 self.sentry_watchlist[symbol] = {
                     "symbol": symbol, 
                     "strategy_hint": strategy_hint, 
-                    "llm_decision_context": context_for_retry # (استخدام المتغير المحلي)
+                    "llm_decision_context": context_for_retry 
                 }
 
         finally:
@@ -620,7 +602,7 @@ class TradeManager:
                 self.r2_service.release_lock()
 
 
-    async def _save_trade_to_r2(self, **kwargs): # (محدث V6.2)
+    async def _save_trade_to_r2(self, **kwargs):
         """(دالة داخلية - V6.2) تحفظ فقط البيانات الأساسية للصفقة الوهمية."""
         try:
             symbol = kwargs.get('symbol')
@@ -628,7 +610,6 @@ class TradeManager:
             exit_profile = kwargs.get('exit_profile')
             expected_target_time = (datetime.now() + timedelta(minutes=15)).isoformat()
 
-            # (منطق جديد: استخراج قرار LLM فقط وتجاهل بيانات الشموع)
             explorer_context_blob = kwargs.get('explorer_context', {})
             llm_decision_only = explorer_context_blob.get('decision', {})
             
@@ -638,7 +619,7 @@ class TradeManager:
                 "exit_profile": exit_profile,
                 "exit_parameters": kwargs.get('exit_parameters', {}),
                 "tactical_context_at_decision": kwargs.get('tactical_context', {}),
-                "explorer_llm_decision": llm_decision_only # حفظ قرار LLM فقط
+                "explorer_llm_decision": llm_decision_only 
             }
             
             new_trade = {
@@ -679,10 +660,9 @@ class TradeManager:
         except Exception as e: 
             print(f"❌ [R2] فشل حفظ الصفقة لـ {symbol}: {e}"); 
             traceback.print_exc()
-            # (إثارة الخطأ لإعلام الدالة المستدعية بالفشل)
             raise
 
-    async def close_trade(self, trade_to_close, close_price, reason="System Close"): # (لا تغيير هنا)
+    async def close_trade(self, trade_to_close, close_price, reason="System Close"):
         """(لا تغيير جوهري) - لا يزال مسؤولاً عن حساب PnL وتحديث R2 وتشغيل LearningHub"""
         try:
             symbol = trade_to_close.get('symbol'); trade_to_close['status'] = 'CLOSED'
@@ -705,8 +685,6 @@ class TradeManager:
             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)
             
-            # (لا حاجة لإزالة المهمة يدوياً، الحلقة الرئيسية ستفعل ذلك)
-            
             await self.r2_service.save_system_logs_async({
                 "trade_closed": True, "symbol": symbol, "pnl_usd": pnl, "pnl_percent": pnl_percent,
                 "new_capital": new_capital, "strategy": strategy, "reason": reason
@@ -719,7 +697,7 @@ class TradeManager:
             return True
         except Exception as e: print(f"❌ [Executor] فشل فادح أثناء إغلاق الصفقة (الوهمية) {symbol}: {e}"); traceback.print_exc(); raise
 
-    async def immediate_close_trade(self, symbol, close_price, reason="Immediate Close"): # (لا تغيير هنا)
+    async def immediate_close_trade(self, symbol, close_price, reason="Immediate Close"):
         """(معدل) - للإغلاق الفوري بناءً على زناد Sentry"""
         if not self.r2_service.acquire_lock(): print(f"⚠️ [Executor] فشل في الحصول على قفل R2 لـ {symbol} (Immediate Close)"); return False
         try:
@@ -732,7 +710,7 @@ class TradeManager:
         finally:
             if self.r2_service.lock_acquired: self.r2_service.release_lock()
 
-    async def update_trade_strategy(self, trade_to_update, re_analysis_decision): # (لا تغيير هنا)
+    async def update_trade_strategy(self, trade_to_update, re_analysis_decision):
         """(يستدعى من المستكشف) لتحديث الأهداف الاستراتيجية فقط"""
         try:
             symbol = trade_to_update.get('symbol')
@@ -756,7 +734,7 @@ class TradeManager:
             return True
         except Exception as e: print(f"❌ (Explorer) فشل تحديث استراتيجية {symbol}: {e}"); raise
 
-    async def _archive_closed_trade(self, closed_trade): # (لا تغيير هنا)
+    async def _archive_closed_trade(self, closed_trade):
         try:
             key = "closed_trades_history.json"; history = []
             try: response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key); history = json.loads(response['Body'].read())
@@ -766,7 +744,7 @@ class TradeManager:
             self.r2_service.s3_client.put_object(Bucket="trading", Key=key, Body=data_json, ContentType="application/json")
         except Exception as e: print(f"❌ Failed to archive trade: {e}")
 
-    async def _update_trade_summary(self, closed_trade): # (لا تغيير هنا)
+    async def _update_trade_summary(self, closed_trade):
         try:
             key = "trade_summary.json"; summary = {"total_trades": 0, "winning_trades": 0, "losing_trades": 0, "total_profit_usd": 0.0, "total_loss_usd": 0.0, "win_percentage": 0.0, "avg_profit_per_trade": 0.0, "avg_loss_per_trade": 0.0, "largest_win": 0.0, "largest_loss": 0.0, "last_updated": datetime.now().isoformat()}
             try: response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key); summary = json.loads(response['Body'].read())
@@ -782,15 +760,15 @@ class TradeManager:
             self.r2_service.s3_client.put_object(Bucket="trading", Key=key, Body=data_json, ContentType="application/json")
         except Exception as e: print(f"❌ Failed to update trade summary: {e}")
 
-    async def get_open_trades(self): # (لا تغيير هنا)
+    async def get_open_trades(self):
         try: return await self.r2_service.get_open_trades_async()
         except Exception as e: print(f"❌ Failed to get open trades: {e}"); return []
 
-    async def get_trade_by_symbol(self, symbol): # (لا تغيير هنا)
+    async def get_trade_by_symbol(self, symbol):
         try:
             open_trades = await self.get_open_trades()
             return next((t for t in open_trades if t['symbol'] == symbol and t['status'] == 'OPEN'), None)
         except Exception as e: print(f"❌ Failed to get trade by symbol {symbol}: {e}"); return None
 
 
-print(f"✅ Trade Manager loaded - V6.5 (Executor Sanity Check + Strategic Exit) (ccxt.async_support: {CCXT_ASYNC_AVAILABLE})")
+print(f"✅ Trade Manager loaded - V6.6 (Fixed TP Execution Logic) (ccxt.async_support: {CCXT_ASYNC_AVAILABLE})")