Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (V25.3 - GEM-Architect: Separation of Concerns Edition)
+# trade_manager.py (V27.7 - GEM-Architect: Watchdog & Resurrection Edition)
 
 import asyncio
 import uuid
@@ -19,11 +19,12 @@ class TradeManager:
         self.sentry_tasks = {}
         self.running = True
         
-        # إعدادات الرسوم (Simulation Fees)
-        self.FEE_RATE = 0.001 
+        # نظام نقل الرسائل للواجهة (UI Bridge)
+        self.latest_guardian_log = "🛡️ Guardian System Initialized."
         
-        # إعدادات المراجعة الاستراتيجية (Oracle Re-check)
-        self.ORACLE_CHECK_INTERVAL = 900  # كل 15 دقيقة
+        # إعدادات الرسوم
+        self.FEE_RATE = 0.001 
+        self.ORACLE_CHECK_INTERVAL = 900 
         
         self.ai_stats = {
             "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
@@ -32,7 +33,7 @@ class TradeManager:
         }
         
         self.execution_lock = asyncio.Lock()
-        print(f"🛡️ [TradeManager V25.3] Full Spot Commander Initialized.")
+        print(f"🛡️ [TradeManager V27.7] Watchdog System Online.")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -41,84 +42,95 @@ class TradeManager:
     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] Recovered {len(self.open_positions)} active trades.")
+            # نحافظ على الصفقات الموجودة في الذاكرة لتجنب قتل الحلقات عن طريق الخطأ
+            current_ids = set(self.open_positions.keys())
+            
+            for trade in open_trades_list:
+                sym = trade['symbol']
+                if sym not in self.open_positions:
+                    self.open_positions[sym] = trade
+                    print(f"   -> [Sync] Restored trade for {sym} from DB.")
+            
+            # (اختياري) تنظيف الصفقات التي اختفت من قاعدة البيانات
+            # self.open_positions = {k: v for k, v in self.open_positions.items() if k in [t['symbol'] for t in open_trades_list]}
+
         except Exception as e:
             print(f"❌ [TradeManager] R2 Sync Failed: {e}")
-            self.open_positions = {} 
 
     # ==============================================================================
-    # 🎯 L4 Sniper Execution Logic (Authority Delegated to Engine)
+    # 🐕 Watchdog: Ensure Guardians are ALWAYS Running
+    # ==============================================================================
+    async def ensure_active_guardians(self):
+        """
+        تقوم هذه الدالة بفحص كل صفقة مفتوحة.
+        إذا لم يكن لها "حارس" (Task) يعمل، تقوم بإنشاء واحد فوراً.
+        تُستدعى هذه الدالة بشكل دوري من الطيار الآلي.
+        """
+        active_symbols = list(self.open_positions.keys())
+        if not active_symbols:
+            return "💤 No active trades."
+
+        restored_count = 0
+        status_msgs = []
+
+        for symbol in active_symbols:
+            # التحقق: هل المهمة موجودة؟ وهل هي تعمل؟
+            task = self.sentry_tasks.get(symbol)
+            is_alive = task and not task.done()
+
+            if not is_alive:
+                print(f"🚨 [Watchdog] Found DEAD guardian for {symbol}. Resurrecting...")
+                self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
+                restored_count += 1
+                status_msgs.append(f"♻️ Resurrected {symbol}")
+            else:
+                status_msgs.append(f"✅ {symbol} Active")
+
+        # تحديث السجل للواجهة
+        self.latest_guardian_log = f"🛡️ Guardians: {', '.join(status_msgs)}"
+        if restored_count > 0:
+            return f"⚠️ Watchdog restored {restored_count} guardians."
+        return "✅ All guardians active."
+
+    # ==============================================================================
+    # 🎯 L4 Sniper Execution Logic
     # ==============================================================================
     async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
-        if len(self.open_positions) > 0:
-             print(f"⛔ [TradeManager] Max positions reached. Skipping scan.")
-             return
+        if len(self.open_positions) > 0: return
 
         if not self.processor.initialized:
             await self.processor.initialize()
 
         sniper_candidates = []
-        
         print(f"\n🔎 [Sniper] Scanning {len(oracle_approved_signals)} candidates...")
 
         for signal in oracle_approved_signals:
             symbol = signal['symbol']
