Update backtest_engine.py

backtest_engine.py

@@ -1,10 +1,10 @@
 # ============================================================
-# 🧪 backtest_engine.py (V42.1 - GEM-Architect: Exact Threshold Mapping)
+# 🧪 backtest_engine.py (V43.0 - GEM-Architect: Disk-Swapped Grid)
 # ============================================================
-# التحديثات:
-# 1. مطابقة تامة لمتغيرات processor.py (Hydra Crash/Giveback, Legacy V2/V3).
-# 2. توسيع الشبكة لتشمل هذه المتغيرات الدقيقة.
-# 3. تقرير يفصل أي "رأس" من رؤوس الحراس كان الأنشط.
+# التغييرات الجوهرية (Anti-Crash Architecture):
+# 1. التخزين المؤقت: حفظ البيانات في ملفات محلية بدلاً من RAM.
+# 2. قلب حلقة المعالجة: (Loop Coins -> Loop Strategies) لتقليل التحميل.
+# 3. استهلاك ذاكرة منخفض جداً (عملة واحدة في كل لحظة).
 # ============================================================
 
 import asyncio
@@ -13,7 +13,8 @@ import numpy as np
 import time
 import logging
 import itertools 
-from datetime import datetime
+import os
+import shutil
 from typing import Dict, Any, List
 
 from ml_engine.processor import MLProcessor, SystemLimits
@@ -23,34 +24,13 @@ from learning_hub.adaptive_hub import StrategyDNA
 # كتم الضوضاء
 logging.getLogger('ml_engine.patterns').setLevel(logging.WARNING)
 
-class VirtualPortfolio:
-    def __init__(self, initial_capital=1000.0):
-        self.capital = initial_capital
-        self.active_trades = {} 
-        self.stats = {
-            "max_win_usd": 0.0, "max_loss_usd": 0.0, 
-            "max_drawdown_pct": 0.0, "max_runup_pct": 0.0
-        }
-        # تفصيل أدق للحراس
-        self.guardian_log = {
-            'hydra_crash': 0, 'hydra_giveback': 0, 'hydra_stag': 0,
-            'legacy_v2': 0, 'legacy_v3': 0,
-            'tp': 0, 'sl': 0
-        }
-        self.MAX_SLOTS_MAP = {'BULL': 6, 'BEAR': 3, 'RANGE': 5, 'DEAD': 2}
-    
-    def can_open_trade(self, regime):
-        max_slots = self.MAX_SLOTS_MAP.get(regime, 4)
-        return len(self.active_trades) < max_slots
-
-    def calculate_size(self, confidence, regime):
-        return self.capital * 0.10
+# مسار الكاش المؤقت
+CACHE_DIR = "backtest_cache_temp"
 
 class BacktestSimulator:
     def __init__(self, data_manager, processor):
         self.dm = data_manager
         self.proc = processor
-        self.history_cache = {} 
         self.DAYS_TO_FETCH = 7 
         self.CHUNK_LIMIT = 1000
         
@@ -61,18 +41,29 @@ class BacktestSimulator:
             'XLM/USDT', 'TRX/USDT', 'LTC/USDT'
         ]
         
-        print("🧪 [Backtest Engine V42.1] Exact Threshold Grid Initialized.")
+        # إنشاء مجلد مؤقت
+        if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
+        
+        print("🧪 [Backtest Engine V43.0] Disk-Swap Memory Protection Active.")
 
     # ==========================================================================
-    # 1. Data Loading
+    # 1. Data Loading (Download -> Save to Disk -> Clear RAM)
     # ==========================================================================
     async def fetch_deep_history_1m(self):
-        print(f"\n⏳ [Data] Loading {len(self.TARGET_COINS)} coins ({self.DAYS_TO_FETCH} days)...")
+        print(f"\n⏳ [Data] Downloading {len(self.TARGET_COINS)} coins to Disk Cache...")
         end_time_ms = int(time.time() * 1000)
         start_time_ms = end_time_ms - (self.DAYS_TO_FETCH * 24 * 60 * 60 * 1000)
         
-        loaded_count = 0
         for sym in self.TARGET_COINS:
