Update trade_manager.py

trade_manager.py

@@ -1,40 +1,227 @@
-# trade_manager.py
+# trade_manager.py (محدث بالكامل مع محرك الخروج الديناميكي وإدارة التعارض)
 import asyncio
 import json
 import time
 import traceback
 from datetime import datetime, timedelta
 from helpers import safe_float_conversion, _apply_patience_logic
+# 🔴 جديد: نحتاج إلى pandas لحساب ATR في المراقب
+try:
+    import pandas as pd
+    import pandas_ta as ta
+    PANDAS_TA_AVAILABLE = True
+except ImportError:
+    PANDAS_TA_AVAILABLE = False
+    print("⚠️ pandas_ta not available. ATR Trailing Stop will be disabled.")
+
+
+# 🔴 جديد: محرك الخروج الديناميكي (كلاس داخلي أو مساعد)
+class _DynamicExitEngine:
+    def __init__(self, data_manager):
+        self.data_manager = data_manager
+
+    async def evaluate_exit(self, trade: dict, current_price: float):
+        """
+        يقيّم ما إذا كان يجب إغلاق الصفقة بناءً على ملف الخروج الخاص بها.
+        يرجع: (should_close, close_reason, updated_trade_object)
+        """
+        if not PANDAS_TA_AVAILABLE:
+            # إذا لم تكن المكتبات متاحة، نعود إلى الوقف الثابت البسيط
+            return await self._evaluate_fixed_exit(trade, current_price)
+
+        try:
+            exit_profile = trade.get('decision_data', {}).get('exit_profile', 'FIXED_TARGET')
+            exit_params = trade.get('decision_data', {}).get('exit_parameters', {})
+            
+            # 1. التحقق من الوقف الكارثي (Hard Stop) والهدف النهائي (Take Profit) دائماً
+            hard_stop = trade.get('stop_loss')
+            take_profit = trade.get('take_profit')
+            
+            if hard_stop and current_price <= hard_stop:
+                return True, f"Hard Stop Loss hit: {current_price} <= {hard_stop}", trade
+            if take_profit and current_price >= take_profit:
+                return True, f"Final Take Profit hit: {current_price} >= {take_profit}", trade
+
+            # 2. التحقق من الوقف الديناميكي (المتحرك) إذا كان موجوداً
+            dynamic_stop = trade.get('dynamic_stop_loss')
+            if dynamic_stop and current_price <= dynamic_stop:
+                return True, f"Dynamic Trailing Stop hit: {current_price} <= {dynamic_stop}", trade
+
+            # 3. تنفيذ منطق ملف الخروج
+            if exit_profile == "ATR_TRAILING":
+                return await self._evaluate_atr_trailing(trade, current_price, exit_params)
+            elif exit_profile == "TIME_BASED":
+                return await self._evaluate_time_based(trade, current_price, exit_params)
+            elif exit_profile == "FIXED_TARGET":
+                # تم التعامل معه بالفعل (TP/SL)، لكن يمكن إضافة منطق نقطة التعادل
+                return await self._evaluate_break_even(trade, current_price, exit_params.get("break_even_trigger_percent", 0))
+            elif exit_profile == "SIGNAL_BASED":
+                # (منطق الطوارئ - يمكن توسيعه لاحقاً)
+                # مثال: التحقق من ارتفاع حجم البيع
+                # volume_spike = await self._check_emergency_signals(trade['symbol'])
+                # if volume_spike:
+                #    return True, f"Emergency Signal Stop (Volume Spike)", trade
+                pass
+
+            # إذا لم يتم تشغيل أي شيء، تحقق من نقطة التعادل (إذا لم تكن جزءاً من ATR)
+            if exit_profile != "ATR_TRAILING":
+                return await self._evaluate_break_even(trade, current_price, exit_params.get("break_even_trigger_percent", 0))
+
+            return False, "No exit criteria met", trade
+
+        except Exception as e:
+            print(f"❌ Error in DynamicExitEngine for {trade.get('symbol')}: {e}")
+            traceback.print_exc()
+            # في حالة الخطأ، نعود إلى الوقف الثابت الآمن
+            return await self._evaluate_fixed_exit(trade, current_price)
+
+    async def _evaluate_fixed_exit(self, trade: dict, current_price: float):
+        """الخروج الآمن (الافتراضي): الوقف الثابت والهدف الثابت فقط"""
+        hard_stop = trade.get('stop_loss')
+        take_profit = trade.get('take_profit')
+        
+        if hard_stop and current_price <= hard_stop:
+            return True, f"Hard Stop Loss hit: {current_price} <= {hard_stop}", trade
+        if take_profit and current_price >= take_profit:
+            return True, f"Final Take Profit hit: {current_price} >= {take_profit}", trade
+            
+        # التحقق من الوقف الديناميكي (إذا تم تعيينه مسبقاً)
+        dynamic_stop = trade.get('dynamic_stop_loss')
+        if dynamic_stop and current_price <= dynamic_stop:
+            return True, f"Dynamic Stop hit: {current_price} <= {dynamic_stop}", trade
+            
+        return False, "No exit criteria met", trade
+
+    async def _evaluate_atr_trailing(self, trade: dict, current_price: float, params: dict):
+        """حساب الوقف المتحرك بناءً على ATR"""
+        try:
+            atr_period = params.get("atr_period", 14)
+            atr_multiplier = params.get("atr_multiplier", 2.0)
+            break_even_trigger_percent = params.get("break_even_trigger_percent", 0) # مثال: 1.5%
+
+            # 1. جلب بيانات الشموع لحساب ATR (نستخدم إطار زمني قصير مثل 15m)
+            ohlcv_data = await self._fetch_ohlcv_for_atr(trade['symbol'], '15m', atr_period + 50) # +50 لتهيئة المؤشر
+            if ohlcv_data is None:
+                return False, "ATR data unavailable", trade # لا يمكن الحساب، استمر
+
+            # 2. حساب ATR
+            df = pd.DataFrame(ohlcv_data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+            df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=atr_period)
+            
+            if df['atr'].dropna().empty:
+                return False, "ATR calculation failed", trade
+                
+            current_atr = df['atr'].iloc[-1]
+            if current_atr is None or current_atr == 0:
+                return False, "Invalid ATR value", trade
+
+            # 3. حساب سعر الوقف الجديد بناءً على ATR
+            new_atr_stop = current_price - (current_atr * atr_multiplier)
+            
+            # 4. التحقق من نقطة التعادل (Break Even)
+            current_dynamic_stop = trade.get('dynamic_stop_loss', 0)
+            entry_price = trade.get('entry_price')
+            
+            if break_even_trigger_percent > 0:
+                trigger_price = entry_price * (1 + break_even_trigger_percent / 100)
+                if current_price >= trigger_price:
+                    # إذا وصلنا لهدف نقطة التعادل، الوقف الجديد *على الأقل* سعر الدخول
+                    new_atr_stop = max(new_atr_stop, entry_price)
+
+            # 5. تحديث الوقف الديناميكي
+            # الوقف المتحرك يجب أن يرتفع فقط، لا ينخفض
+            if new_atr_stop > current_dynamic_stop:
+                trade['dynamic_stop_loss'] = new_atr_stop
+                print(f"📈 {trade['symbol']}: ATR Trailing Stop updated to {new_atr_stop:.6f}")
+                # ملاحظة: هذا التحديث محلي للمهمة فقط (لا يحفظ في R2 كل دقيقة)
+            
+            # سيتم التحقق من الوقف المحدث في الدورة التالية (أو في بداية هذه الدالة)
+            return False, "ATR Trailing logic executed", trade
+
+        except Exception as e:
+            print(f"❌ Error in ATR Trailing logic for {trade.get('symbol')}: {e}")
+            return False, "ATR logic failed", trade # فشل آمن، لا تغلق الصفقة
+
+    async def _evaluate_time_based(self, trade: dict, current_price: float, params: dict):
+        """التحقق من الوقف الزمني"""
+        exit_after_minutes = params.get("exit_after_minutes", 0)
+        if exit_after_minutes <= 0:
+            return False, "Time stop not configured", trade
+            
+        entry_time = datetime.fromisoformat(trade.get('entry_timestamp'))
+        elapsed_minutes = (datetime.now() - entry_time).total_seconds() / 60
+        
+        if elapsed_minutes >= exit_after_minutes:
+            return True, f"Time Stop hit: {elapsed_minutes:.1f}m >= {exit_after_minutes}m", trade
+            
+        return False, "Time stop not hit", trade
+
+    async def _evaluate_break_even(self, trade: dict, current_price: float, break_even_trigger_percent: float):
+        """منطق نقطة التعادل (إذا لم يكن جزءاً من ATR)"""
+        if break_even_trigger_percent <= 0:
+            return False, "Break-even not configured", trade
+            
+        entry_price = trade.get('entry_price')
+        current_dynamic_stop = trade.get('dynamic_stop_loss', 0)
+        
+        # إذا كان الوقف الحالي أقل من سعر الدخول
+        if current_dynamic_stop < entry_price:
+            trigger_price = entry_price * (1 + break_even_trigger_percent / 100)
+            if current_price >= trigger_price:
+                trade['dynamic_stop_loss'] = entry_price # ارفع الوقف إلى سعر الدخول
+                print(f"📈 {trade['symbol']}: Break-Even Stop activated at {entry_price:.6f}")
+        
+        return False, "Break-even logic executed", trade
+
+    async def _fetch_ohlcv_for_atr(self, symbol, timeframe, limit):
+        """جلب بيانات الشموع لحساب ATR (دالة مساعدة)"""
+        try:
+            if not self.data_manager or not self.data_manager.exchange:
+                return None
+            # جلب البيان��ت بشكل متزامن (لأننا داخل مهمة asyncio بالفعل)
+            # هذه الدالة (fetch_ohlcv) في ccxt ليست async
+            loop = asyncio.get_event_loop()
+            ohlcv_data = await loop.run_in_executor(
+                None, 
+                lambda: self.data_manager.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
+            )
+            
+            if ohlcv_data and len(ohlcv_data) >= limit:
+                return ohlcv_data
+            else:
+                return None
+        except Exception as e:
+            print(f"⚠️ Failed to fetch OHLCV for ATR ({symbol}): {e}")
+            return None
+
 
 class TradeManager:
-    def __init__(self, r2_service, learning_engine=None, data_manager=None):
+    def __init__(self, r2_service, learning_engine=None, data_manager=None, state_manager=None): # 🔴 جديد
         self.r2_service = r2_service
         self.learning_engine = learning_engine
         self.data_manager = data_manager
+        self.state_manager = state_manager # 🔴 جديد: لإدارة التعارض
         self.monitoring_tasks = {}
         self.is_running = False
         self.monitoring_errors = {}
         self.max_consecutive_errors = 5
+        self.exit_engine = _DynamicExitEngine(self.data_manager) # 🔴 جديد: تهيئة محرك الخروج
 
     async def open_trade(self, symbol, decision, current_price):
         try:
-            # ✅ الإصلاح: التحقق من نوع الصفقة ومنع صفقات SHORT
-            trade_type = decision.get("trade_type", "LONG") # الافتراضي هو LONG
+            trade_type = decision.get("trade_type", "LONG") 
             if trade_type == "SHORT":
                 print(f"⚠️ تم رفض فتح صفقة SHORT لـ {symbol}. النظام مصمم لـ SPOT فقط.")
                 await self.r2_service.save_system_logs_async({
-                    "trade_open_rejected": True,
-                    "reason": "SHORT trade not allowed for SPOT system",
-                    "symbol": symbol,
-                    "llm_decision": decision
+                    "trade_open_rejected": True, "reason": "SHORT trade not allowed", "symbol": symbol
                 })
