Update trade_manager.py

trade_manager.py

@@ -1,6 +1,6 @@
-# trade_manager.py (V22.5 - GEM-Architect: Real-Time Hard Limits Fix)
+# trade_manager.py (V23.0 - GEM-Architect: Processor Integration)
+
 import asyncio
-import json
 import uuid
 import time
 import traceback
@@ -8,70 +8,56 @@ from datetime import datetime
 from typing import List, Dict, Any
 
 class TradeManager:
-    def __init__(self, r2_service, data_manager, titan_engine, pattern_engine, guard_engine=None, sniper_engine=None, deep_steward=None): 
+    def __init__(self, r2_service, data_manager, processor): 
+        """
+        مدير الصفقات: يعتمد كلياً على 'processor' في القرارات الذكية.
+        """
         self.r2 = r2_service
         self.data_manager = data_manager
-        self.titan = titan_engine
-        self.pattern_engine = pattern_engine
-        
-        # ⚠️ GuardEngine (Old V1) - معطل تماماً
-        self.guard = guard_engine 
-        
-        self.sniper = sniper_engine 
         
-        # [ 🧠 ] Hybrid Deep Steward (V2 Radar + V3 Sniper)
-        self.deep_steward = deep_steward
+        # 🧠 The Central Brain
+        self.processor = processor 
         
         self.open_positions = {}
         self.watchlist = {}
         self.sentry_tasks = {}
         self.running = True
         
-        # [ 🧠 IQ Stats ] مخزن الإحصائيات
+        # [ 🧠 IQ Stats ]
         self.ai_stats = {
             "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
             "v2":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
             "v3":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0}
         }
         
-        self.ds_stats = self.ai_stats["hybrid"]
-        
         self.execution_lock = asyncio.Lock()
         
-        print(f"🛡️ [TradeManager V22.5] Initialized. Real-Time Hard Limits Enabled.")
+        print(f"🛡️ [TradeManager V23] Initialized with Central Processor.")
 
     async def initialize_sentry_exchanges(self):
-        print("🛡️ [TradeManager] Initializing and syncing state with R2...")
+        print("🛡️ [TradeManager] Syncing state with R2...")
         await self.sync_internal_state_with_r2()
 
     async def sync_internal_state_with_r2(self):
         try:
             open_trades_list = await self.r2.get_open_trades_async()
             self.open_positions = {trade['symbol']: trade for trade in open_trades_list}
-            print(f"   -> [Sync] تم استعادة {len(self.open_positions)} صفقة مفتوحة من R2.")
+            print(f"   -> [Sync] Recovered {len(self.open_positions)} active trades.")
         except Exception as e:
-            print(f"❌ [TradeManager] فشل فادح في مزامنة R2 (get_open_trades_async): {e}")
+            print(f"❌ [TradeManager] R2 Sync Failed: {e}")
             self.open_positions = {} 
 
     # ==============================================================================
-    # 🎯 دوال الفرز والتنفيذ (L4 Sniper Logic)
+    # 🎯 L4 Sniper Logic (Via Processor)
     # ==============================================================================
     async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
         if len(self.open_positions) > 0:
-             print(f"⛔ [TradeManager] تم إلغاء الفرز. توجد صفقة مفتوحة بالفعل.")
+             print(f"⛔ [TradeManager] Scan aborted. Max positions reached.")
              return
 
-        if self.sniper and not self.sniper.initialized:
-            try:
-                print("   -> [Lazy Load] 🎯 تهيئة SniperEngine V3 (Batch Select) عند الطلب...")
-                await self.sniper.initialize()
-            except Exception as e:
-                print(f"❌ [Lazy Load] فشل فادح في تهيئة SniperEngine: {e}")
-                self.sniper = None
-        
-        if not self.sniper or not self.sniper.initialized:
-            print("⚠️ [TradeManager] SniperEngine V3 غير جاهز للفرز. تم الإلغاء.")
-            return
+        # نطلب من المعالج التأكد من أن القناص جاهز
+        if not self.processor.initialized:
+            await self.processor.initialize()
 
         sniper_candidates = []
         