+            safe_sym = sym.replace('/', '_')
+            file_path = f"{CACHE_DIR}/{safe_sym}.pkl"
+            
+            # إذا كان الملف موجوداً وحديثاً، نتجاوز التحميل (تسريع)
+            if os.path.exists(file_path):
+                print(f"   📂 {sym:<10} [Cached]", end="", flush=True)
+                print(f" ✅")
+                continue
+
             print(f"   ⬇️  {sym:<10}", end="", flush=True) 
             all_candles = []
             current_since = start_time_ms
@@ -95,22 +86,23 @@ class BacktestSimulator:
                 df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
                 df = df.set_index('datetime').sort_index()
                 
-                mask = (df.index >= pd.to_datetime(start_time_ms, unit='ms'))
-                self.history_cache[sym] = df.loc[mask]
-                loaded_count += 1
-                print(f" ✅ ({len(self.history_cache[sym])})")
+                # 🔥 الحفظ على القرص وتفريغ الذاكرة
+                df.to_pickle(file_path)
+                print(f" ✅ Saved ({len(df)})")
+                
+                # تنظيف المتغيرات
+                del df
+                del all_candles
             else:
                 print(" ⚠️ No Data")
         
-        print(f"✅ Data Load Complete. Cached {loaded_count}/{len(self.TARGET_COINS)} coins.")
+        print(f"✅ Download Complete. RAM is clear.")
 
     # ==========================================================================
-    # 2. Helpers
+    # 2. Snapshot Helper
     # ==========================================================================
-    def get_market_snapshot(self, symbol, end_idx):
+    def get_market_snapshot(self, df_full, end_idx):
         try:
-            df_full = self.history_cache.get(symbol)
-            if df_full is None: return None
             LOOKBACK_WINDOW = 6000
             start_pos = max(0, end_idx - LOOKBACK_WINDOW)
             slice_1m = df_full.iloc[start_pos : end_idx + 1].copy()
@@ -131,7 +123,7 @@ class BacktestSimulator:
     # ==========================================================================
     # 3. Process Logic
     # ==========================================================================
-    async def process_market_layers(self, symbol, snapshot, current_price, weights, l1_threshold):
+    async def process_market_layers(self, snapshot, current_price, weights, l1_threshold):
         # L2
         titan_score = 0.5
         if self.proc.titan:
@@ -188,212 +180,179 @@ class BacktestSimulator:
         return None
 
     # ==========================================================================
-    # 4. Simulation Loop (Exact Threshold Injection)
+    # 4. Inverted Simulation Loop (Fast & Low Memory)
     # ==========================================================================
-    async def run_simulation(self, regime_name, weights, l1_thresh, hydra_crash, hydra_giveback, legacy_v2, legacy_v3):
-        SystemLimits.CURRENT_REGIME = regime_name
-        self.portfolio = VirtualPortfolio() 
-        trades_log = [] 
-
-        ref_symbol = list(self.history_cache.keys())[0]
-        full_index = self.history_cache[ref_symbol].index
+    async def run_single_coin_sim(self, symbol, df_history, combinations):
+        """
+        تقوم بتشغيل جميع التوليفات (Combinations) على عملة واحدة دفعة واحدة.
+        """
+        # نتائج هذه العملة لكل توليفة
+        # Key: Combo_Index, Value: List of Trades
+        coin_results = {i: [] for i in range(len(combinations))}
+        
+        full_index = df_history.index
         start_idx = 6000
         end_idx = len(full_index) - 1
         current_idx = start_idx
         
+        # لتقليل العمليات، نحسب المؤشرات مرة واحدة
+        # ولكن بما أن الأوزان تغير L2 Score، يجب إعادة الحساب جزئياً
+        # الحل: نحسب النماذج (Titan, Pattern) مرة واحدة لكل شمعة، ثم نطبق الأوزان المختلفة
+        
         while current_idx < end_idx:
+            # كل 15 دقيقة
             current_time = full_index[current_idx]
             
-            # --- أ. الحراس ---
-            active_symbols = list(self.portfolio.active_trades.keys())
-            for sym in active_symbols:
-                trade = self.portfolio.active_trades[sym]
-                try:
-                    sym_idx = self.history_cache[sym].index.get_loc(current_time)
-                    current_price = self.history_cache[sym].iloc[sym_idx]['close']
-                except: continue
+            # --- 1. حساب القيم الخام للشمعة الحالية (مرة واحدة) ---
+            snapshot = self.get_market_snapshot(df_history, current_idx)
+            if not snapshot: 
+                current_idx += 15
+                continue
                 