-                return None # لا تفتح الصفقة
+                return None 
 
             portfolio_state = await self.r2_service.get_portfolio_state_async()
             available_capital = portfolio_state.get("current_capital_usd", 0)
 
             if available_capital < 1:
-                print(f"❌ رأس المال غير كافي لفتح صفقة لـ {symbol}: {available_capital}")
+                print(f"❌ رأس المال غير كافي لـ {symbol}: {available_capital}")
                 return None
 
             expected_target_minutes = decision.get('expected_target_minutes', 15)
@@ -44,6 +231,10 @@ class TradeManager:
             strategy = decision.get('strategy')
             if not strategy or strategy == 'unknown':
                 strategy = 'GENERIC'
+                
+            # 🔴 جديد: جلب ملف الخروج والمعاملات
+            exit_profile = decision.get('exit_profile', 'FIXED_TARGET') # الافتراضي هو الوقف الثابت
+            exit_parameters = decision.get('exit_parameters', {})
 
             trades = await self.r2_service.get_open_trades_async()
             new_trade = {
@@ -51,11 +242,12 @@ class TradeManager:
                 "symbol": symbol,
                 "entry_price": current_price,
                 "entry_timestamp": datetime.now().isoformat(),
-                "decision_data": decision,
+                "decision_data": decision, # 🔴 هذا يحتوي الآن على ملف الخروج
                 "status": "OPEN",
-                "stop_loss": decision.get("stop_loss"),
-                "take_profit": decision.get("take_profit"),
-                "trade_type": "LONG", # ✅ الإصلاح: فرض LONG دائماً لـ SPOT
+                "stop_loss": decision.get("stop_loss"), # الوقف الكارثي
+                "take_profit": decision.get("take_profit"), # الهدف النهائي
+                "dynamic_stop_loss": decision.get("stop_loss"), # 🔴 جديد: يبدأ الوقف المتحرك عند الوقف الكارثي
+                "trade_type": "LONG", 
                 "position_size_usd": available_capital,
                 "expected_target_minutes": expected_target_minutes,
                 "expected_target_time": expected_target_time,
@@ -73,23 +265,17 @@ class TradeManager:
             await self.r2_service.save_portfolio_state_async(portfolio_state)
 
             await self.r2_service.save_system_logs_async({
-                "new_trade_opened": True,
-                "symbol": symbol,
-                "position_size": available_capital,
-                "expected_minutes": expected_target_minutes,
-                "trade_type": "LONG", # تم فرض LONG
-                "strategy": strategy
+                "new_trade_opened": True, "symbol": symbol, "position_size": available_capital,
+                "strategy": strategy, "exit_profile": exit_profile # 🔴 جديد: تسجيل ملف الخروج
             })
 
-            print(f"✅ تم فتح صفقة جديدة (LONG) لـ {symbol} باستراتيجية {strategy}")
+            print(f"✅ تم فتح صفقة جديدة (LONG) لـ {symbol} (استراتيجية: {strategy} | ملف خروج: {exit_profile})")
             return new_trade
 
         except Exception as e:
             print(f"❌ فشل فتح صفقة لـ {symbol}: {e}")
             await self.r2_service.save_system_logs_async({
-                "trade_open_failed": True,
-                "symbol": symbol,
-                "error": str(e)
+                "trade_open_failed": True, "symbol": symbol, "error": str(e)
             })
             raise
 
@@ -103,8 +289,7 @@ class TradeManager:
             
             entry_price = trade_to_close['entry_price']
             position_size = trade_to_close['position_size_usd']
-            # ✅ الإصلاح: بما أن النظام SPOT فقط، نفترض دائماً LONG لحساب PnL
-            trade_type = "LONG" # trade_to_close.get('trade_type', 'LONG')
+            trade_type = "LONG" 
             strategy = trade_to_close.get('strategy', 'unknown')
             
             pnl = 0.0
@@ -112,14 +297,8 @@ class TradeManager:
             
             if entry_price and entry_price > 0 and close_price and close_price > 0:
                 try:
-                    # ✅ الإصلاح: استخدام معادلة LONG فقط
-                    # if trade_type == 'LONG':
                     pnl_percent = ((close_price - entry_price) / entry_price) * 100
                     pnl = position_size * (pnl_percent / 100)
-                    # elif trade_type == 'SHORT': # <-- إزالة هذا القسم
-                    #     pnl_percent = ((entry_price - close_price) / entry_price) * 100
-                    #     pnl = position_size * (pnl_percent / 100)
-                          
                 except (TypeError, ZeroDivisionError) as calc_error:
                     pnl = 0.0
                     pnl_percent = 0.0
@@ -132,7 +311,6 @@ class TradeManager:
 
             portfolio_state = await self.r2_service.get_portfolio_state_async()
             current_capital = portfolio_state.get("current_capital_usd", 0)
-            invested_capital = portfolio_state.get("invested_capital_usd", 0)
             
             new_capital = current_capital + position_size + pnl
             
@@ -151,27 +329,18 @@ 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)
             