-            
-            # Spot Filter: نقبل فقط إشارات الشراء
-            if signal.get('action_type') != 'BUY': 
-                continue
-
+            if signal.get('action_type') != 'BUY': continue
             if symbol in self.open_positions: continue
 
-            # 1. جلب بيانات الدقيقة للقناص
             ohlcv_task = self.data_manager.get_latest_ohlcv(symbol, '1m', 1000) 
             ob_task = self.data_manager.get_order_book_snapshot(symbol)
             ohlcv_1m, order_book = await asyncio.gather(ohlcv_task, ob_task)
             
-            if not ohlcv_1m or len(ohlcv_1m) < 100:
-                print(f"   -> ⚠️ [Skip] {symbol}: Insufficient 1m data.")
-                continue
+            if not ohlcv_1m or len(ohlcv_1m) < 100: continue
             
-            # 2. استشارة القناص (هو من يمتلك القرار والعتبة)
-            # نمرر له البيانات وننتظر الحكم (BUY/WAIT) + التفاصيل
             sniper_result = await self.processor.check_sniper_entry(ohlcv_1m, order_book)
-            
             sniper_signal = sniper_result.get('signal', 'WAIT')
             final_conf = sniper_result.get('confidence_prob', 0.0)
             
-            # استخراج التفاصيل للسجلات (الشفافية الكاملة)
-            ml_score = sniper_result.get('ml_score', 0.0)
-            ob_score = sniper_result.get('ob_score', 0.0)
-            reason = sniper_result.get('reason', 'N/A')
-            
-            # طباعة السجل المفصل الذي طلبته
-            log_msg = (f"   -> 🔭 {symbol:<6} | Decision: {sniper_signal} | Score: {final_conf:.2f} "
-                       f"(ML:{ml_score:.2f} + OB:{ob_score:.2f})")
-            print(log_msg)
+            print(f"   -> 🔭 {symbol:<6} | Decision: {sniper_signal} | Score: {final_conf:.2f}")
 
-            # 3. التحقق من التوافق (طاعة عمياء للمحرك)
-            # لم نعد نفحص أي أرقام هنا، المحرك قام بذلك بالفعل
             if sniper_signal == 'BUY':
-                print(f"      ✅ [ACCEPTED] {symbol} approved by Sniper Engine.")
-                
                 signal['sniper_entry_price'] = sniper_result.get('entry_price', 0)
                 signal['sniper_score'] = final_conf
                 sniper_candidates.append(signal)
-            else:
-                # فقط نوضح سبب الرفض في حال أراد المستخدم المراجعة
-                pass # الرسالة السابقة تكفي (Decision: WAIT)
 
         if not sniper_candidates:
             print("   -> 📉 No candidates passed the Sniper L4 check.")
             return
 
-        # ترتيب حسب قوة Oracle + قوة القناص
-        sniper_candidates.sort(
-            key=lambda x: (x.get('confidence', 0) + x.get('sniper_score', 0)), 
-            reverse=True
-        )
-        
+        sniper_candidates.sort(key=lambda x: (x.get('confidence', 0) + x.get('sniper_score', 0)), reverse=True)
         best_signal = sniper_candidates[0]
         
         async with self.execution_lock:
@@ -127,13 +139,11 @@ class TradeManager:
                 await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🚀 Entry Execution (With Oracle V4 Params)
+    # 🚀 Entry Execution
     # ==============================================================================
     async def _execute_entry_from_signal(self, symbol, signal_data):
         try:
             trade_id = str(uuid.uuid4())
-            
-            # تحديد سعر الدخول (الأفضلية لسعر القناص، ثم السعر الحالي)
             current_price = float(signal_data.get('sniper_entry_price', 0.0))
             if current_price <= 0.0:
                  current_price = await self.data_manager.get_latest_price_async(symbol)
@@ -142,19 +152,15 @@ class TradeManager:
             current_capital = float(portfolio.get('current_capital_usd', 100.0))
             entry_fee_usd = current_capital * self.FEE_RATE
 