@@ -79,93 +65,61 @@ class TradeManager:
             symbol = signal['symbol']
             
             if symbol in self.open_positions or symbol in self.watchlist:
-                print(f"   -> [L4 Skip] {symbol} موجودة مسبقاً في الصفقات أو المراقبة.")
                 continue
 
-            print(f"   -> [L4 Check] {symbol} التحقق من L4 (Sniper)...")
+            # جلب البيانات
             ohlcv_1m = await self.data_manager.get_latest_ohlcv(symbol, '1m', 600)
             
-            if not ohlcv_1m or len(ohlcv_1m) < self.sniper.LOOKBACK_WINDOW:
-                print(f"   -> [L4 Skip] {symbol} بيانات 1m غير كافية للقناص ({len(ohlcv_1m)} < {self.sniper.LOOKBACK_WINDOW}).")
-                continue
-
-            sniper_result = await self.sniper.check_entry_signal_async(ohlcv_1m)
+            # استشارة القناص عبر المعالج
+            sniper_result = await self.processor.check_sniper_entry(ohlcv_1m)
             
             if sniper_result['signal'] == 'BUY':
                 confidence = sniper_result['confidence_prob']
-                threshold = sniper_result.get('threshold', self.sniper.threshold)
-                print(f"   -> [L4 PASS] {symbol} (Conf: {confidence:.2f} >= {threshold:.2f}). أضيف للفرز النهائي.")
+                threshold = sniper_result.get('threshold', 0.60)
+                print(f"   -> [L4 PASS] {symbol} (Conf: {confidence:.2f}). Added to batch.")
                 
                 signal['l2_sniper_result'] = sniper_result
                 signal['sniper_confidence'] = confidence
                 sniper_candidates.append(signal)
             else:
-                confidence = sniper_result.get('confidence_prob', 0.0)
-                threshold = sniper_result.get('threshold', self.sniper.threshold)
-                print(f"   -> [L4 REJECT] {symbol} (Conf: {confidence:.2f} < {threshold:.2f}).")
+                print(f"   -> [L4 REJECT] {symbol} (Conf: {sniper_result.get('confidence_prob',0):.2f})")
 
         if not sniper_candidates:
-            print("   -> [L4 Result] القناص رفض جميع الإشارات المعتمدة من العقل. لا يوجد تنفيذ.")
+            print("   -> [L4 Result] No candidates passed the Sniper check.")
             return
 
+        # ترتيب النتائج
         sniper_candidates.sort(key=lambda x: (x['sniper_confidence'], x['final_total_score']), reverse=True)
-        
         best_signal = sniper_candidates[0]
         
-        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} (Sniper: {best_signal['sniper_confidence']:.2f}, L2: {best_signal['final_total_score']:.2f})")
+        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} (Sniper: {best_signal['sniper_confidence']:.2f})")
         
-        if len(sniper_candidates) > 1:
-            for i, loser in enumerate(sniper_candidates[1:]):
-                print(f"       -> (خسرت أمامها: {i+2}. {loser['symbol']} (Sniper: {loser['sniper_confidence']:.2f}, L2: {loser['final_total_score']:.2f}))")
-
+        # التنفيذ
         async with self.execution_lock:
-            if len(self.open_positions) > 0:
-                print(f"⛔ [TradeManager] تم إلغاء التنفيذ في اللحظة الأخيرة. توجد صفقة مفتوحة.")
-                return
-
-            if best_signal['symbol'] in self.open_positions:
-                print(f"   -> [L4 EXEC SKIP] {best_signal['symbol']} تم فتحها بواسطة عملية أخرى للتو.")
-                return
-            
-            await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
+            if len(self.open_positions) == 0 and best_signal['symbol'] not in self.open_positions:
+                await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🎯 تنفيذ الدخول (Entry Execution)
+    # 🎯 Entry Execution
     # ==============================================================================
     async def _execute_entry_from_signal(self, symbol, signal_data):
         try:
-            if len(self.open_positions) > 0:
-                print(f"⛔ [Entry BLOCKED] لا يمكن فتح {symbol}، توجد صفقة مفتوحة بالفعل.")
-                return
-
             trade_id = str(uuid.uuid4())
             current_price = float(signal_data.get('current_price', 0.0))
-            
             if current_price <= 0.0:
                  current_price = await self.data_manager.get_latest_price_async(symbol)
-                 if current_price <= 0.0:
-                    print(f"⚠️ [Entry ERROR] {symbol} السعر 0، لا يمكن التنفيذ.")
-                    return
 
             l2_result = signal_data.get('l2_sniper_result', {})
-            l2_confidence = l2_result.get('confidence_prob', 0.0)
-            l2_threshold = l2_result.get('threshold', 0.0)
-
-            tp_price = signal_data.get('tp_price')
-            sl_price = signal_data.get('sl_price')
+            
+            # الأهداف (من Oracle أو حساب تلقائي)
+            tp_price = float(signal_data.get('tp_price') or 0.0)
+            sl_price = float(signal_data.get('sl_price') or 0.0)
 
-            if not tp_price or not sl_price:
-                print(f"   -> [Entry Info] {symbol} لم يوفر العقل أهدافاً، جاري الحساب الوهمي.")
+            if tp_price <= 0 or sl_price <= 0:
+                # Fallback simple calculation
                 atr_mock = current_price * 0.02 
                 tp_price = current_price + (atr_mock * 2.0)
                 sl_price = current_price - (atr_mock * 1.0)
-            
-            tp_price = float(tp_price)
-            sl_price = float(sl_price)
-
-            if tp_price <= current_price or sl_price >= current_price:
-                 print(f"⚠️ [Entry ERROR] {symbol} أهداف TP/SL غير صالحة. إلغاء.")
-                 return
 
             new_trade = {
                 'id': trade_id,
@@ -178,100 +132,41 @@ class TradeManager:
                 'last_update': datetime.now().isoformat(),
                 
                 'l1_score': float(signal_data.get('final_total_score', 0.0)), 
-                'l1_components': signal_data.get('components', {}),
-                'l2_sniper_confidence': float(l2_confidence),
-                'l2_sniper_threshold': float(l2_threshold),
-                'l3_oracle_tp': float(signal_data.get('tp_price', 0.0) or 0.0),
-                'l3_oracle_sl': float(signal_data.get('sl_price', 0.0) or 0.0),
+                'l2_sniper_confidence': float(l2_result.get('confidence_prob', 0.0)),
+                'l3_oracle_tp': tp_price,
+                'l3_oracle_sl': sl_price,
             }
             
             self.open_positions[symbol] = new_trade
+            if self.watchlist: self.watchlist.clear()
             
-            if self.watchlist:
-                print(f"   -> [Watchlist] مسح {len(self.watchlist)} عنصر من قائمة المراقبة.")
-                self.watchlist.clear()
-            
-            # ============================================================
-            # 🕒 تسجيل وقت أول صفقة
-            # ============================================================
+            # حفظ في R2
             portfolio = await self.r2.get_portfolio_state_async()
             if portfolio.get('first_trade_timestamp') is None:
                 portfolio['first_trade_timestamp'] = new_trade['entry_time']
                 await self.r2.save_portfolio_state_async(portfolio)
-
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             
-            if symbol in self.sentry_tasks:
-                self.sentry_tasks[symbol].cancel()
-            
+            # تفعيل الحارس
+            if symbol in self.sentry_tasks: self.sentry_tasks[symbol].cancel()
             self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
             
-            print(f"✅ [ENTRY EXECUTED] {symbol} | Price: {current_price:.8f} | TP: {tp_price:.8f} | SL: {sl_price:.8f}")
+            print(f"✅ [ENTRY] {symbol} @ {current_price} | TP: {tp_price} | SL: {sl_price}")
 
         except Exception as e:
-            print(f"❌ [TradeManager] فشل فادح أثناء تنفيذ الدخول لـ {symbol}: {e}")
+            print(f"❌ [Entry Error] {symbol}: {e}")
             traceback.print_exc()
 
     # ==============================================================================
-    # 👁️ Watchlist Functions
-    # ==============================================================================
-    async def _add_to_watchlist(self, symbol, signal_data):
-        if symbol not in self.open_positions and symbol not in self.watchlist:
-            if self.open_positions:
-                print(f"👀 [Watchlist] {symbol} تم تجاهله (توجد صفقة أخرى مفتوحة).")
-                return
-                
-            self.watchlist[symbol] = signal_data
-            print(f"👀 [Watchlist] {symbol} تمت إضافته للمراقبة (L1 Score: {signal_data['enhanced_final_score']:.2f})")
-
-    async def _find_signal_in_watchlist(self):
-        if not self.watchlist:
-            return
-            
-        if self.open_positions:
-            print("   -> [Watchlist] تم تخطي البحث (توجد صفقة مفتوحة). مسح المراقب...")
-            self.watchlist.clear()
-            return
-            
-        if self.sniper and not self.sniper.initialized:
-            try:
-                print("   -> [Lazy Load] 🎯 تهيئة SniperEngine V3 (Watchlist) عند الطلب...")
-                await self.sniper.initialize()
-            except Exception as e:
-                print(f"❌ [Lazy Load] فشل فادح في تهيئة SniperEngine (Watchlist): {e}")
-                self.sniper = None
-        
-        if not self.sniper or not self.sniper.initialized:
-            return 
-
-        watchlist_symbols = list(self.watchlist.keys())
-        if not watchlist_symbols:
-            return
-
-        print(f"   -> [Watchlist] فحص {len(watchlist_symbols)} عملة في قائمة المراقبة لـ L4...")
-        
-        signals_from_watchlist = []
-        for symbol in watchlist_symbols:
-            signal_data = self.watchlist.get(symbol)
-            if not signal_data: continue
-            signals_from_watchlist.append(signal_data)
-        
-        if signals_from_watchlist:
-            await self.select_and_execute_best_signal(signals_from_watchlist)
-
-    # ==============================================================================
-    # 🛡️ دوال حا��س الخروج (Hybrid Sentry) - [CRITICAL FIX: Real-Time Checks]
+    # 🛡️ Hybrid Sentry (Via Processor)
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry Activated] بدء الحراسة لـ {symbol} (وضع الاستجابة الفورية).")
-        
+        print(f"🛡️ [Sentry] Guarding {symbol}...")
         last_ai_check_time = 0
         
         while self.running and symbol in self.open_positions:
             try:
-                # ⚡ [FAST LANE] المسار السريع: فحص الحدود الصارمة كل 2 ثانية
-                # هذا يضمن عدم تفويت الهدف إذا تحرك السعر بسرعة
-                await asyncio.sleep(2) 
+                await asyncio.sleep(2) # Fast tick
                 
                 trade = self.open_positions.get(symbol)
                 if not trade: break 
@@ -279,61 +174,48 @@ class TradeManager:
                 current_price = await self.data_manager.get_latest_price_async(symbol)
                 if current_price == 0.0: continue 
 
-                # 1. فحص الحدود الصارمة (Hard Limits) - أولوية قصوى
+                # 1. Hard Limits
                 if current_price >= trade['tp_price']:
-                    print(f"✅ [Sentry FAST] {symbol} (Target Hit) at {current_price:.8f}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
                     break 
-
                 if current_price <= trade['sl_price']:
-                    print(f"🛑 [Sentry FAST] {symbol} (Stop Loss Hit) at {current_price:.8f}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
                     break 
 
-                # 🐌 [SLOW LANE] المسار البطيء: فحص الذكاء الاصطناعي كل 60 ثانية
+                # 2. AI Check (Processor Consultation) every 60s
                 if time.time() - last_ai_check_time > 60:
-                    if self.deep_steward and self.deep_steward.initialized:
-                        # جلب البيانات اللازمة (تم تثبيت الحد على 300)
-                        task1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
-                        task5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
-                        task15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
+                    t1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
+                    t5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
+                    t15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
+                    
+                    d1, d5, d15 = await asyncio.gather(t1, t5, t15)
+                    
+                    if d1 and d5 and d15 and len(d1) >= 200:
+                        # ⚡ استشارة المعالج هنا ⚡
+                        decision = self.processor.consult_guardian(d1, d5, d15, trade['entry_price'])
                         
-                        d1, d5, d15 = await asyncio.gather(task1, task5, task15)
+                        action = decision.get('action', 'HOLD')
+                        scores = decision.get('scores', {})
                         
-                        if d1 and d5 and d15 and len(d1) >= 200:
-                            decision = self.deep_steward.analyze_position(d1, d5, d15, trade['entry_price'])
-                            action = decision.get('action', 'HOLD')
-                            scores = decision.get('scores', {}) 
-                            
-                            if action == 'EXIT_HARD':
-                                print(f"🤖 [Hybrid Guardian] 🚨 خروج طارئ! {decision['reason']}")
-                                async with self.execution_lock:
-                                    await self._execute_exit(symbol, current_price, "AI_HARD_EXIT", ai_scores=scores)
-                                break
-                            
-                            elif action == 'EXIT_SOFT':
-                                print(f"🤖 [Hybrid Guardian] ⚠️ تحذير خروج! {decision['reason']}")
-                                async with self.execution_lock:
-                                    await self._execute_exit(symbol, current_price, "AI_SOFT_EXIT", ai_scores=scores)
-                                break
-                        else:
-                            # لو البيانات ناقصة، ننتظر الدورة القادمة
-                            pass
+                        if action in ['EXIT_HARD', 'EXIT_SOFT']:
+                            print(f"🤖 [Guardian] {action}: {decision.get('reason')}")
+                            async with self.execution_lock:
+                                await self._execute_exit(symbol, current_price, f"AI_{action}", ai_scores=scores)
+                            break
                             
                     last_ai_check_time = time.time()
                     self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
             
             except asyncio.CancelledError:
-                print(f"🛡️ [Sentry STOP] تم إيقاف الحارس لـ {symbol}.")
                 break
             except Exception as e:
-                print(f"❌ [Sentry ERROR] فشل مؤقت لـ {symbol}: {e}")
-                await asyncio.sleep(5) # انتظار قصير عند الخطأ
+                print(f"❌ [Sentry Error] {symbol}: {e}")
+                await asyncio.sleep(5)
 
     # ==============================================================================
-    # 👻 المراقب الشبحي (Ghost Monitor)
+    # 👻 Ghost Monitor & Stats
     # ==============================================================================
     def _launch_post_exit_analysis(self, symbol, exit_price, exit_time, position_size_usd, ai_scores=None):
         asyncio.create_task(self._analyze_after_exit_task(symbol, exit_price, exit_time, position_size_usd, ai_scores))
@@ -348,146 +230,87 @@ class TradeManager:
             self.ai_stats[key]["missed"] += abs(usd_impact)
 
     async def _analyze_after_exit_task(self, symbol, exit_price, exit_time, position_size_usd, ai_scores):
-        await asyncio.sleep(900) 
-        
+        await asyncio.sleep(900) # 15 min wait
         try:
-            current_price = await self.data_manager.get_latest_price_async(symbol)
-            if current_price == 0: return
+            curr = await self.data_manager.get_latest_price_async(symbol)
+            if curr == 0: return
 
-            change_pct = (current_price - exit_price) / exit_price
+            change_pct = (curr - exit_price) / exit_price
             usd_impact = change_pct * position_size_usd
             is_good_exit = change_pct < 0 
             
-            # 1. تحديث الهجين
             self._update_specific_stat("hybrid", is_good_exit, usd_impact)
             
-            # 2. تحديث المكونات
             if ai_scores:
-                v2_score = ai_scores.get('v2', 0.0)
-                v3_score = ai_scores.get('v3', 0.0)
-                
-                if v2_score >= 0.60: # V2 ساهم
-                    self._update_specific_stat("v2", is_good_exit, usd_impact)
-                
-                if v3_score >= 0.75: # V3 ساهم
-                    self._update_specific_stat("v3", is_good_exit, usd_impact)
-
-            audit_record = {
-                "symbol": symbol,
-                "exit_time": exit_time,
-                "exit_price": exit_price,
-                "price_15m_later": current_price, 
-                "change_15m_pct": change_pct * 100, 
-                "usd_impact": usd_impact,
-                "verdict": "SUCCESS (Saved Loss)" if is_good_exit else "MISS (Lost Profit)",
-                "ai_scores": ai_scores if ai_scores else {},
-                "timestamp": datetime.now().isoformat()
+                if ai_scores.get('v2', 0) >= 0.60: self._update_specific_stat("v2", is_good_exit, usd_impact)
+                if ai_scores.get('v3', 0) >= 0.75: self._update_specific_stat("v3", is_good_exit, usd_impact)
+
+            record = {
+                "symbol": symbol, "exit_price": exit_price, "price_15m": curr,
+                "usd_impact": usd_impact, "verdict": "SUCCESS" if is_good_exit else "MISS"
             }
-            
-            await self.r2.append_deep_steward_audit(audit_record)
-            print(f"👻 [Ghost Monitor] {symbol}: {audit_record['verdict']} | Impact: ${usd_impact:.2f}")
+            await self.r2.append_deep_steward_audit(record)
 
         except Exception as e:
-            print(f"⚠️ [Ghost Error] {symbol}: {e}")
+            print(f"⚠️ [Ghost Error] {e}")
 
     # ==============================================================================
-    # 🔴 دالة الخروج المحاسبية (Accounting Exit Logic)
+    # 🔴 Exit & Force Exit
     # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
-        if symbol not in self.open_positions:
-            print(f"⚠️ [Exit ERROR] {symbol} غير موجودة في الصفقات المفتوحة.")
-            return
+        if symbol not in self.open_positions: return
 
         try:
             trade = self.open_positions.pop(symbol) 
-            entry_price = float(trade['entry_price'])
-            exit_price = float(price)
-            
-            raw_profit_pct = (exit_price - entry_price) / entry_price
-            profit_pct_display = raw_profit_pct * 100
+            entry = float(trade['entry_price'])
+            exit_p = float(price)
+            profit_pct = ((exit_p - entry) / entry)
             
-            trade['status'] = 'CLOSED'
-            trade['exit_price'] = exit_price
-            trade['exit_time'] = datetime.now().isoformat()
-            trade['exit_reason'] = reason
-            trade['profit_pct'] = profit_pct_display
+            trade.update({'status': 'CLOSED', 'exit_price': exit_p, 'exit_reason': reason, 'profit_pct': profit_pct*100})
 
             portfolio = await self.r2.get_portfolio_state_async()
-            current_capital = float(portfolio.get('current_capital_usd', 100.0))
+            curr_cap = float(portfolio.get('current_capital_usd', 100.0))
+            pnl_usd = curr_cap * profit_pct
+            new_cap = curr_cap + pnl_usd
             
-            pnl_usd = current_capital * raw_profit_pct
-            new_capital = current_capital + pnl_usd
-            
-            portfolio['current_capital_usd'] = new_capital
+            portfolio['current_capital_usd'] = new_cap
             portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
-            
             if pnl_usd >= 0:
                 portfolio['winning_trades'] = portfolio.get('winning_trades', 0) + 1
-                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0.0) + pnl_usd
+                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + pnl_usd
                 trade['result'] = 'WIN'
             else:
                 portfolio['losing_trades'] = portfolio.get('losing_trades', 0) + 1
-                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0.0) + abs(pnl_usd)
+                portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0) + abs(pnl_usd)
                 trade['result'] = 'LOSS'
 