-            # إزالة من المهام النشطة
             if symbol in self.monitoring_tasks:
                 del self.monitoring_tasks[symbol]
             if symbol in self.monitoring_errors:
                 del self.monitoring_errors[symbol]
             
             await self.r2_service.save_system_logs_async({
-                "trade_closed": True,
-                "symbol": symbol,
-                "entry_price": entry_price,
-                "close_price": close_price,
-                "pnl_usd": pnl,
-                "pnl_percent": pnl_percent,
-                "new_capital": new_capital,
-                "strategy": strategy,
-                "position_size": position_size,
-                "trade_type": trade_type, # سيظل LONG دائماً
-                "reason": reason
+                "trade_closed": True, "symbol": symbol, "pnl_usd": pnl, "pnl_percent": pnl_percent,
+                "new_capital": new_capital, "strategy": strategy, "trade_type": trade_type, "reason": reason
             })
 
             if self.learning_engine and self.learning_engine.initialized:
+                # 🔴 نمرر الصفقة كاملة (تحتوي على decision_data -> exit_profile)
                 await self.learning_engine.analyze_trade_outcome(trade_to_close, reason)
 
             print(f"✅ تم إغلاق صفقة {symbol} - السبب: {reason} - الربح: {pnl_percent:+.2f}%")
@@ -180,19 +349,26 @@ class TradeManager:
         except Exception as e:
             print(f"❌ فشل إغلاق صفقة {trade_to_close.get('symbol')}: {e}")
             await self.r2_service.save_system_logs_async({
-                "trade_close_failed": True,
-                "symbol": trade_to_close.get('symbol'),
-                "error": str(e)
+                "trade_close_failed": True, "symbol": trade_to_close.get('symbol'), "error": str(e)
             })
             raise
 
     async def update_trade(self, trade_to_update, re_analysis_decision):
         try:
             symbol = trade_to_update.get('symbol')
