Update trade_manager.py

trade_manager.py

@@ -1,4 +1,5 @@
-# trade_manager.py (V27.7 - GEM-Architect: Watchdog & Resurrection Edition)
+# trade_manager.py
+# (V27.8 - GEM-Architect: Watchdog System + Visible Logic Scores)
 
 import asyncio
 import uuid
@@ -19,12 +20,14 @@ class TradeManager:
         self.sentry_tasks = {}
         self.running = True
         
-        # نظام نقل الرسائل للواجهة (UI Bridge)
+        # متغير لتمرير الرسائل إلى الواجهة (UI Log Bridge)
         self.latest_guardian_log = "🛡️ Guardian System Initialized."
         
-        # إعدادات الرسوم
+        # إعدادات الرسوم (Simulation Fees)
         self.FEE_RATE = 0.001 
-        self.ORACLE_CHECK_INTERVAL = 900 
+        
+        # إعدادات المراجعة الاستراتيجية (Oracle Re-check)
+        self.ORACLE_CHECK_INTERVAL = 900  # كل 15 دقيقة
         
         self.ai_stats = {
             "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
@@ -33,7 +36,7 @@ class TradeManager:
         }
         
         self.execution_lock = asyncio.Lock()
-        print(f"🛡️ [TradeManager V27.7] Watchdog System Online.")
+        print(f"🛡️ [TradeManager V27.8] Watchdog & Score Reporting Online.")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -42,20 +45,11 @@ class TradeManager:
     async def sync_internal_state_with_r2(self):
         try:
             open_trades_list = await self.r2.get_open_trades_async()
-            # نحافظ على الصفقات الموجودة في الذاكرة لتجنب قتل الحلقات عن طريق الخطأ
-            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]}
-
+            self.open_positions = {trade['symbol']: trade for trade in open_trades_list}
+            print(f"   -> [Sync] Recovered {len(self.open_positions)} active trades.")
         except Exception as e:
             print(f"❌ [TradeManager] R2 Sync Failed: {e}")
+            self.open_positions = {} 
 
     # ==============================================================================
     # 🐕 Watchdog: Ensure Guardians are ALWAYS Running
@@ -64,7 +58,7 @@ class TradeManager:
         """
         تقوم هذه الدالة بفحص كل صفقة مفتوحة.
         إذا لم يكن لها "حارس" (Task) يعمل، تقوم بإنشاء واحد فوراً.
-        تُستدعى هذه الدالة بشكل دوري من الطيار الآلي.
+        تستخدم لمنع توقف المراقبة الصامت.
         """
         active_symbols = list(self.open_positions.keys())
         if not active_symbols:
@@ -84,44 +78,65 @@ class TradeManager:
                 restored_count += 1
                 status_msgs.append(f"♻️ Resurrected {symbol}")
             else:
-                status_msgs.append(f"✅ {symbol} Active")
+                status_msgs.append(f"✅ {symbol} Running")
 
-        # تحديث السجل للواجهة
-        self.latest_guardian_log = f"🛡️ Guardians: {', '.join(status_msgs)}"
+        # ملاحظة: لا نقوم بتحديث latest_guardian_log هنا لكي لا نمسح الدرجات (Scores)
+        # إلا في حالة الإنعاش الطارئ.
         if restored_count > 0:
+            self.latest_guardian_log = f"⚠️ Watchdog restored: {', '.join(status_msgs)}"
             return f"⚠️ Watchdog restored {restored_count} guardians."
+        
         return "✅ All guardians active."
 
     # ==============================================================================
-    # 🎯 L4 Sniper Execution Logic
+    # 🎯 L4 Sniper Execution Logic (Authority Delegated to Engine)
     # ==============================================================================
     async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
-        if len(self.open_positions) > 0: return
+        if len(self.open_positions) > 0:
+             print(f"⛔ [TradeManager] Max positions reached. Skipping scan.")
+             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']
-            if signal.get('action_type') != 'BUY': continue
+            
+            # Spot Filter: نقبل فقط إشارات الشراء
+            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: continue
+            if not ohlcv_1m or len(ohlcv_1m) < 100:
+                print(f"   -> ⚠️ [Skip] {symbol}: Insufficient 1m data.")
+                continue
             
+            # 2. استشارة القناص
             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)
             
-            print(f"   -> 🔭 {symbol:<6} | Decision: {sniper_signal} | Score: {final_conf:.2f}")
+            ml_score = sniper_result.get('ml_score', 0.0)
+            ob_score = sniper_result.get('ob_score', 0.0)
+            
+            log_msg = (f"   -> 🔭 {symbol:<6} | Decision: {sniper_signal} | Score: {final_conf:.2f} "
+                       f"(ML:{ml_score:.2f} + OB:{ob_score:.2f})")
+            print(log_msg)
 
             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)
@@ -130,7 +145,12 @@ class TradeManager:
             print("   -> 📉 No candidates passed the Sniper L4 check.")
             return
 