-            total_t = portfolio['total_trades']
-            if total_t > 0:
-                portfolio['win_rate'] = (portfolio['winning_trades'] / total_t) * 100
-            
-            trade['pnl_usd'] = pnl_usd 
-            
             await self.r2.save_portfolio_state_async(portfolio)
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             await self.r2.append_to_closed_trades_history(trade)
             
-            print(f"✅ [EXIT EXECUTED] {symbol} | Reason: {reason} | PnL: {profit_pct_display:.2f}% (${pnl_usd:.2f}) | New Cap: ${new_capital:.2f}")
+            print(f"✅ [EXIT] {symbol} | PnL: {trade['profit_pct']:.2f}% | Cap: ${new_cap:.2f}")
 
             if "AI_" in reason:
-                self._launch_post_exit_analysis(symbol, exit_price, trade['exit_time'], current_capital, ai_scores)
+                self._launch_post_exit_analysis(symbol, exit_p, trade.get('exit_time'), curr_cap, ai_scores)
 
             if symbol in self.sentry_tasks:
                 self.sentry_tasks[symbol].cancel()
                 del self.sentry_tasks[symbol]
 
         except Exception as e:
-            print(f"❌ [TradeManager] فشل فادح أثناء تنفيذ الخروج لـ {symbol}: {e}")
-            traceback.print_exc()
-            if symbol not in self.open_positions:
-                 self.open_positions[symbol] = trade 
+            print(f"❌ [Exit Error] {e}")
+            self.open_positions[symbol] = trade # استعادة في حال الخطأ
 
     async def force_exit_by_manager(self, symbol, reason):