-            if re_analysis_decision.get('new_stop_loss'):
+            
+            # 🔴 جديد: تحديث ملف الخروج والمعاملات
+            if re_analysis_decision.get('action') == "UPDATE_TRADE":
                 trade_to_update['stop_loss'] = re_analysis_decision['new_stop_loss']
-            if re_analysis_decision.get('new_take_profit'):
                 trade_to_update['take_profit'] = re_analysis_decision['new_take_profit']
+                
+                # تحديث الوقف المتحرك ليبدأ من الوقف الجديد
+                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"   🔄 {symbol}: تم تحديث ملف الخروج إلى {re_analysis_decision['new_exit_profile']}")
             
             new_expected_minutes = re_analysis_decision.get('new_expected_minutes')
             if new_expected_minutes:
@@ -205,9 +381,9 @@ class TradeManager:
                 original_strategy = re_analysis_decision.get('strategy', 'GENERIC')
             
             trade_to_update['strategy'] = original_strategy
-            trade_to_update['decision_data'] = re_analysis_decision
+            trade_to_update['decision_data']['reasoning'] = re_analysis_decision.get('reasoning') # تحديث سبب القرار
             trade_to_update['is_monitored'] = True
-            trade_to_update['trade_type'] = "LONG" # ✅ الإصلاح: التأكد من بقائها LONG
+            trade_to_update['trade_type'] = "LONG" 
 
             open_trades = await self.r2_service.get_open_trades_async()
             for i, trade in enumerate(open_trades):
