Update trade_manager.py

trade_manager.py

@@ -1,10 +1,10 @@
-# trade_manager.py (V25.0 - GEM-Architect: Strategic Oracle Integration)
+# trade_manager.py (V25.2 - GEM-Architect: Full Spot Edition with Oracle V4)
 
 import asyncio
 import uuid
 import time
 import traceback
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import List, Dict, Any
 
 class TradeManager:
@@ -32,7 +32,7 @@ class TradeManager:
         }
         
         self.execution_lock = asyncio.Lock()
-        print(f"🛡️ [TradeManager V25.0] Strategic Commander Initialized.")
+        print(f"🛡️ [TradeManager V25.2] Full Spot Commander Initialized.")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -48,12 +48,9 @@ class TradeManager:
             self.open_positions = {} 
 
     # ==============================================================================
-    # 🎯 L4 Sniper Execution Logic (Oracle Directed)
+    # 🎯 L4 Sniper Execution Logic (Oracle V4 Directed - Spot Only)
     # ==============================================================================
     async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
-        """
-        يتلقى إشارات Oracle V2، ويستخدم Sniper (القديم) فقط لاختيار أفضل نقطة دخول.
-        """
         if len(self.open_positions) > 0:
              print(f"⛔ [TradeManager] Max positions reached. Skipping scan.")
              return
@@ -65,12 +62,14 @@ class TradeManager:
         
         for signal in oracle_approved_signals:
             symbol = signal['symbol']
-            oracle_direction = signal.get('action_type', 'BUY') # BUY or SELL from Oracle
             
+            # 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)
@@ -79,35 +78,20 @@ class TradeManager:
                 print(f"   -> [Sniper Skip] {symbol} (Insufficient 1m data).")
                 continue
             
-            # 2. استشارة القناص (Tactical Check)
-            # نمرر له البيانات ليفحص هل الدخول مناسب الآن؟
-            # ملاحظة: نستخدم check_sniper_entry الموجودة في Processor والتي تستدعي SniperEngine
+            # 2. استشارة القناص
+            # نمرر له direction='LONG' دائماً لأننا في Spot
             sniper_result = await self.processor.check_sniper_entry(ohlcv_1m, order_book)
             
-            # 3. التحقق من التوافق (Alignment Check)
-            # Oracle يقول "شراء"، هل القناص يرى دخول "شراء" جيد؟
-            sniper_signal = sniper_result.get('signal', 'WAIT') # BUY/SELL/WAIT
+            sniper_signal = sniper_result.get('signal', 'WAIT')
             sniper_conf = sniper_result.get('confidence_prob', 0.0)
             
-            # شرط الموافقة:
-            # 1. القناص يعطي إشارة توافق اتجاه Oracle (أو على الأقل لا تعارضه بقوة)
-            # 2. إذا كان القناص بسيطاً جداً ويعطي BUY دائماً عند القاع، نتأكد أننا في Oracle BUY.
-            
-            is_compatible = False
-            if oracle_direction == 'BUY' and sniper_signal == 'BUY':
-                is_compatible = True
-            elif oracle_direction == 'SELL' and sniper_signal == 'SELL':
-                is_compatible = True
-            
-            if is_compatible and sniper_conf >= 0.60:
-                print(f"   -> 🎯 [Sniper Confirmed] {symbol} | Oracle:{oracle_direction} + Sniper:{sniper_signal}")
+            # 3. التحقق من التوافق (Must be BUY/LONG)
+            if sniper_signal == 'BUY' and sniper_conf >= 0.60:
+                print(f"   -> 🎯 [Sniper Confirmed] {symbol} | Oracle:BUY + Sniper:BUY")
                 
-                # دمج معلومات القناص مع إشارة Oracle
-                signal['sniper_entry_price'] = sniper_result.get('entry_price', 0) # إذا كان القناص يقترح سعراً
+                signal['sniper_entry_price'] = sniper_result.get('entry_price', 0)
                 signal['sniper_score'] = sniper_conf
                 sniper_candidates.append(signal)
-            else:
-                print(f"   -> 🔸 [Sniper Mismatch] {symbol} | Oracle:{oracle_direction} vs Sniper:{sniper_signal}")
 
         if not sniper_candidates:
             return
@@ -125,7 +109,7 @@ class TradeManager:
                 await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🚀 Entry Execution (With Oracle V2 Parameters)
+    # 🚀 Entry Execution (With Oracle V4 Params)
     # ==============================================================================
     async def _execute_entry_from_signal(self, symbol, signal_data):
         try:
@@ -140,45 +124,39 @@ class TradeManager:
             current_capital = float(portfolio.get('current_capital_usd', 100.0))
             entry_fee_usd = current_capital * self.FEE_RATE
 
-            # --- [Oracle V2 Integration] ---
-            # استخدام الأهداف الذكية من Oracle
-            tp_price = float(signal_data.get('primary_tp', 0.0))
-            sl_price = float(signal_data.get('sl_price', 0.0))
+            # --- [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')
-            direction = signal_data.get('action_type', 'BUY')
-
-            # Fallback (Safety Net)
-            if tp_price <= 0 or sl_price <= 0:
-                atr_mock = current_price * 0.02 
-                if direction == 'BUY':
-                    tp_price = current_price * 1.04
-                    sl_price = current_price * 0.98
-                else:
-                    tp_price = current_price * 0.96
-                    sl_price = current_price * 1.02
 
             new_trade = {
                 'id': trade_id,
                 'symbol': symbol,
                 'entry_price': current_price,
-                'direction': direction, # LONG/SHORT support
+                'direction': 'LONG', # Spot is always LONG
                 'entry_time': datetime.now().isoformat(),
                 'status': 'OPEN',
                 'tp_price': tp_price,
                 'sl_price': sl_price,
                 'last_update': datetime.now().isoformat(),
-                'last_oracle_check': datetime.now().isoformat(), # للتوقيت
-                'strategy': f"OracleV2_{direction}", 
+                'last_oracle_check': datetime.now().isoformat(),
+                'strategy': 'OracleV4_Spot',
                 
-                # تخزين بيانات Oracle الأصلية للمقارنة لاحقاً
+                # تخزين بيانات Oracle
                 'initial_oracle_strength': oracle_strength,
                 '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))
+                '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
@@ -190,11 +168,10 @@ class TradeManager:
             
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             
-            # تفعيل الحارس
             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} ({direction}) @ {current_price} | TP: {tp_price} | SL: {sl_price} | Str: {oracle_strength:.2f}")
+            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}")
@@ -204,7 +181,8 @@ class TradeManager:
     # 🛡️ Hybrid Sentry + Strategic Oracle Layer
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry] Guarding {symbol}...")
+        print(f"🛡️ [Sentry] Guarding {symbol} (High/Low Simulation + Oracle)...")
+        last_ai_check_time = 0
         
         while self.running and symbol in self.open_positions:
             try:
@@ -213,47 +191,65 @@ class TradeManager:
                 if not trade: break 
 
                 # -------------------------------------------------------------
-                # 1. التفتيش الروتيني (Guardian Execution)
+                # 1. محاكاة التلامس (High/Low Wicks Simulation)
                 # -------------------------------------------------------------
-                # هذا الجزء لا يفهم الاستراتيجية، هو فقط ينفذ الأوامر (TP/SL/Panic)
                 ohlcv = await self.data_manager.get_latest_ohlcv(symbol, '1m', limit=2)
-                curr_price = await self.data_manager.get_latest_price_async(symbol)
+                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]
                 
-                if ohlcv:
-                    candle_high = ohlcv[-1][2]
-                    candle_low = ohlcv[-1][3]
-                    direction = trade.get('direction', 'BUY')
+                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']}")
+                    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']}")
+                    async with self.execution_lock:
+                        await self._execute_exit(symbol, trade['sl_price'], "SL_HIT")
+                    break 
+
+                # -------------------------------------------------------------
+                # 2. الحارس الهجين (Hybrid Guardian - AI Check)
+                # -------------------------------------------------------------
+                if time.time() - last_ai_check_time > 60:
+                    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)
                     
-                    # منطق الخروج (LONG)
-                    if direction == 'BUY':
-                        if max(curr_price, candle_high) >= trade['tp_price']:
-                            await self._execute_exit(symbol, trade['tp_price'], "TP_HIT")
-                            break
-                        if min(curr_price, candle_low) <= trade['sl_price']:
-                            await self._execute_exit(symbol, trade['sl_price'], "SL_HIT")
+                    if d1 and d5 and d15 and len(d1) >= 500:
+                        decision = self.processor.consult_guardian(d1, d5, d15, trade['entry_price'])
+                        action = decision.get('action', 'HOLD')
+                        scores = decision.get('scores', {})
+                        
+                        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_ticker_price, f"AI_{action}", ai_scores=scores)
                             break
+                    last_ai_check_time = time.time()
                     