-            # --- [Oracle V4 Params] ---
-            # استخدام الأهداف الذكية القادمة من Oracle
-            # إذا لم تتوفر (Fallback)، نستخدم حسابات بسيطة
             tp_price = float(signal_data.get('primary_tp', current_price * 1.05))
             sl_price = float(signal_data.get('sl_price', current_price * 0.95))
             oracle_strength = float(signal_data.get('strength', 0.5))
-            oracle_class = signal_data.get('target_class', 'TP2')
 
             new_trade = {
                 'id': trade_id,
                 'symbol': symbol,
                 'entry_price': current_price,
-                'direction': 'LONG', # Spot is always LONG
+                'direction': 'LONG',
                 'entry_time': datetime.now().isoformat(),
                 'status': 'OPEN',
                 'tp_price': tp_price,
@@ -162,175 +168,147 @@ class TradeManager:
                 'last_update': datetime.now().isoformat(),
                 'last_oracle_check': datetime.now().isoformat(),
                 'strategy': 'OracleV4_Spot',
-                
-                # تخزين بيانات Oracle
                 'initial_oracle_strength': oracle_strength,
-                'initial_oracle_class': oracle_class,
+                'initial_oracle_class': signal_data.get('target_class', 'TP2'),
                 'oracle_tp_map': signal_data.get('tp_map', {}),
-                
                 'entry_capital': current_capital,
                 'entry_fee_usd': entry_fee_usd,
                 'l1_score': float(signal_data.get('enhanced_final_score', 0.0)),
-                'decision_data': {
-                    'components': signal_data.get('components', {}),
-                    'oracle_conf': signal_data.get('confidence', 0)
-                }
             }
             
             self.open_positions[symbol] = new_trade
             if self.watchlist: self.watchlist.clear()
             
-            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()))
             
+            # Start Guardian immediately
             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] {symbol} @ {current_price} | TP: {tp_price} | SL: {sl_price} | Str: {oracle_strength:.2f}")
+            print(f"✅ [ENTRY] {symbol} @ {current_price} | TP: {tp_price} | SL: {sl_price}")
 
         except Exception as e:
             print(f"❌ [Entry Error] {symbol}: {e}")
             traceback.print_exc()
 
     # ==============================================================================
-    # 🛡️ Hybrid Sentry + Strategic Oracle Layer
+    # 🛡️ Hybrid Sentry (The Independent Loop)
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry] Guarding {symbol} (High/Low Simulation + Oracle)...")
+        print(f"🛡️ [Sentry] STARTING WATCH for {symbol}...")
         last_ai_check_time = 0
         
-        while self.running and symbol in self.open_positions:
+        # حلقة لا نهائية طالما الصفقة موجودة
+        while self.running:
+            # 1. Check if trade still exists in memory
+            if symbol not in self.open_positions:
+                print(f"👋 [Sentry] Trade {symbol} closed/removed. Stopping sentry.")
+                break
+                
             try:
-                await asyncio.sleep(1) 
-                trade = self.open_positions.get(symbol)
-                if not trade: break 
+                await asyncio.sleep(1) # Fast tick for price checks
+                trade = self.open_positions[symbol]
 
                 # -------------------------------------------------------------
-                # 1. محاكاة التلامس (High/Low Wicks Simulation)
+                # 1. محاكاة التلامس السريعة (Fast Price Check)
                 # -------------------------------------------------------------
-                ohlcv = await self.data_manager.get_latest_ohlcv(symbol, '1m', limit=2)
+                # نستخدم السعر اللحظي لتوفير استدعاءات الـ API
                 current_ticker_price = await self.data_manager.get_latest_price_async(symbol)
-
-                if not ohlcv: continue
-
-                current_candle = ohlcv[-1]
-                candle_high = current_candle[2]
-                candle_low = current_candle[3]
                 