@@ -218,11 +394,9 @@ class TradeManager:
             await self.r2_service.save_open_trades_async(open_trades)
 
             await self.r2_service.save_system_logs_async({
-                "trade_updated": True,
-                "symbol": symbol,
-                "new_expected_minutes": new_expected_minutes,
-                "action": "UPDATE_TRADE",
-                "strategy": original_strategy
+                "trade_updated": True, "symbol": symbol, "action": "UPDATE_TRADE",
+                "strategy": original_strategy,
+                "new_exit_profile": re_analysis_decision.get('new_exit_profile', 'N/A')
             })
 
             print(f"✅ تم تحديث صفقة {symbol}")
@@ -256,7 +430,7 @@ class TradeManager:
 
     async def start_trade_monitoring(self):
         self.is_running = True
-        print("🔍 بدء مراقبة الصفقات...")
+        print(f"🔍 بدء مراقبة الصفقات (Dynamic Exit Engine) (Pandas: {PANDAS_TA_AVAILABLE})...")
         
         while self.is_running:
             try:
@@ -266,23 +440,20 @@ class TradeManager:
                 for trade in open_trades:
                     symbol = trade['symbol']
                     
-                    # تخطي الصفقات التي تجاوزت حد الأخطاء
                     if self.monitoring_errors.get(symbol, 0) >= self.max_consecutive_errors:
                         if symbol in self.monitoring_tasks:
                             del self.monitoring_tasks[symbol]
                         continue
                     
-                    # بدء المراقبة إذا لم تكن نشطة
                     if symbol not in self.monitoring_tasks:
                         task = asyncio.create_task(self._monitor_single_trade(trade))
                         self.monitoring_tasks[symbol] = {
                             'task': task,
                             'start_time': current_time,
-                            'trade': trade
+                            'trade_object': trade # 🔴 حفظ نسخة محلية من الصفقة
                         }
                         trade['monitoring_started'] = True
                 
-                # تنظيف المهام المنتهية
                 current_symbols = {trade['symbol'] for trade in open_trades}
                 for symbol in list(self.monitoring_tasks.keys()):
                     if symbol not in current_symbols:
@@ -293,31 +464,40 @@ class TradeManager:
                         if symbol in self.monitoring_errors:
                             del self.monitoring_errors[symbol]
                 
-                await asyncio.sleep(10)
+                await asyncio.sleep(10) # الفحص الرئيسي كل 10 ثوانٍ
                 
             except Exception as error:
                 print(f"❌ خطأ في مراقبة الصفقات: {error}")
                 await asyncio.sleep(30)
 
-    async def _monitor_single_trade(self, trade):
-        symbol = trade['symbol']
-        max_monitoring_time = 3600  # أقصى وقت مراقبة: ساعة واحدة
+    async def _monitor_single_trade(self, trade_object):
+        """
+        🔴 (أعيدت كتابته بالكامل)
+        المراقب التكتيكي (1 دقيقة) الذي ينفذ ملف الخروج الديناميكي.
+        """
+        symbol = trade_object['symbol']
+        # 🔴 نستخدم النسخة المحلية من الصفقة لتتبع الوقف المتحرك
+        local_trade = trade_object.copy() 
         
-        print(f"🔍 بدء مراقبة الصفقة: {symbol}")
+        print(f"🔍 بدء مراقبة الصفقة (تكتيكي): {symbol} (ملف: {local_trade.get('decision_data', {}).get('exit_profile', 'N/A')})")
         
         while (symbol in self.monitoring_tasks and 
                self.is_running and 
                self.monitoring_errors.get(symbol, 0) < self.max_consecutive_errors):
             
             try:
-                start_time = time.time()
-                
+                # 🔴 1. التحقق من قفل التحليل الاستراتيجي (منع التعارض)
+                if self.state_manager and self.state_manager.trade_analysis_lock.locked():
+                    print(f"⏸️ [Monitor] إيقاف مؤقت لـ {symbol} (التحليل الاستراتيجي يعمل...)")
+                    await asyncio.sleep(10) # انتظار انتهاء التحليل
+                    continue # تخطي هذه الدورة
+                    
                 if not self.data_manager:
                     print(f"⚠️ DataManager غير متوفر لـ {symbol}")
                     await asyncio.sleep(15)
                     continue
                     
-                # الحصول على السعر الحالي مع مهلة زمنية
+                # 🔴 2. جلب السعر الحالي
                 try:
                     current_price = await asyncio.wait_for(
                         self.data_manager.get_latest_price_async(symbol), 
@@ -335,39 +515,27 @@ class TradeManager:
                     await asyncio.sleep(15)
                     continue
                     
-                entry_price = trade['entry_price']
-                stop_loss = trade.get('stop_loss')
-                take_profit = trade.get('take_profit')
-                # ✅ الإصلاح: نفترض LONG دائماً عند التحقق من الإغلاق لـ SPOT
-                trade_type = "LONG"
-                should_close, close_reason = False, ""
-                
-                # التحقق من شروط الإغلاق (مع افتراض LONG)
-                if stop_loss and current_price <= stop_loss:
-                    should_close, close_reason = True, f"وصول وقف الخسارة (LONG): {current_price} <= {stop_loss}"
-                elif take_profit and current_price >= take_profit:
-                    should_close, close_reason = True, f"وصول جني الأرباح (LONG): {current_price} >= {take_profit}"
+                # 🔴 3. تنفيذ محرك الخروج الديناميكي
+                # نمرر النسخة المحلية من الصفقة (local_trade)
+                should_close, close_reason, updated_local_trade = await self.exit_engine.evaluate_exit(
+                    local_trade, 
+                    current_price
+                )
                 
-                # تحديث وقف الخسارة الديناميكي (Trailing Stop Loss) لصفقات LONG
-                if not should_close and current_price > entry_price:
-                    # مثال بسيط: تحديد وقف خسارة عند 2% تحت السعر الحالي إذا كان أعلى من وقف الخسارة الأصلي
-                    potential_new_stop = current_price * 0.98
-                    current_stop_loss = trade.get('stop_loss', 0) or 0 # التعامل مع None
-                    if potential_new_stop > current_stop_loss:
-                        trade['stop_loss'] = potential_new_stop
-                        print(f"📈 {symbol}: تم تحديث وقف الخسارة الديناميكي إلى {potential_new_stop:.6f}")
-                        # ملاحظة: هذا التحديث محلي للمهمة، قد تحتاج لحفظه في R2 إذا أردت استمراره
+                # تحديث النسخة المحلية (تحتوي على dynamic_stop_loss المحدث)
+                local_trade = updated_local_trade
                 
-                # إغلاق الصفقة إذا لزم الأمر
+                # 🔴 4. اتخاذ قرار الإغلاق
                 if should_close:
-                    if self.r2_service.acquire_lock():
+                    print(f"🛑 [Monitor] قرار إغلاق لـ {symbol}: {close_reason}")
+                    if self.r2_service.acquire_lock(): # محاولة قفل R2 للإغلاق
                         try:
-                            # قبل الإغلاق، تأكد من جلب أحدث نسخة من الصفقة من R2
+                            # قبل الإغلاق، تأكد من جلب أحدث نسخة من R2
                             latest_trade_data = await self.r2_service.get_trade_by_symbol_async(symbol)
                             if latest_trade_data and latest_trade_data['status'] == 'OPEN':
-                                await self.immediate_close_trade(symbol, current_price, close_reason)
+                                await self.immediate_close_trade(symbol, current_price, f"Tactical Monitor: {close_reason}")
                             else:
-                                print(f"⚠️ الصفقة {symbol} لم تعد مفتوحة أو غير موجودة، تم إلغاء الإغلاق.")
+                                print(f"⚠️ الصفقة {symbol} لم تعد مفتوحة، تم إلغاء الإغلاق التكتيكي.")
                         except Exception as close_error:
                             print(f"❌ فشل الإغلاق التلقائي لـ {symbol}: {close_error}")
                         finally:
@@ -375,42 +543,28 @@ class TradeManager:
                     
                     break # الخروج من حلقة المراقبة بعد محاولة الإغلاق
                 
-                # إعادة تعيين عداد الأخطاء عند النجاح
+                # 🔴 5. إعادة تعيين عداد الأخطاء والانتظار
                 if symbol in self.monitoring_errors:
                     self.monitoring_errors[symbol] = 0
                     
-                # التحقق من وقت المراقبة الطويل
-                monitoring_duration = time.time() - self.monitoring_tasks[symbol]['start_time'] # استخدام وقت البدء الأصلي
-                if monitoring_duration > max_monitoring_time:
-                    print(f"🕒 انتهى وقت مراقبة الصفقة {symbol} ({monitoring_duration:.0f}s > {max_monitoring_time}s)")
-                    # يمكنك إضافة منطق هنا لإغلاق الصفقة إذا طالت مدتها، أو تركها لإعادة التحليل
-                    break
-                    
-                await asyncio.sleep(15) # انتظار 15 ثانية بين كل فحص
+                # انتظار 60 ثانية (دورة المراقب التكتيكي)
+                await asyncio.sleep(60) 
                 
             except Exception as error:
                 error_count = self._increment_monitoring_error(symbol)
                 print(f"❌ خطأ في مراقبة {symbol} (الخطأ #{error_count}): {error}")
+                traceback.print_exc()
                 
                 if error_count >= self.max_consecutive_errors:
                     print(f"🚨 إيقاف مراقبة {symbol} بسبب الأخطاء المتتالية")
                     await self.r2_service.save_system_logs_async({
-                        "monitoring_stopped": True,
-                        "symbol": symbol,
-                        "error_count": error_count,
-                        "error": str(error)
+                        "monitoring_stopped": True, "symbol": symbol, "error_count": error_count, "error": str(error)
                     })
-                    # اختياري: محاولة إغلاق الصفقة كإجراء أخير
-                    # current_price_fallback = await self.data_manager.get_latest_price_async(symbol)
-                    # if current_price_fallback and self.r2_service.acquire_lock():
-                    #    try: await self.immediate_close_trade(symbol, current_price_fallback, "Forced close due to monitoring errors")
-                    #    finally: self.r2_service.release_lock()
                     break # الخروج من الحلقة بسبب الأخطاء
                     
                 await asyncio.sleep(30) # انتظار أطول بعد الخطأ
 
-        print(f"🛑 توقيف مراقبة الصفقة: {symbol}")
-        # التأكد من إزالة المهمة عند الخروج من الحلقة
+        print(f"🛑 توقيف مراقبة الصفقة (تكتيكي): {symbol}")
         if symbol in self.monitoring_tasks:
             del self.monitoring_tasks[symbol]
         if symbol in self.monitoring_errors:
@@ -446,7 +600,6 @@ class TradeManager:
             
             history.append(closed_trade)
             
-            # حفظ آخر 1000 صفقة فقط
             if len(history) > 1000:
                 history = history[-1000:]
             
@@ -528,4 +681,6 @@ class TradeManager:
             'active_tasks': len(self.monitoring_tasks),
             'monitoring_errors': dict(self.monitoring_errors),
             'max_consecutive_errors': self.max_consecutive_errors
-        }
+        }
+
+print(f"✅ Trade Manager loaded - V2 (Dynamic Exit Engine & Lock-Aware Monitor / Pandas: {PANDAS_TA_AVAILABLE})")