-                    # منطق الخروج (SHORT)
-                    elif direction == 'SELL':
-                        if min(curr_price, candle_low) <= trade['tp_price']: # ربح الشورت في النزول
-                            await self._execute_exit(symbol, trade['tp_price'], "TP_HIT")
-                            break
-                        if max(curr_price, candle_high) >= trade['sl_price']: # خسارة الشورت في الصعود
-                            await self._execute_exit(symbol, trade['sl_price'], "SL_HIT")
-                            break
-
+                    self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
+                
                 # -------------------------------------------------------------
-                # 2. الطبقة الاستراتيجية (Oracle Re-Evaluation) - System 2
+                # 3. الطبقة الاستراتيجية (Oracle V4 Re-Evaluation) [NEW]
                 # -------------------------------------------------------------
-                # نفحص هل حان وقت استشارة الجنرال؟
-                last_check = datetime.fromisoformat(trade.get('last_oracle_check', datetime.now().isoformat()))
-                time_since_check = (datetime.now() - last_check).total_seconds()
-                
-                if time_since_check > self.ORACLE_CHECK_INTERVAL:
-                    # نعم، مر الوقت المحدد. استدعاء Oracle
-                    await self._consult_oracle_strategy_update(symbol, trade)
-                    # تحديث التوقيت
+                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: break
             except Exception as e:
@@ -262,115 +258,173 @@ class TradeManager:
 
     async def _consult_oracle_strategy_update(self, symbol, trade):
         """
-        المنطق الاستراتيجي: يسأل Oracle ويعدل تعليمات الحارس (Trade Params)
+        Oracle V4 Strategy Update:
+        - هل تحول الاتجاه إلى هبوط؟ -> خروج.
+        - هل ضعفت القوة؟ -> تقليص الهدف.
         """
         try:
-            # 1. جلب بيانات جديدة
-            # نحتاج أن نمرر البيانات بنفس الطريقة التي يتوقعها Processor
-            raw_data = await self.data_manager.get_analysis_data_packet(symbol) # دالة مساعدة مفترضة أو تجميع يدوي
-            if not raw_data: return
-
-            # 2. استدعاء Oracle عبر Processor (لضمان وجود الدرجات والميزات)
-            # بما أننا في منتصف الصفقة، قد لا نملك Titan Score محدث.
-            # سنطلب من Processor إجراء تحليل سريع
-            new_analysis = await self.processor.process_compound_signal(raw_data)
-            if not new_analysis: return
+            # 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}
             
-            oracle_verdict = await self.processor.consult_oracle(new_analysis)
+            # 2. تشغيل الطبقة الثانية (Titan/MC) للحصول على Scores محدثة
+            l2_analysis = await self.processor.process_compound_signal(raw_data)
+            if not l2_analysis: return
             
-            # 3. اتخاذ القرارات (Logic Layer)
+            # 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)
-            current_direction = oracle_verdict.get('action_type', 'BUY') # الاتجاه الحالي حسب Oracle
-            trade_direction = trade.get('direction', 'BUY')
             
-            print(f"🧠 [Oracle Re-Eval] {symbol}: Str {initial_strength:.2f} -> {current_strength:.2f} | Dir: {current_direction}")
-
-            # السيناريو أ: انعكاس الاتجاه (Dangerous!)
-            if current_direction != trade_direction:
-                # إذا كانت الثقة عالية في الانعكاس، اخرج فوراً
-                if oracle_verdict.get('confidence', 0) > 0.75:
-                    print(f"🚨 [Oracle Command] THESIS FAILED. Inverting... Exiting {symbol}.")
-                    await self.force_exit_by_manager(symbol, reason="Oracle_Trend_Reversal")
-                    return
-
-            # السيناريو ب: ضعف الزخم (Weakness)
-            # إذا انخفضت القوة بشكل ملحوظ (مثلاً 30% أقل)
-            if current_strength < (initial_strength * 0.7):
-                print(f"⚠️ [Oracle Command] Momentum fading. Tightening TP.")
+            if current_strength < (initial_strength * 0.6):
+                print(f"⚠️ [Oracle Command] Momentum fading ({initial_strength:.2f}->{current_strength:.2f}). Lowering TP.")
                 
-                # تقليص الهدف: إذا كنا نطمح لـ TP3، نرضى بـ TP1 أو TP2
-                current_tp = trade['tp_price']
                 tp_map = trade.get('oracle_tp_map', {})
                 conservative_tp = tp_map.get('TP1')
+                current_tp = trade['tp_price']
                 