-                max_price_seen = max(current_ticker_price, candle_high)
-                min_price_seen = min(current_ticker_price, candle_low)
-
-                # Spot Long Logic Check
-                if max_price_seen >= trade['tp_price']:
-                    print(f"🎯 [TP HIT] Price {max_price_seen} touched Target {trade['tp_price']}")
+                # Check TP/SL
+                if current_ticker_price >= trade['tp_price']:
+                    print(f"🎯 [TP HIT] Price {current_ticker_price} >= {trade['tp_price']}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, trade['tp_price'], "TP_HIT")
                     break 
-
-                if min_price_seen <= trade['sl_price']:
-                    print(f"🛑 [SL HIT] Price {min_price_seen} touched Stop {trade['sl_price']}")
+                
+                if current_ticker_price <= trade['sl_price']:
+                    print(f"🛑 [SL HIT] Price {current_ticker_price} <= {trade['sl_price']}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, trade['sl_price'], "SL_HIT")
-                    break 
+                    break
 
                 # -------------------------------------------------------------
-                # 2. الحارس الهجين (Hybrid Guardian - AI Check)
+                # 2. الحارس الهجين (The Hybrid Guardian - Every 60s)
                 # -------------------------------------------------------------
                 if time.time() - last_ai_check_time > 60:
+                    self.latest_guardian_log = f"🧠 Guardian Analyzing {symbol}..."
+                    
+                    # جلب البيانات بشكل متزامن
                     t1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 1000)
                     t5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 500)
                     t15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 500)
-                    d1, d5, d15 = await asyncio.gather(t1, t5, t15)
                     
-                    if d1 and d5 and d15 and len(d1) >= 500:
-                        decision = self.processor.consult_guardian(d1, d5, d15, trade['entry_price'])
+                    try:
+                        d1, d5, d15 = await asyncio.gather(t1, t5, t15)
+                    except Exception as fetch_err:
+                        print(f"⚠️ [Sentry Warning] Data fetch failed for {symbol}: {fetch_err}")
+                        await asyncio.sleep(5) # انتظر قليلاً وحاول في الدورة القادمة
+                        continue
+
+                    if d1 and d5 and d15 and len(d1) >= 200:
+                        # استشارة الحارس
+                        decision = self.processor.consult_guardian(d1, d5, d15, float(trade['entry_price']))
+                        
                         action = decision.get('action', 'HOLD')
                         scores = decision.get('scores', {})
+                        reason = decision.get('reason', 'N/A')
+                        
+                        # تحديث السجل للواجهة
+                        score_txt = f"V2:{scores.get('v2',0):.2f}|V3:{scores.get('v3',0):.2f}"
+                        self.latest_guardian_log = f"🛡️ {symbol}: {action} ({score_txt})"
                         
                         if action in ['EXIT_HARD', 'EXIT_SOFT']:
-                            print(f"🤖 [Guardian] {action}: {decision.get('reason')}")
+                            print(f"🤖 [Guardian Trigger] {symbol} -> {action}: {reason}")
                             async with self.execution_lock:
                                 await self._execute_exit(symbol, current_ticker_price, f"AI_{action}", ai_scores=scores)
                             break
+                        else:
+                            # Log Safe Status
+                            # print(f"   🛡️ [Guardian] {symbol} Safe. {reason}")
+                            pass
+
                     last_ai_check_time = time.time()
-                    
                     self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
                 
                 # -------------------------------------------------------------
-                # 3. الطبقة الاستراتيجية (Oracle V4 Re-Evaluation) [NEW]
+                # 3. Oracle Strategy Update (Every 15 mins)
                 # -------------------------------------------------------------
-                last_oracle_check = datetime.fromisoformat(trade.get('last_oracle_check', datetime.now().isoformat()))
-                if (datetime.now() - last_oracle_check).total_seconds() > self.ORACLE_CHECK_INTERVAL:
-                    # تحديث التوقيت أولاً لمنع التكرار
+                last_check_str = trade.get('last_oracle_check', datetime.now().isoformat())
+                if (datetime.now() - datetime.fromisoformat(last_check_str)).total_seconds() > self.ORACLE_CHECK_INTERVAL:
                     self.open_positions[symbol]['last_oracle_check'] = datetime.now().isoformat()
-                    # استشارة الجنرال
                     await self._consult_oracle_strategy_update(symbol, trade)
 
-            except asyncio.CancelledError: break
+            except asyncio.CancelledError:
+                print(f"🛑 [Sentry] Task Cancelled for {symbol}")
+                break
             except Exception as e:
-                print(f"❌ [Sentry Error] {symbol}: {e}")
-                await asyncio.sleep(5)
+                print(f"❌ [Sentry Critical Error] {symbol}: {e}")
+                traceback.print_exc()
+                await asyncio.sleep(10) # Backoff on crash to avoid CPU spin
 
     async def _consult_oracle_strategy_update(self, symbol, trade):