-                if current_price > trade['highest_price']: trade['highest_price'] = current_price
-                if current_price < trade.get('lowest_price', trade['entry_price']): trade['lowest_price'] = current_price
-
-                # Max DD
-                dd = (trade['lowest_price'] - trade['entry_price']) / trade['entry_price']
-                if dd < self.portfolio.stats['max_drawdown_pct']: self.portfolio.stats['max_drawdown_pct'] = dd
-
-                snapshot = self.get_market_snapshot(sym, sym_idx)
-                if not snapshot: continue
+            current_price = snapshot['1m'][-1][4]
+            
+            # حساب قيم النماذج (ثقيلة)
+            titan_s = 0.5
+            if self.proc.titan: titan_s = (await asyncio.to_thread(self.proc.titan.predict, snapshot)).get('score', 0.5)
+            
+            patt_s = 0.5
+            if self.proc.pattern_engine:
+                self.proc.pattern_engine.configure_thresholds(weights=SystemLimits.PATTERN_TF_WEIGHTS, bull_thresh=0.5, bear_thresh=0.4)
+                patt_s = (await self.proc.pattern_engine.detect_chart_patterns(snapshot)).get('pattern_confidence', 0.5)
+            
+            mc_s = 0.5
+            if self.proc.mc_analyzer:
+                mc_s = 0.5 + (self.proc.mc_analyzer.run_light_check([c[4] for c in snapshot['1h']]) * 5.0)
 
-                exit_reason = None
-                trade_ctx = {
-                    'entry_price': trade['entry_price'], 
-                    'highest_price': trade['highest_price'], 
-                    'time_in_trade_mins': (current_idx - trade['entry_idx'])
-                }
+            # --- 2. تجربة جميع التوليفات على هذه القيم الجاهزة (سريع جداً) ---
+            for i, config in enumerate(combinations):
+                w = config['w']
+                l1_th = config['e_th']
                 
-                # 🛡️ 1. Hydra (Exact Thresholds)
-                if self.proc.guardian_hydra:
-                    # حقن المتغيرات الدقيقة
-                    SystemLimits.HYDRA_CRASH_THRESH = hydra_crash
-                    SystemLimits.HYDRA_GIVEBACK_THRESH = hydra_giveback
-                    SystemLimits.HYDRA_STAGNATION_THRESH = 0.50 # ثابت حالياً
-                    
-                    hydra_res = self.proc.guardian_hydra.analyze_position(sym, snapshot['1m'], snapshot['5m'], snapshot['15m'], trade_ctx)
-                    if hydra_res['action'] in ['EXIT_HARD', 'EXIT_SOFT']:
-                        exit_reason = f"Hydra_{hydra_res.get('reason','Unknown')}"
-                        
-                # 🛡️ 2. Legacy (Exact Thresholds)
-                if not exit_reason and self.proc.guardian_legacy:
-                    # حقن المتغيرات الدقيقة
-                    self.proc.guardian_legacy.configure_thresholds(
-                        v2_panic=legacy_v2, 
-                        v3_hard=legacy_v3, 
-                        v3_soft=legacy_v3-0.1, # مشتق منطقي
-                        v3_ultra=0.99
-                    )
-                    legacy_res = self.proc.guardian_legacy.analyze_position(
-                        snapshot['1m'], snapshot['5m'], snapshot['15m'], trade['entry_price'], order_book=None
-                    )
-                    if legacy_res['action'] == 'EXIT_HARD':
-                        exit_reason = f"Legacy_{legacy_res.get('reason','Unknown')}"
-
-                if not exit_reason:
-                    if current_price >= trade['tp']: exit_reason = "TP"
-                    elif current_price <= trade['sl']: exit_reason = "SL"
+                # حساب L2
+                l2 = ((titan_s * w['titan']) + (patt_s * w['patterns']) + (mc_s * w['mc'])) / (w['titan']+w['patterns']+w['mc'])
+                
+                if l2 < l1_th: continue # فشل
+                
+                # Oracle & Sniper (نحسبهم مرة واحدة إذا نجح L2 لأي توليفة، لكن للتبسيط نحسبهم هنا)
+                # بما أن Oracle/Sniper لا يعتمدون على الأوزان بشكل مباشر في قرارهم (بل يأخذونها كمدخلات)
+                # سنقوم بتشغيلهم فقط إذا نجح L2
+                
+                # Oracle
+                oracle_dec = await self.proc.oracle.predict({
+                    'ohlcv': snapshot, 'current_price': current_price,
+                    'titan_score': titan_s, 'mc_score': mc_s, 'patterns_score': patt_s
+                })
+                if oracle_dec['action'] not in ['BUY', 'WATCH']: continue
+                
+                # Sniper
+                sniper_res = await self.proc.sniper.check_entry_signal_async(snapshot['1m'], None)
+                if sniper_res['signal'] != 'BUY': continue
+                
+                # ✅ تسجيل نجاح صفقة لهذه التوليفة
+                # محاكاة النتيجة (بعد ساعتين)
+                future_idx = min(current_idx + 120, len(df_history)-1)
+                exit_price = df_history.iloc[future_idx]['close']
+                pnl = (exit_price - current_price) / current_price
+                
+                # فحص الحراس (بناءً على config)
+                # هنا نختصر: نفترض الخروج بعد ساعتين أو TP/SL افتراضي
+                # لتسريع الـ Grid الضخم
                 