-                # تعديل الهدف في الذاكرة (الحارس سينفذ هذا الهدف الجديد)
-                if conservative_tp:
-                    # تأكد أن الهدف الجديد مازال منطقياً (أعلى من السعر الحالي للشراء)
-                    curr_p = await self.data_manager.get_latest_price_async(symbol)
-                    is_valid = (trade_direction == 'BUY' and conservative_tp > curr_p) or \
-                               (trade_direction == 'SELL' and conservative_tp < curr_p)
-                    
-                    if is_valid and abs(conservative_tp - curr_p) < abs(current_tp - curr_p):
+                # تأكد أن الهدف الجديد أعلى من السعر الحالي (نحن في صفقة شراء)
+                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)")
 
-            # السيناريو ج: زيادة القوة (Booming) - اختياري
-            # يمكن رفع الوقف (Trailing) هنا
+        except Exception as e:
+            print(f"⚠️ [Oracle Re-Eval Error] {e}")
+
+    # ==============================================================================
+    # 👻 Ghost Monitor & Learning (Restored)
+    # ==============================================================================
+    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))
+
+    def _update_specific_stat(self, key, is_good, usd_impact):
+        if key not in self.ai_stats: return
+        self.ai_stats[key]["total"] += 1
+        if is_good:
+            self.ai_stats[key]["good"] += 1
+            self.ai_stats[key]["saved"] += abs(usd_impact)
+        else:
+            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
+        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 
+            
+            self._update_specific_stat("hybrid", is_good_exit, usd_impact)
+            if ai_scores:
+                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"⚠️ [Re-Eval Warning] {e}")
+            print(f"⚠️ [Ghost/Learning Error] {e}")
 
     # ==============================================================================
-    # 🔴 Exit & Helpers (Standard)
+    # 🔴 Exit Logic (Spot PnL)
     # ==============================================================================
-    async def _execute_exit(self, symbol, price, reason):
-        # (نفس دالة الخروج السابقة مع دعم الـ Fees والـ PnL)
-        # ... [Keep previous implementation code for _execute_exit] ...
-        # اختصاراً للمساحة، سأفترض بقاء الكود السابق كما هو لأنه لم يتغير منطقياً
+    async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         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)
             entry_capital = float(trade.get('entry_capital', 100.0))
+            entry_fee_usd = float(trade.get('entry_fee_usd', 0.0))
             
-            # حساب PnL مع دعم Long/Short
-            direction = trade.get('direction', 'BUY')
-            if direction == 'BUY':
-                pnl_gross_pct = (exit_price - entry_price) / entry_price
-            else:
-                pnl_gross_pct = (entry_price - exit_price) / entry_price # Short Profit
-            
-            gross_profit_usd = pnl_gross_pct * entry_capital
-            fees_usd = entry_capital * self.FEE_RATE * 2 # Entry + Exit
-            net_pnl_usd = gross_profit_usd - fees_usd
+            # Spot PnL Logic
+            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 
             net_profit_pct = (net_pnl_usd / entry_capital) * 100
             
-            # تحديث المحفظة والسجلات (كما في الكود السابق)
             trade.update({
-                'status': 'CLOSED', 'exit_price': exit_price, 'exit_reason': reason,
-                'profit_pct': net_profit_pct, 'net_pnl_usd': net_pnl_usd, 'fees_paid_usd': fees_usd
+                'status': 'CLOSED', 
+                'exit_price': exit_price, 
+                'exit_reason': reason, 
+                'profit_pct': net_profit_pct,
+                'net_pnl_usd': net_pnl_usd,
+                'fees_paid_usd': entry_fee_usd + exit_fee_usd
             })
+
+            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
             
-            await self.r2.append_to_closed_trades_history(trade)
-            # ... (Update portfolio logic) ...
+            portfolio['current_capital_usd'] = new_cap
+            portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
             
-            print(f"✅ [EXIT] {symbol} ({direction}) | Net: {net_profit_pct:.2f}% (${net_pnl_usd:.2f}) | {reason}")
+            if net_pnl_usd >= 0:
+                portfolio['winning_trades'] = portfolio.get('winning_trades', 0) + 1
+                portfolio['total_profit_usd'] = portfolio.get('total_profit_usd', 0) + net_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) + abs(net_pnl_usd)
+                trade['result'] = 'LOSS'
+
+            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)
             
-            if symbol in self.sentry_tasks: 
+            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)
+
+            if symbol in self.sentry_tasks:
                 self.sentry_tasks[symbol].cancel()
                 del self.sentry_tasks[symbol]
 
         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)
         async with self.execution_lock:
             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))
+
     async def stop_sentry_loops(self):
         self.running = False
         for task in self.sentry_tasks.values(): task.cancel()