-        """
-        Oracle V4 Strategy Update:
-        - هل تحول الاتجاه إلى هبوط؟ -> خروج.
-        - هل ضعفت القوة؟ -> تقليص الهدف.
-        """
         try:
-            # 1. تجميع البيانات
-            # نحتاج محاكاة دورة تحليلية مصغرة للحصول على Scores + OHLCV
-            # نطلب من DataManager جلب البيانات الأساسية
             tasks = [self.data_manager.get_latest_ohlcv(symbol, tf, limit=100) for tf in ["15m", "1h", "4h"]]
             results = await asyncio.gather(*tasks)
             ohlcv_data = {tf: res for tf, res in zip(["15m", "1h", "4h"], results) if res}
             
             if '1h' not in ohlcv_data: return
-
-            curr_p = await self.data_manager.get_latest_price_async(symbol)
-            raw_data = {'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': curr_p}
             
-            # 2. تشغيل الطبقة الثانية (Titan/MC) للحصول على Scores محدثة
-            l2_analysis = await self.processor.process_compound_signal(raw_data)
-            if not l2_analysis: return
-            
-            # 3. استشارة Oracle V4
-            oracle_verdict = await self.processor.consult_oracle(l2_analysis)
-            
-            # 4. اتخاذ القرار
-            # الحالة أ: Oracle يقول WAIT أو يتوقع هبوط
-            # (تذكر: Oracle V4 يعيد WAIT إذا كان التوقع Short في Spot Mode)
-            if oracle_verdict.get('action') == 'WAIT' or oracle_verdict.get('direction') == 'SHORT':
-                print(f"🚨 [Oracle Command] Outlook turned Bearish for {symbol}. Exiting...")
-                await self.force_exit_by_manager(symbol, reason="Oracle_Bearish_Flip")
-                return
-
-            # الحالة ب: ضعف الزخم (Weakness)
-            current_strength = oracle_verdict.get('strength', 0.5)
-            initial_strength = trade.get('initial_oracle_strength', 0.5)
+            curr_p = await self.data_manager.get_latest_price_async(symbol)
+            l2_analysis = await self.processor.process_compound_signal({'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': curr_p})
             
-            if current_strength < (initial_strength * 0.6):
-                print(f"⚠️ [Oracle Command] Momentum fading ({initial_strength:.2f}->{current_strength:.2f}). Lowering TP.")
-                
-                tp_map = trade.get('oracle_tp_map', {})
-                conservative_tp = tp_map.get('TP1')
-                current_tp = trade['tp_price']
+            if l2_analysis:
+                oracle_verdict = await self.processor.consult_oracle(l2_analysis)
                 
-                # تأكد أن الهدف الجديد أعلى من السعر الحالي (نحن في صفقة شراء)
-                if conservative_tp and conservative_tp > curr_p:
-                    # تحديث الهدف إذا كان أقرب من الهدف الحالي
-                    if conservative_tp < current_tp:
-                        self.open_positions[symbol]['tp_price'] = conservative_tp
-                        print(f"   -> TP updated to {conservative_tp} (TP1)")
-
+                if oracle_verdict.get('action') == 'WAIT' or oracle_verdict.get('direction') == 'SHORT':
+                    print(f"🚨 [Oracle Command] Bearish Flip for {symbol}. Exiting...")
+                    await self.force_exit_by_manager(symbol, reason="Oracle_Bearish_Flip")
         except Exception as e:
             print(f"⚠️ [Oracle Re-Eval Error] {e}")
 
     # ==============================================================================
-    # 👻 Ghost Monitor & Learning (Restored)
+    # 👻 Post-Exit Logic
     # ==============================================================================
     def _launch_post_exit_analysis(self, symbol, exit_price, exit_time, position_size_usd, ai_scores=None, trade_obj=None):
         asyncio.create_task(self._analyze_after_exit_task(symbol, exit_price, exit_time, position_size_usd, ai_scores, trade_obj))
@@ -345,13 +323,11 @@ 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, trade_obj):
-        await asyncio.sleep(900) # 15 min check
+        await asyncio.sleep(900) 
         try:
             curr = await self.data_manager.get_latest_price_async(symbol)
             if curr == 0: return
 