-        sniper_candidates.sort(key=lambda x: (x.get('confidence', 0) + x.get('sniper_score', 0)), reverse=True)
+        # ترتيب حسب قوة Oracle + قوة القناص
+        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:
@@ -139,11 +159,12 @@ class TradeManager:
                 await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🚀 Entry Execution
+    # 🚀 Entry Execution (With Oracle V4 Params)
     # ==============================================================================
     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)
@@ -152,15 +173,17 @@ class TradeManager:
             current_capital = float(portfolio.get('current_capital_usd', 100.0))
             entry_fee_usd = current_capital * self.FEE_RATE
 
+            # --- [Oracle V4 Params] ---
             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',
+                'direction': 'LONG', # Spot is always LONG
                 'entry_time': datetime.now().isoformat(),
                 'status': 'OPEN',
                 'tp_price': tp_price,
@@ -168,147 +191,166 @@ class TradeManager:
                 'last_update': datetime.now().isoformat(),
                 'last_oracle_check': datetime.now().isoformat(),
                 'strategy': 'OracleV4_Spot',
+                
                 'initial_oracle_strength': oracle_strength,
-                'initial_oracle_class': signal_data.get('target_class', 'TP2'),
+                'initial_oracle_class': oracle_class,
                 '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
+            # Start Guardian Loop 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}")
+            print(f"✅ [ENTRY] {symbol} @ {current_price} | TP: {tp_price} | SL: {sl_price} | Str: {oracle_strength:.2f}")
 
         except Exception as e:
             print(f"❌ [Entry Error] {symbol}: {e}")
             traceback.print_exc()
 
     # ==============================================================================
-    # 🛡️ Hybrid Sentry (The Independent Loop)
+    # 🛡️ Hybrid Sentry + Strategic Oracle Layer
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry] STARTING WATCH for {symbol}...")
+        print(f"🛡️ [Sentry] STARTING WATCH for {symbol} (High/Low + Oracle)...")
         last_ai_check_time = 0
         
-        # حلقة لا نهائية طالما الصفقة موجودة
         while self.running:
-            # 1. Check if trade still exists in memory
+            # Check if trade exists
             if symbol not in self.open_positions:
-                print(f"👋 [Sentry] Trade {symbol} closed/removed. Stopping sentry.")
                 break
-                
-            try:
-                await asyncio.sleep(1) # Fast tick for price checks
-                trade = self.open_positions[symbol]
 
+            try:
+                await asyncio.sleep(1) 
+                trade = self.open_positions.get(symbol)
+                
                 # -------------------------------------------------------------
-                # 1. محاكاة التلامس السريعة (Fast Price Check)
+                # 1. محاكاة التلامس (High/Low Wicks Simulation)
                 # -------------------------------------------------------------
-                # نستخدم السعر اللحظي لتوفير استدعاءات الـ API
+                # استخدام السعر اللحظي لتوفير الطلبات إذا لم تتوفر الشموع الكاملة
                 current_ticker_price = await self.data_manager.get_latest_price_async(symbol)
-                
-                # Check TP/SL
+
+                # Check TP/SL Hits
                 if current_ticker_price >= trade['tp_price']:
-                    print(f"🎯 [TP HIT] Price {current_ticker_price} >= {trade['tp_price']}")
+                    print(f"🎯 [TP HIT] Price {current_ticker_price} touched Target {trade['tp_price']}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, trade['tp_price'], "TP_HIT")
                     break 
-                
+
                 if current_ticker_price <= trade['sl_price']:
-                    print(f"🛑 [SL HIT] Price {current_ticker_price} <= {trade['sl_price']}")
+                    print(f"🛑 [SL HIT] Price {current_ticker_price} touched Stop {trade['sl_price']}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, trade['sl_price'], "SL_HIT")
-                    break
+                    break 
 
                 # -------------------------------------------------------------
-                # 2. الحارس الهجين (The Hybrid Guardian - Every 60s)
+                # 2. الحارس الهجين (Hybrid Guardian - AI Check)
                 # -------------------------------------------------------------
                 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)
                     
                     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:
-                        # استشارة الحارس
+                    except:
+                        continue # Skip cycle on network error
+                    
+                    if d1 and d5 and d15 and len(d1) >= 500:
                         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')
+                        scores = decision.get('scores', {'v2': 0.0, 'v3': 0.0})
+                        v2_val = scores.get('v2', 0.0)
+                        v3_val = scores.get('v3', 0.0)
                         
-                        # تحديث السجل للواجهة
-                        score_txt = f"V2:{scores.get('v2',0):.2f}|V3:{scores.get('v3',0):.2f}"
-                        self.latest_guardian_log = f"🛡️ {symbol}: {action} ({score_txt})"
+                        # ✅ تحديث السجل للواجهة بالصيغة المطلوبة (V2:0.60 | V3:0.70)
+                        log_msg = f"🛡️ {symbol}: {action} | V2:{v2_val:.2f} | V3:{v3_val:.2f}"
+                        self.latest_guardian_log = log_msg
                         
                         if action in ['EXIT_HARD', 'EXIT_SOFT']:
-                            print(f"🤖 [Guardian Trigger] {symbol} -> {action}: {reason}")
+                            print(f"🤖 [Guardian] {action}: {decision.get('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
+                        
+                        # يمكن طباعة حالة الأمان في الكونسول أيضاً إذا رغبت
+                        # print(f"   {log_msg}")
 
                     last_ai_check_time = time.time()
                     self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
                 
                 # -------------------------------------------------------------
-                # 3. Oracle Strategy Update (Every 15 mins)
+                # 3. الطبقة الاستراتيجية (Oracle V4 Re-Evaluation)
                 # -------------------------------------------------------------
-                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:
+                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:
                     self.open_positions[symbol]['last_oracle_check'] = datetime.now().isoformat()
                     await self._consult_oracle_strategy_update(symbol, trade)
 
-            except asyncio.CancelledError:
-                print(f"🛑 [Sentry] Task Cancelled for {symbol}")
-                break
+            except asyncio.CancelledError: break
             except Exception as e:
-                print(f"❌ [Sentry Critical Error] {symbol}: {e}")
-                traceback.print_exc()
-                await asyncio.sleep(10) # Backoff on crash to avoid CPU spin
+                print(f"❌ [Sentry Error] {symbol}: {e}")
+                await asyncio.sleep(5)
 
     async def _consult_oracle_strategy_update(self, symbol, trade):
+        """
+        Oracle V4 Strategy Update
+        """
         try:
             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)
-            l2_analysis = await self.processor.process_compound_signal({'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': curr_p})
+            raw_data = {'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': curr_p}
+            
+            l2_analysis = await self.processor.process_compound_signal(raw_data)
+            if not l2_analysis: return
+            
+            oracle_verdict = await self.processor.consult_oracle(l2_analysis)
+            
+            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
+
+            current_strength = oracle_verdict.get('strength', 0.5)
+            initial_strength = trade.get('initial_oracle_strength', 0.5)
             
-            if l2_analysis:
-                oracle_verdict = await self.processor.consult_oracle(l2_analysis)
+            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 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")
+                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)")
+
         except Exception as e:
             print(f"⚠️ [Oracle Re-Eval Error] {e}")
 
     # ==============================================================================
-    # 👻 Post-Exit Logic
+    # 👻 Ghost Monitor & Learning
     # ==============================================================================
     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))
@@ -323,7 +365,7 @@ 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) 
+        await asyncio.sleep(900) # 15 min check
         try:
             curr = await self.data_manager.get_latest_price_async(symbol)
             if curr == 0: return
@@ -337,13 +379,19 @@ 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 Error] {e}")
+            print(f"⚠️ [Ghost/Learning 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:
@@ -351,12 +399,13 @@ 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))
             
-            # PnL Calc
+            # Spot PnL Logic
             exit_value_gross = (exit_price / entry_price) * entry_capital
             exit_fee_usd = exit_value_gross * self.FEE_RATE
-            entry_fee_usd = float(trade.get('entry_fee_usd', 0.0))
-            net_pnl_usd = (exit_value_gross - exit_fee_usd) - entry_capital 
+            net_exit_value = exit_value_gross - exit_fee_usd
+            net_pnl_usd = net_exit_value - entry_capital 
             net_profit_pct = (net_pnl_usd / entry_capital) * 100
             
             trade.update({
@@ -365,12 +414,14 @@ 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,
-                'exit_time': datetime.now().isoformat()
+                'fees_paid_usd': entry_fee_usd + exit_fee_usd
             })
 
             portfolio = await self.r2.get_portfolio_state_async()
-            portfolio['current_capital_usd'] = float(portfolio.get('current_capital_usd', 100.0)) + net_pnl_usd
+            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['total_trades'] = portfolio.get('total_trades', 0) + 1
             
             if net_pnl_usd >= 0:
@@ -386,19 +437,22 @@ 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} | PnL: {net_profit_pct:.2f}% | {reason}")
+            print(f"✅ [EXIT] {symbol} | Net PnL: {net_profit_pct:.2f}% (${net_pnl_usd:.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)
+            # Update UI Log
+            self.latest_guardian_log = f"✅ Closed {symbol} ({reason})"
 
             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)
@@ -406,7 +460,8 @@ class TradeManager:
             await self._execute_exit(symbol, p, reason)
 
     async def start_sentry_loops(self):
-        await self.ensure_active_guardians() # Uses the new watchdog method directly
+        # Uses the new watchdog method directly to start loops
+        await self.ensure_active_guardians()
 
     async def stop_sentry_loops(self):
         self.running = False