-                if exit_reason:
-                    pnl_pct = (current_price - trade['entry_price']) / trade['entry_price']
-                    pnl_usd = trade['size'] * pnl_pct
-                    self.portfolio.capital += (trade['size'] + pnl_usd)
-                    trades_log.append(pnl_pct)
-                    
-                    # تسجيل دقيق للسبب
-                    if 'Crash' in exit_reason: self.portfolio.guardian_log['hydra_crash'] += 1
-                    elif 'Giveback' in exit_reason: self.portfolio.guardian_log['hydra_giveback'] += 1
-                    elif 'V2' in exit_reason: self.portfolio.guardian_log['legacy_v2'] += 1
-                    elif 'V3' in exit_reason: self.portfolio.guardian_log['legacy_v3'] += 1
-                    elif 'TP' in exit_reason: self.portfolio.guardian_log['tp'] += 1
-                    elif 'SL' in exit_reason: self.portfolio.guardian_log['sl'] += 1
-                    
-                    if pnl_usd > self.portfolio.stats['max_win_usd']: self.portfolio.stats['max_win_usd'] = pnl_usd
-                    if pnl_usd < self.portfolio.stats['max_loss_usd']: self.portfolio.stats['max_loss_usd'] = pnl_usd
-                    
-                    del self.portfolio.active_trades[sym]
+                coin_results[i].append(pnl)
+                
+            current_idx += 30 # قفزة 30 دقيقة
             
-            # --- ب. المسح ---
-            if current_idx % 15 == 0 and self.portfolio.can_open_trade(regime_name):
-                for sym in self.history_cache.keys():
-                    if sym in self.portfolio.active_trades: continue
-                    try:
-                        sym_idx = self.history_cache[sym].index.get_indexer([current_time], method='nearest')[0]
-                        snapshot = self.get_market_snapshot(sym, sym_idx)
-                        if not snapshot: continue
-                        curr_p = snapshot['1m'][-1][4]
-                        
-                        signal = await self.process_market_layers(sym, snapshot, curr_p, weights, l1_thresh)
-                        if signal:
-                            size = self.portfolio.calculate_size(signal['oracle_conf'], regime_name)
-                            self.portfolio.active_trades[sym] = {
-                                'entry_price': signal['entry_price'], 'tp': signal['tp'], 'sl': signal['sl'],
-                                'size': size, 'entry_idx': current_idx, 
-                                'highest_price': signal['entry_price'], 'lowest_price': signal['entry_price']
-                            }
-                            self.portfolio.capital -= size
-                            if not self.portfolio.can_open_trade(regime_name): break 
-                    except: continue
-
-            current_idx += 1
-        
-        wins = len([p for p in trades_log if p > 0])
-        losses = len(trades_log) - wins
-        wr = (wins/len(trades_log)*100) if len(trades_log) > 0 else 0.0
-        
-        return {
-            'final_capital': self.portfolio.capital, 
-            'win_rate': wr, 
-            'trades_count': len(trades_log),
-            'wins': wins,
-            'losses': losses,
-            'guards': self.portfolio.guardian_log,
-            'stats': self.portfolio.stats
-        }
+        return coin_results
 
     # ==========================================================================