-        print(f"⚠️ [Manager Force Exit] طلب خروج إداري لـ {symbol} بسبب: {reason}")
-        current_price = await self.data_manager.get_latest_price_async(symbol)
+        p = await self.data_manager.get_latest_price_async(symbol)
         async with self.execution_lock:
-            await self._execute_exit(symbol, current_price, reason)
-
-    async def update_trade_targets(self, symbol, new_tp=None, new_sl=None, reason="MANUAL"):
-        if symbol in self.open_positions:
-            trade = self.open_positions[symbol]
-            old_tp = trade['tp_price']
-            old_sl = trade['sl_price']
-            
-            if new_tp is not None: trade['tp_price'] = float(new_tp)
-            if new_sl is not None: trade['sl_price'] = float(new_sl)
-            
-            self.open_positions[symbol] = trade
-            await self.r2.save_open_trades_async(list(self.open_positions.values()))
-            
-            print(f"🎯 [Targets Updated] {symbol} | TP: {old_tp:.8f}->{trade['tp_price']:.8f} | SL: {old_sl:.8f}->{trade['sl_price']:.8f} | Reason: {reason}")
-        else:
-            print(f"⚠️ [Target Update Failed] {symbol} is not currently open.")
+            await self._execute_exit(symbol, p, reason)
 
     async def start_sentry_loops(self):
         for symbol in list(self.open_positions.keys()):
              if symbol not in self.sentry_tasks or self.sentry_tasks[symbol].done():
-                 print(f"🛡️ [Sentry Restart] Activating guardian for existing trade: {symbol}")
                  self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
 
     async def stop_sentry_loops(self):
-        print("🛑 [TradeManager] Stopping all sentry loops...")
         self.running = False
-        for sym, task in self.sentry_tasks.items():
-            task.cancel()
-        
-        await asyncio.sleep(1)
-        print("🛑 [TradeManager] All sentries stopped.")
+        for task in self.sentry_tasks.values(): task.cancel()