-            # Spot Logic: الخروج الجيد هو عندما يهبط السعر بعد بيعنا
-            # Exit Price > Current Price => Good Exit (Saved money)
             change_pct = (curr - exit_price) / exit_price
             usd_impact = change_pct * position_size_usd
             is_good_exit = change_pct < 0 
@@ -361,19 +337,13 @@ class TradeManager:
                 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(record)
-
             if self.learning_hub and trade_obj:
                 trade_obj['pnl_percent'] = trade_obj.get('profit_pct', 0.0)
                 await self.learning_hub.analyze_trade_and_learn(trade_obj, trade_obj.get('exit_reason', 'UNKNOWN'))
 
         except Exception as e:
-            print(f"⚠️ [Ghost/Learning Error] {e}")
+            print(f"⚠️ [Ghost Error] {e}")
 
-    # ==============================================================================
-    # 🔴 Exit Logic (Spot PnL)
-    # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         if symbol not in self.open_positions: return
         try:
@@ -381,13 +351,12 @@ class TradeManager:
             entry_price = float(trade['entry_price'])
             exit_price = float(price)
             entry_capital = float(trade.get('entry_capital', 100.0))
-            entry_fee_usd = float(trade.get('entry_fee_usd', 0.0))
             
-            # Spot PnL Logic
+            # PnL Calc
             exit_value_gross = (exit_price / entry_price) * entry_capital
             exit_fee_usd = exit_value_gross * self.FEE_RATE
-            net_exit_value = exit_value_gross - exit_fee_usd
-            net_pnl_usd = net_exit_value - entry_capital 
+            entry_fee_usd = float(trade.get('entry_fee_usd', 0.0))
+            net_pnl_usd = (exit_value_gross - exit_fee_usd) - entry_capital 
             net_profit_pct = (net_pnl_usd / entry_capital) * 100
             
             trade.update({
@@ -396,14 +365,12 @@ class TradeManager:
                 'exit_reason': reason, 
                 'profit_pct': net_profit_pct,
                 'net_pnl_usd': net_pnl_usd,
-                'fees_paid_usd': entry_fee_usd + exit_fee_usd
+                'fees_paid_usd': entry_fee_usd + exit_fee_usd,
+                'exit_time': datetime.now().isoformat()
             })
 
             portfolio = await self.r2.get_portfolio_state_async()
-            current_total_cap = float(portfolio.get('current_capital_usd', 100.0))
-            new_cap = current_total_cap + net_pnl_usd
-            
-            portfolio['current_capital_usd'] = new_cap
+            portfolio['current_capital_usd'] = float(portfolio.get('current_capital_usd', 100.0)) + net_pnl_usd
             portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
             
             if net_pnl_usd >= 0:
@@ -419,19 +386,19 @@ class TradeManager:
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             await self.r2.append_to_closed_trades_history(trade)
             
-            print(f"✅ [EXIT] {symbol} | Net PnL: {net_profit_pct:.2f}% (${net_pnl_usd:.2f}) | {reason}")
+            print(f"✅ [EXIT] {symbol} | PnL: {net_profit_pct:.2f}% | {reason}")
 
-            self._launch_post_exit_analysis(symbol, exit_price, trade.get('exit_time'), entry_capital, ai_scores, trade)
+            self._launch_post_exit_analysis(symbol, exit_price, datetime.now().isoformat(), entry_capital, ai_scores, trade)
 
             if symbol in self.sentry_tasks:
                 self.sentry_tasks[symbol].cancel()
                 del self.sentry_tasks[symbol]
+                
+            self.latest_guardian_log = f"✅ Closed {symbol} ({reason})"
 
         except Exception as e:
             print(f"❌ [Exit Error] {e}")
             traceback.print_exc()
-            if symbol not in self.open_positions:
-                 self.open_positions[symbol] = trade 
 
     async def force_exit_by_manager(self, symbol, reason):
         p = await self.data_manager.get_latest_price_async(symbol)
@@ -439,9 +406,7 @@ class TradeManager:
             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():
-                 self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
+        await self.ensure_active_guardians() # Uses the new watchdog method directly
 
     async def stop_sentry_loops(self):
         self.running = False