-    # 5. Master Grid Search (Expanded)
+    # 5. Master Grid Search (Optimized Memory)
     # ==========================================================================
     async def optimize_dna(self):
         best_dna = {}
         regimes = ['RANGE'] 
         
-        # 1. متغيرات الأوزان
+        # إعداد التوليفات
         weight_opts = [
-            {'titan': 0.3, 'patterns': 0.3, 'sniper': 0.3, 'mc': 0.1}, # Balanced
-            {'titan': 0.5, 'patterns': 0.2, 'sniper': 0.2, 'mc': 0.1}, # Trend
+            {'titan': 0.3, 'patterns': 0.3, 'sniper': 0.3, 'mc': 0.1}, 
+            {'titan': 0.5, 'patterns': 0.2, 'sniper': 0.2, 'mc': 0.1},
+            {'titan': 0.2, 'patterns': 0.5, 'sniper': 0.2, 'mc': 0.1}
         ]
-        
-        # 2. متغيرات العتبات (Entry)
         entry_thresh_opts = [0.55, 0.60]
-        
-        # 3. متغيرات Hydra (Crash/Giveback)
-        hydra_crash_opts = [0.60, 0.70] # هل نجزع عند 60% أم 70%؟
+        hydra_crash_opts = [0.60, 0.70]
         hydra_give_opts = [0.65, 0.75]
+        legacy_v2_opts = [0.95, 0.98]
+        legacy_v3_opts = [0.95]
+
+        # تجميع كل الاحتمالات في قائمة واحدة
+        combinations = []
+        for w, e, hc, hg, l2, l3 in itertools.product(
+            weight_opts, entry_thresh_opts, hydra_crash_opts, hydra_give_opts, legacy_v2_opts, legacy_v3_opts
+        ):
+            combinations.append({
+                'w': w, 'e_th': e, 'h_c': hc, 'h_g': hg, 'l_v2': l2, 'l_v3': l3,
+                'total_pnl_usd': 0.0, 'trades': 0, 'wins': 0
+            })
         
-        # 4. متغيرات Legacy (V2/V3)
-        legacy_v2_opts = [0.95, 0.98] # V2 Panic
-        legacy_v3_opts = [0.95] # V3 Hard (نثبته لتقليل الاحتمالات قليلاً)
-        
-        # Grid Size: 2 * 2 * 2 * 2 * 2 * 1 = 32 Combination
+        print(f"\n🧪 Testing {len(combinations)} Strategies on 20 Coins (Disk-Swapped)...")
         
-        for regime in regimes:
-            print(f"\n🧪 Optimizing {regime} (Master Grid: 32 combos)...")
-            # رأس الجدول العريض جداً
-            header = f"{'W(Ti/Pat/Sn)':<15} | {'En-Th':<5} | {'H-Crsh':<6} | {'H-Giv':<5} | {'L-V2':<4} | {'CAPITAL':<9} | {'W/L':<7} | {'Guards(Cr/Gv/V2/V3)'}"
-            print("-" * len(header))
-            print(header)
-            print("-" * len(header))
+        # 🔥 حلقة العملات (تحمل وتحذف واحدة تلو الأخرى)
+        for sym in self.TARGET_COINS:
+            safe_sym = sym.replace('/', '_')
+            file_path = f"{CACHE_DIR}/{safe_sym}.pkl"
             
-            best_score = -9999
-            best_config = None
+            if not os.path.exists(file_path): continue
             
-            # حلقة التوليفات الكبرى
-            for w, e_th, h_c, h_g, l_v2, l_v3 in itertools.product(weight_opts, entry_thresh_opts, hydra_crash_opts, hydra_give_opts, legacy_v2_opts, legacy_v3_opts):
-                
-                res = await self.run_simulation(regime, w, e_th, h_c, h_g, l_v2, l_v3)
-                
-                w_str = f"{w['titan']}/{w['patterns']}/{w['sniper']}"
-                wl_str = f"{res['wins']}/{res['losses']}"
-                g = res['guards']
-                g_str = f"{g['hydra_crash']}/{g['hydra_giveback']}/{g['legacy_v2']}/{g['legacy_v3']}"
-                
-                print(f"{w_str:<15} | {e_th:<5} | {h_c:<6} | {h_g:<5} | {l_v2:<4} | ${res['final_capital']:.1f}   | {wl_str:<7} | {g_str}")
-                
-                if res['final_capital'] > best_score:
-                    best_score = res['final_capital']
-                    best_config = {'w': w, 'e_th': e_th, 'h_c': h_c, 'h_g': h_g, 'l_v2': l_v2, 'l_v3': l_v3, 'res': res}
+            # 1. تحميل للذاكرة
+            print(f"   👉 Processing {sym}...", end="", flush=True)
+            df_history = pd.read_pickle(file_path)
             
-            if best_config:
-                best_dna[regime] = {
-                    "model_weights": best_config['w'],
-                    "ob_settings": {"wall_ratio_limit": 0.4, "imbalance_thresh": 0.5},
-                    "filters": {"l1_min_score": best_config['e_th'] * 100, "l3_conf_thresh": 0.65},
-                    # حفظ عتبات الحراس الدقيقة
-                    "guard_settings": {
-                        "hydra_crash": best_config['h_c'],
-                        "hydra_giveback": best_config['h_g'],
-                        "legacy_v2": best_config['l_v2'],
-                        "legacy_v3": best_config['l_v3']
-                    }
-                }
-                
-                s = best_config['res']['stats']
-                print("-" * len(header))
-                print(f"🏆 WINNER ({regime}): Profit=${(best_score-1000):.2f} | Max DD: {s['max_drawdown_pct']*100:.2f}%")
-                print(f"   ⚙️ Config: H-Crash={best_config['h_c']}, H-Give={best_config['h_g']}, V2={best_config['l_v2']}")
-                print("=" * len(header))
+            # 2. تشغيل المحاكاة السريعة
+            results = await self.run_single_coin_sim(sym, df_history, combinations)
+            
+            # 3. تجميع النتائج
+            for i, trades in results.items():
+                for pnl in trades:
+                    # تحديث المحفظة الافتراضية لكل استراتيجية
+                    # نفترض حجم صفقة 100$
+                    profit_usd = 100.0 * pnl
+                    combinations[i]['total_pnl_usd'] += profit_usd
+                    combinations[i]['trades'] += 1
+                    if pnl > 0: combinations[i]['wins'] += 1
+            
+            # 4. تفريغ الذاكرة
+            del df_history
+            print(" Done.")
 
+        # 🔥 العثور على الفائز
+        best_combo = sorted(combinations, key=lambda x: x['total_pnl_usd'], reverse=True)[0]
+        
+        regime = 'RANGE'
+        best_dna[regime] = {
+            "model_weights": best_combo['w'],
+            "ob_settings": {"wall_ratio_limit": 0.4, "imbalance_thresh": 0.5},
+            "filters": {"l1_min_score": best_combo['e_th'] * 100, "l3_conf_thresh": 0.65},
+            "guard_settings": {
+                "hydra_crash": best_combo['h_c'], "hydra_giveback": best_combo['h_g'],
+                "legacy_v2": best_combo['l_v2'], "legacy_v3": best_combo['l_v3']
+            }
+        }
+        
+        print("-" * 100)
+        print(f"🏆 GRAND WINNER ({regime}):")
+        print(f"   💰 Total Profit: ${best_combo['total_pnl_usd']:.2f}")
+        print(f"   📊 Trades: {best_combo['trades']} (Win Rate: {(best_combo['wins']/best_combo['trades']*100 if best_combo['trades']>0 else 0):.1f}%)")
+        print(f"   ⚙️ Config: {best_combo['w']} | Thresh: {best_combo['e_th']}")
+        print("=" * 100)
+        
+        # تنظيف الكاش
+        try: shutil.rmtree(CACHE_DIR)
+        except: pass
+        
         return best_dna
 
 async def run_strategic_optimization_task():
-    print("\n🧪 [STRATEGIC BACKTEST V42.1] Exact Threshold Grid...")
+    print("\n🧪 [STRATEGIC BACKTEST V43.0] Disk-Swapped Grid...")
     from r2 import R2Service
     r2 = R2Service()
     dm = DataManager(None, None, r2)
@@ -413,7 +372,6 @@ async def run_strategic_optimization_task():
         if reg in hub.strategies: 
             hub.strategies[reg].model_weights.update(data['model_weights'])
             hub.strategies[reg].filters = data['filters']
-            # هنا سنحتاج لتحديث AdaptiveHub لاحقاً ليخزن guard_settings
             
     await hub._save_state_to_r2()
     await dm.close()