Update app.py

app.py

@@ -1,814 +1,290 @@
-# ==============================================================================
-# 🚀 app.py (V36.3 - GEM-Architect: Neural Dashboard)
-# ==============================================================================
+# ============================================================
+# 🗓️ periodic_tuner.py (V4.2 - GEM-Architect: Status Metrics)
+# ============================================================
 
-import os
-import sys
-import traceback
 import asyncio
-import gc
+import numpy as np
+import pandas as pd
+import pandas_ta as ta
 import time
+import logging
+import argparse
 import json
-import logging 
 from datetime import datetime, timedelta
-from contextlib import asynccontextmanager, redirect_stdout, redirect_stderr
-from io import StringIO
-from typing import List, Dict, Any, Optional
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-import gradio as gr
-import pandas as pd
-import plotly.graph_objects as go 
+# استيراد محركات النظام
+from backtest_engine import HeavyDutyBacktester
+from ml_engine.data_manager import DataManager
+from ml_engine.processor import MLProcessor
+from learning_hub.adaptive_hub import AdaptiveHub
+from r2 import R2Service
+
+# ============================================================
+# 💎 THE GOLDEN LIST (52 Strategic Assets)
+# ============================================================
+STRATEGIC_COINS = [
+    'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT', 'LINK/USDT',
+    'TON/USDT', 'INJ/USDT', 'APT/USDT', 'OP/USDT', 'ARB/USDT', 'SUI/USDT',
+    'SEI/USDT', 'MINA/USDT', 'MATIC/USDT', 'NEAR/USDT', 'RUNE/USDT', 'API3/USDT',
+    'FLOKI/USDT', 'BABYDOGE/USDT', 'SHIB/USDT', 'TRX/USDT', 'DOT/USDT', 'UNI/USDT',
+    'ONDO/USDT', 'SNX/USDT', 'HBAR/USDT', 'XLM/USDT', 'AGIX/USDT', 'IMX/USDT',
+    'LRC/USDT', 'KCS/USDT', 'ICP/USDT', 'SAND/USDT', 'AXS/USDT', 'APE/USDT',
+    'GMT/USDT', 'CHZ/USDT', 'CFX/USDT', 'LDO/USDT', 'FET/USDT', 'RPL/USDT',
+    'MNT/USDT', 'RAY/USDT', 'CAKE/USDT', 'SRM/USDT', 'PENDLE/USDT', 'ATOM/USDT'
+]
 
-# ------------------------------------------------------------------------------
-# Logging Setup
-# ------------------------------------------------------------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(levelname)s] %(message)s", 
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
 logger = logging.getLogger("TitanCore")
 
-# ------------------------------------------------------------------------------
-# Imports
-# ------------------------------------------------------------------------------
-try:
-    from r2 import R2Service, INITIAL_CAPITAL 
-    from ml_engine.data_manager import DataManager
-    from ml_engine.processor import MLProcessor, SystemLimits 
-    from whale_monitor.core import EnhancedWhaleMonitor
-    from whale_monitor.rpc_manager import AdaptiveRpcManager
-    from sentiment_news import NewsFetcher
-    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-    from learning_hub.adaptive_hub import AdaptiveHub
-    from trade_manager import TradeManager
-    from periodic_tuner import AutoTunerScheduler
-    
-    # محاولة استيراد محرك الباكتست (اختياري للتشغيل عبر الواجهة)
+# ============================================================
+# 👁️ MARKET SENSOR V3.2
+# ============================================================
+async def detect_dominant_regime(dm: DataManager, days_back=7):
     try:
-        from backtest_engine import run_strategic_optimization_task
-        BACKTEST_AVAILABLE = True
-    except ImportError:
-        BACKTEST_AVAILABLE = False
-        
-except ImportError as e:
-    logger.critical(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# ------------------------------------------------------------------------------
-# Global Context
-# ------------------------------------------------------------------------------
-r2: R2Service = None
-data_manager: DataManager = None
-ml_processor: MLProcessor = None
-adaptive_hub: AdaptiveHub = None  
-trade_manager: TradeManager = None
-whale_monitor: EnhancedWhaleMonitor = None
-news_fetcher: NewsFetcher = None
-senti_analyzer: SentimentIntensityAnalyzer = None
-sys_state: 'SystemState' = None
-scheduler: AutoTunerScheduler = None
-
-# ------------------------------------------------------------------------------
-# State Management
-# ------------------------------------------------------------------------------
-class SystemState:
-    def __init__(self):
-        self.ready = False
-        self.cycle_running = False
-        self.training_running = False 
-        self.auto_pilot = True 
-        
-        self.last_cycle_time: datetime = None
-        self.last_cycle_error = None
-        self.app_start_time = datetime.now()
-        
-        self.last_cycle_logs = "System Initializing..."
-        self.training_status_msg = "Adaptive Mode: Active" 
-        
-        self.scan_interval = 60 
-
-    def set_ready(self): 
-        self.ready = True
-        self.last_cycle_logs = "✅ System Ready. Cybernetic Loop ON."
-        logger.info("✅ System State set to READY.")
-    
-    def set_cycle_start(self): 
-        self.cycle_running = True
-        self.last_cycle_logs = "🌀 [Cycle START] Scanning Markets..."
-        logger.info("🌀 Cycle STARTED.")
-
-    def set_cycle_end(self, error=None, logs=None):
-        self.cycle_running = False
-        self.last_cycle_time = datetime.now()
-        self.last_cycle_error = str(error) if error else None
-        
-        if logs: 
-            self.last_cycle_logs = logs
-        elif error:
-            self.last_cycle_logs = f"❌ [Cycle ERROR] {error}"
-            logger.error(f"Cycle Error: {error}")
-        else:
-            self.last_cycle_logs = f"✅ [Cycle END] Finished successfully."
-            logger.info("✅ Cycle ENDED.")
-
-sys_state = SystemState()
-
-# ------------------------------------------------------------------------------
-# Utilities
-# ------------------------------------------------------------------------------
-def format_crypto_price(price):
-    if price is None: return "0.0"
-    try:
-        p = float(price)
-        if p == 0: return "0.0"
-        return "{:.8f}".format(p).rstrip('0').rstrip('.')
-    except: return str(price)
-
-def calculate_duration_str(timestamp_str):
-    if not timestamp_str: return "--:--:--"
-    try:
-        if isinstance(timestamp_str, str):
-            start_time = datetime.fromisoformat(timestamp_str)
-        else: start_time = timestamp_str
-        
-        diff = datetime.now() - start_time
-        total_seconds = int(diff.total_seconds())
-        
-        days = total_seconds // 86400
-        hours = (total_seconds % 86400) // 3600
-        minutes = (total_seconds % 3600) // 60
-        seconds = total_seconds % 60
-        
-        if days > 0: return f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
-        return f"{hours:02}:{minutes:02}:{seconds:02}"
-    except: return "--:--:--"
-
-# ------------------------------------------------------------------------------
-# Auto-Pilot Daemon
-# ------------------------------------------------------------------------------
-async def auto_pilot_loop():
-    logger.info("🤖 [Auto-Pilot] Daemon started.")
-    while True:
-        try:
-            await asyncio.sleep(5) 
-            if not sys_state.ready: continue
+        required_limit = 200 + days_back + 10 
+        logger.info(f"👁️ [Market Sensor] Analyzing Dominant Regime (Last {days_back} days)...")
+        
+        candles = await dm.exchange.fetch_ohlcv('BTC/USDT', '1d', limit=required_limit)
+        if not candles or len(candles) < 200: return "RANGE"
+        
+        df = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        close = df['close']
+        df['sma50'] = ta.sma(close, length=50)
+        df['sma200'] = ta.sma(close, length=200)
+        adx_df = ta.adx(df['high'], df['low'], close, length=14)
+        if adx_df is not None: df['adx'] = adx_df.iloc[:, 0]
+        else: df['adx'] = 0.0
+        df['vol_sma'] = df['volume'].rolling(30).mean()
+
+        window_df = df.iloc[-days_back:].copy()
+        if window_df.empty: return "RANGE"
+
+        regime_counts = {"BULL": 0, "BEAR": 0, "RANGE": 0, "DEAD": 0}
+        for index, row in window_df.iterrows():
+            day_regime = "RANGE"
+            price = row['close']
+            sma = row['sma200']
+            adx = row['adx']
+            vol = row['volume']
+            vol_avg = row['vol_sma']
             
-            # تحديث حالة الـ Adaptive Hub في الواجهة كل دقيقة
-            if adaptive_hub and int(time.time()) % 60 == 0:
-                sys_state.training_status_msg = adaptive_hub.get_status()
-
-            # فحص الحراس (Watchdogs) للصفقات المفتوحة
-            if trade_manager and len(trade_manager.open_positions) > 0:
-                wd_status = await trade_manager.ensure_active_guardians()
-                if "No active" not in wd_status:
-                    if not sys_state.cycle_running:
-                        sys_state.last_cycle_logs = trade_manager.latest_guardian_log
-                continue 
-
-            # تشغيل دورة المسح (Cycle) إذا كان الطيار الآلي مفعلاً
-            if sys_state.auto_pilot and not sys_state.cycle_running and not sys_state.training_running:
-                if sys_state.last_cycle_time:
-                    elapsed = (datetime.now() - sys_state.last_cycle_time).total_seconds()
-                    if elapsed < sys_state.scan_interval: 
-                        continue
-
-                logger.info("🤖 [Auto-Pilot] Triggering scan...")
-                asyncio.create_task(run_unified_cycle())
-                await asyncio.sleep(5) 
-                    
-        except Exception as e:
-            logger.error(f"⚠️ [Auto-Pilot Error] {e}")
-            await asyncio.sleep(30)
-
-# ------------------------------------------------------------------------------
-# Lifespan
-# ------------------------------------------------------------------------------
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global r2, data_manager, ml_processor, adaptive_hub, trade_manager, whale_monitor, news_fetcher, senti_analyzer, sys_state, scheduler
-    
-    logger.info("\n🚀 [System] Startup Sequence (Titan V36.3 - Neural Dashboard)...")
-    try:
-        # 1. الخدمات الأساسية
-        r2 = R2Service()
-        data_manager = DataManager(contracts_db={}, whale_monitor=None, r2_service=r2)
-        await data_manager.initialize() 
-        await data_manager.load_contracts_from_r2()
-        
-        # 2. المراقبة والتحليل
-        whale_monitor = EnhancedWhaleMonitor(contracts_db=data_manager.get_contracts_db(), r2_service=r2)
-        rpc_mgr = AdaptiveRpcManager(data_manager.http_client)
-        whale_monitor.set_rpc_manager(rpc_mgr)
-        
-        news_fetcher = NewsFetcher()
-        senti_analyzer = SentimentIntensityAnalyzer()
-        data_manager.whale_monitor = whale_monitor
-        
-        # 3. العقل الاستراتيجي (Adaptive Hub)
-        adaptive_hub = AdaptiveHub(r2_service=r2)
-        await adaptive_hub.initialize()
-
-        # 4. المعالج العصبي (Processor)
-        ml_processor = MLProcessor(data_manager=data_manager)
-        await ml_processor.initialize()
-        
-        # 5. مدير التنفيذ (Trade Manager)
-        trade_manager = TradeManager(r2_service=r2, data_manager=data_manager, processor=ml_processor)
-        trade_manager.learning_hub = adaptive_hub 
-        
-        await trade_manager.initialize_sentry_exchanges()
-        await trade_manager.start_sentry_loops()
-        
-        # 6. المجدول التلقائي (Auto-Tuner Scheduler)
-        scheduler = AutoTunerScheduler(trade_manager)
-        asyncio.create_task(scheduler.start_loop())
-        logger.info("🕰️ [Scheduler] Auto-Tuner Background Task Started.")
-        
-        # 7. الجاهزية
-        sys_state.set_ready()
-        asyncio.create_task(auto_pilot_loop())
-        logger.info("✅ [System READY] All modules operational. Cybernetic Link Established.")
-        yield
-        
-    except Exception as e:
-        logger.critical(f"❌ [FATAL STARTUP ERROR] {e}")
-        traceback.print_exc()
-    finally:
-        sys_state.ready = False
-        if trade_manager: await trade_manager.stop_sentry_loops()
-        if data_manager: await data_manager.close()
-        if whale_monitor and whale_monitor.rpc_manager: await whale_monitor.rpc_manager.close()
-        logger.info("✅ [System] Shutdown Complete.")
-
-# ------------------------------------------------------------------------------
-# Helper Tasks
-# ------------------------------------------------------------------------------
-async def _analyze_symbol_task(symbol: str) -> Dict[str, Any]:
-    try:
-        required_tfs = ["5m", "15m", "1h", "4h"]
-        data_tasks = [data_manager.get_latest_ohlcv(symbol, tf, limit=300) for tf in required_tfs]
-        all_data = await asyncio.gather(*data_tasks)
-        
-        ohlcv_data = {}
-        for tf, data in zip(required_tfs, all_data):
-            if data and len(data) > 0: ohlcv_data[tf] = data
+            if pd.notna(vol_avg) and vol < (vol_avg * 0.4): day_regime = "DEAD"
+            elif pd.notna(sma) and price > sma: day_regime = "BULL" if adx > 25 else "RANGE"
+            elif pd.notna(sma) and price < sma: day_regime = "BEAR" if adx > 25 else "RANGE"
+            regime_counts[day_regime] += 1
             
-        if '1h' not in ohlcv_data or '5m' not in ohlcv_data: 
-            return None
-        
-        current_price = await data_manager.get_latest_price_async(symbol)
-        raw_data = {'symbol': symbol, 'ohlcv': ohlcv_data, 'current_price': current_price, 'timestamp': time.time()}
-        
-        res = await ml_processor.process_compound_signal(raw_data)
-        if not res: return None
-
-        return res
-    except Exception: return None
-
-# ------------------------------------------------------------------------------
-# Unified Cycle
-# ------------------------------------------------------------------------------
-async def run_unified_cycle():
-    log_buffer = StringIO()
-    def log_and_print(message):
-        logger.info(message)
-        log_buffer.write(message + '\n')
-
-    if sys_state.cycle_running or sys_state.training_running: return
-    if not sys_state.ready: return
-
-    sys_state.set_cycle_start()
-    
+        dominant_regime = max(regime_counts, key=regime_counts.get)
+        log_str = " | ".join([f"{k}:{v}" for k,v in regime_counts.items()])
+        logger.info(f"   👁️ Regime Distribution: [{log_str}] -> Winner: {dominant_regime}")
+        return dominant_regime
+    except Exception as e:
+        logger.error(f"⚠️ [Sensor Error] {e}")
+        return "RANGE"
+
+# ============================================================
+# 🩺 SURGICAL TUNER (Autonomous)
+# ============================================================
+async def run_surgical_tuning(period_type="weekly", use_fixed_list=True):
+    logger.info(f"🩺 [Auto-Tuner] Starting {period_type.upper()} optimization sequence...")
+    r2 = R2Service()
+    dm = DataManager(None, None, r2)
+    proc = MLProcessor(dm)
+    hub = AdaptiveHub(r2)
     try:
-        # LAYER 0: Guardian & Portfolio Check
-        await trade_manager.sync_internal_state_with_r2()
-        
-        if len(trade_manager.open_positions) > 0:
-            log_and_print(f"ℹ️ [Cycle] Active Positions: {len(trade_manager.open_positions)}")
-            for sym, tr in trade_manager.open_positions.items():
-                curr_p = await data_manager.get_latest_price_async(sym)
-                entry_p = float(tr.get('entry_price', 0))
-                pnl = ((curr_p - entry_p)/entry_p)*100 if entry_p > 0 else 0
-                log_and_print(f"   🔒 {sym}: {pnl:+.2f}%")
-
-        # LAYER 1: Adaptive Screening
-        current_regime = getattr(SystemLimits, 'CURRENT_REGIME', 'UNKNOWN')
-        log_and_print(f"   [1/5] 🔍 L1 Screening (Regime: {current_regime})...")
-        
-        candidates = await data_manager.layer1_rapid_screening()
-        if not candidates:
-            log_and_print("⚠️ No L1 candidates found for current regime.")
-            sys_state.set_cycle_end(logs=log_buffer.getvalue())
-            return
-            
-        # LAYER 2: Deep Analysis
-        log_and_print(f"   [2/5] 🧠 L2 Deep Analysis ({len(candidates)} items)...")
-        tasks = [_analyze_symbol_task(c['symbol']) for c in candidates]
-        results = await asyncio.gather(*tasks)
-        valid_l2 = [res for res in results if res is not None]
+        await dm.initialize(); await proc.initialize(); await hub.initialize()
+        
+        open_trades = await r2.get_open_trades_async()
+        if len(open_trades) > 0:
+            logger.warning("   ⛔ [Auto-Tuner] Aborted: Active trades present.")
+            return False
+
+        days_back = 7 if period_type == 'weekly' else 30
+        detected_regime = await detect_dominant_regime(dm, days_back=days_back)
+        hub.current_market_regime = detected_regime
+        asyncio.create_task(hub._save_state_to_r2()) 
+        
+        current_dna = hub.strategies.get(detected_regime)
+        if not current_dna: return False
+
+        tuning_coins = STRATEGIC_COINS if use_fixed_list else ['DOGE/USDT']
+        logger.info(f"   🌌 Universe: {len(tuning_coins)} Strategic Assets.")
+
+        opt = HeavyDutyBacktester(dm, proc)
+        opt.TARGET_COINS = tuning_coins 
+        
+        base_filters = current_dna.base_filters
+        base_guards = current_dna.base_guards
+        scan_range = 0.03 if period_type == 'weekly' else 0.05
+        steps = 3 
+        def create_micro_grid(center_val):
+            low = max(0.1, center_val - scan_range)
+            high = min(0.99, center_val + scan_range)
+            return np.linspace(low, high, steps)
+
+        opt.GRID_RANGES = {
+            'TITAN':  create_micro_grid(current_dna.model_weights.get('titan', 0.3)), 
+            'ORACLE': create_micro_grid(base_filters['l3_oracle_thresh']),
+            'SNIPER': create_micro_grid(base_filters['l4_sniper_thresh']),
+            'PATTERN': [0.1, 0.5], 'L1_SCORE': [10.0],
+            'HYDRA_CRASH': create_micro_grid(base_guards['hydra_crash']),
+            'HYDRA_GIVEBACK': create_micro_grid(base_guards['hydra_giveback']),
+            'LEGACY_V2': create_micro_grid(base_guards['legacy_v2']),
+        }
         
-        semi_finalists = sorted(valid_l2, key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)[:10]
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+        opt.set_date_range(start_date.strftime("%Y-%m-%d"), end_date.strftime("%Y-%m-%d"))
         
-        if not semi_finalists:
-            log_and_print("⚠️ No valid L2 candidates.")
-            sys_state.set_cycle_end(logs=log_buffer.getvalue())
-            return
-
-        # LAYER 3: Deep Dive (Contextual)
-        log_and_print(f"   [3/5] 📡 L3 Deep Dive (Whales & News) for TOP {len(semi_finalists)}...")
+        logger.info(f"   🚀 Optimizing for {detected_regime} (Last {days_back} days)...")
+        best_config, stats = await opt.run_optimization(detected_regime)
         
-        final_candidates = []
-
-        for sig in semi_finalists:
-            symbol = sig['symbol']
-            l2_score = sig.get('enhanced_final_score', 0.0)
-            
-            # Whale Check
-            whale_points = 0.0
-            try:
-                if whale_monitor:
-                    w_data = await whale_monitor.get_symbol_whale_activity(symbol, known_price=sig.get('current_price', 0))
-                    if w_data and w_data.get('data_available', False) and 'trading_signal' in w_data:
-                        signal = w_data['trading_signal']
-                        action = signal.get('action', 'HOLD')
-                        confidence = float(signal.get('confidence', 0.5))
-                        dynamic_impact = SystemLimits.L3_WHALE_IMPACT_MAX * confidence 
-                        if action == 'BUY': whale_points = dynamic_impact 
-                        elif action == 'SELL': whale_points = -dynamic_impact
-            except Exception: pass
-
-            # News Check
-            news_points = 0.0
-            try:
-                if news_fetcher and senti_analyzer:
-                    n_data = await news_fetcher.get_news(symbol)
-                    summary_text = n_data.get('summary', '')
-                    if "No specific news" not in summary_text:
-                        sent = senti_analyzer.polarity_scores(summary_text)
-                        compound_score = sent['compound']
-                        news_points = compound_score * SystemLimits.L3_NEWS_IMPACT_MAX
-            except Exception: pass
-
-            # MC Advanced
-            mc_a_points = 0.0
-            try:
-                raw_mc_a = await ml_processor.run_advanced_monte_carlo(symbol, '1h')
-                mc_a_points = max(-SystemLimits.L3_MC_ADVANCED_MAX, min(SystemLimits.L3_MC_ADVANCED_MAX, raw_mc_a))
-            except Exception: pass
-
-            final_score = l2_score + whale_points + news_points + mc_a_points
+        if best_config:
+            new_deltas = {}
+            new_deltas['l3_oracle_thresh'] = best_config.get('oracle_thresh') - base_filters['l3_oracle_thresh']
+            new_deltas['l4_sniper_thresh'] = best_config.get('sniper_thresh') - base_filters['l4_sniper_thresh']
+            new_deltas['hydra_crash'] = best_config.get('hydra_thresh') - base_guards['hydra_crash']
+            new_deltas['hydra_giveback'] = best_config.get('hydra_thresh') - base_guards['hydra_giveback']
+            new_deltas['legacy_v2'] = best_config.get('legacy_thresh') - base_guards['legacy_v2']
             
-            sig['whale_score'] = whale_points
-            sig['news_score'] = news_points
-            sig['mc_advanced_score'] = mc_a_points
-            sig['final_total_score'] = final_score 
-            
-            final_candidates.append(sig)
-
-        # RE-RANKING
-        final_candidates.sort(key=lambda x: x['final_total_score'], reverse=True)
-
-        approved_signals = []
-        
-        header = (f"{'SYM':<9} | {'L2(HYB)':<6} | {'TITAN':<5} | {'PATT':<5} | "
-                  f"{'WHALE':<6} | {'MC(A)':<6} | {'FINAL':<6} | {'ORACLE':<6} | {'STATUS'}")
-        log_and_print("-" * 110)
-        log_and_print(header)
-        log_and_print("-" * 110)
+            logger.info(f"   ✅ [Auto-Tuner] Success. Deltas: {new_deltas}")
+            hub.update_periodic_delta(detected_regime, period_type, new_deltas)
+            return True 
+        return False
         
-        for sig in final_candidates:
-            symbol = sig['symbol']
-            
-            decision = await ml_processor.consult_oracle(sig)
-            
-            action = decision.get('action', 'WAIT')
-            oracle_conf = decision.get('confidence', 0.0)
-            target_class = decision.get('target_class', '')
-            
-            status_str = "WAIT 🔴"
-            if action == 'WATCH' or action == 'BUY':
-                status_str = f"✅ {target_class}"
-                sig.update(decision)
-                approved_signals.append(sig)
-
-            l2_hybrid = sig.get('enhanced_final_score', 0.0)
-            titan_d = sig.get('titan_score', 0.0)
-            patt_d = sig.get('patterns_score', 0.0)
-            whale_d = sig.get('whale_score', 0.0)
-            mca_d = sig.get('mc_advanced_score', 0.0)
-            final_d = sig.get('final_total_score', 0.0)
-
-            log_and_print(
-                f"{symbol:<9} | "
-                f"{l2_hybrid:.2f}   | "
-                f"{titan_d:.2f}  | "
-                f"{patt_d:.2f}  | "
-                f"{whale_d:+.2f}  | " 
-                f"{mca_d:+.2f}  | " 
-                f"{final_d:.2f}   | " 
-                f"{oracle_conf:.2f}   | "
-                f"{status_str}"
-            )
-
-        # LAYER 4: Sniper Execution
-        if approved_signals:
-            log_and_print("-" * 110)
-            log_and_print(f"   [4/5] 🎯 L4 Sniper & Portfolio Check ({len(approved_signals)} candidates)...")
-            tm_log_buffer = StringIO()
-            
-            with redirect_stdout(tm_log_buffer), redirect_stderr(tm_log_buffer):
-                await trade_manager.select_and_execute_best_signal(approved_signals)
-            
-            tm_logs = tm_log_buffer.getvalue()
-            for line in tm_logs.splitlines():
-                if line.strip(): log_and_print(line.strip())
-        else:
-            log_and_print("   -> 🛑 No candidates approved by Oracle for Sniper check.")
-
-        gc.collect()
-        sys_state.set_cycle_end(logs=log_buffer.getvalue())
-
     except Exception as e:
-        logger.error(f"❌ [Cycle ERROR] {e}")
-        traceback.print_exc()
-        sys_state.set_cycle_end(error=e, logs=log_buffer.getvalue())
-
-# ------------------------------------------------------------------------------
-# Handlers
-# ------------------------------------------------------------------------------
-async def trigger_training_cycle():
-    if adaptive_hub:
-        status = adaptive_hub.get_status()
-        return f"🤖 Adaptive System: {status}"
-    return "⚠️ System not ready."
-
-async def trigger_strategic_backtest():
-    if not BACKTEST_AVAILABLE:
-        return "⚠️ Backtest Engine not found."
-    
-    if trade_manager and len(trade_manager.open_positions) > 0:
-        return "⛔ Cannot start Backtest: Active trades exist! Close them first."
-    
-    if sys_state.training_running:
-        return "⚠️ Training already in progress."
-        
-    async def _run_bg_task():
-        sys_state.training_running = True
-        sys_state.training_status_msg = "🧪 Strategic Backtest Running..."
+        logger.error(f"❌ [Auto-Tuner Error] {e}")
+        return False
+    finally:
+        await dm.close()
+
+# ============================================================
+# 🕰️ THE SCHEDULER CLASS (Persistent)
+# ============================================================
+class AutoTunerScheduler:
+    def __init__(self, trade_manager):
+        self.trade_manager = trade_manager
+        self.state_file = "scheduler_state.json"
+        
+        # التوقيتات
+        self.last_weekly_run = None
+        self.last_monthly_run = None
+        
+        # العدادات (Status Counters)
+        self.weekly_count = 0
+        self.monthly_count = 0
+        
+        self.is_running = False
+        logger.info("🕰️ [Scheduler] Auto-Tuner Armed & Ready.")
+
+    async def start_loop(self):
+        await self._load_state()
+        while True:
+            try:
+                await asyncio.sleep(3600) 
+                now = datetime.now()
+                
+                # WEEKLY (Monday 03:00 AM)
+                if now.weekday() == 0 and 3 <= now.hour < 4:
+                    if self._needs_run('weekly'): await self._try_run('weekly')
+
+                # MONTHLY (1st Day 04:00 AM)
+                if now.day == 1 and 4 <= now.hour < 5:
+                    if self._needs_run('monthly'): await self._try_run('monthly')
+                        
+            except Exception as e:
+                logger.error(f"⚠️ [Scheduler Loop Error] {e}")
+
+    async def _load_state(self):
         try:
-            logger.info("🧪 [Manual Trigger] Starting Strategic Backtest...")
-            await run_strategic_optimization_task()
-            if adaptive_hub: 
-                await adaptive_hub.initialize()
-            logger.info("✅ [Manual Trigger] Backtest Complete. DNA Updated.")
-        except Exception as e:
-            logger.error(f"❌ Backtest Failed: {e}")
-        finally:
-            sys_state.training_running = False
-            sys_state.training_status_msg = adaptive_hub.get_status() if adaptive_hub else "Ready"
-
-    asyncio.create_task(_run_bg_task())
-    return "🧪 Strategic Backtest Started (Safe Mode)."
-
-async def manual_close_current_trade():
-    if not trade_manager.open_positions: return "⚠️ No trade."
-    symbol = list(trade_manager.open_positions.keys())[0]
-    await trade_manager.force_exit_by_manager(symbol, reason="MANUAL_UI")
-    return f"✅ Closed {symbol}."
-
-async def reset_history_handler():
-    if trade_manager.open_positions: return "⚠️ Close active trades first."
-    current_state = await r2.get_portfolio_state_async()
-    preserved_capital = current_state.get('current_capital_usd', INITIAL_CAPITAL)
-    await r2.reset_all_stats_async()
-    if trade_manager and trade_manager.smart_portfolio:
-         sp = trade_manager.smart_portfolio
-         sp.state["current_capital"] = preserved_capital 
-         sp.state["session_start_balance"] = preserved_capital
-         sp.state["allocated_capital_usd"] = 0.0
-         sp.state["daily_net_pnl"] = 0.0
-         sp.state["is_trading_halted"] = False
-         await sp._save_state_to_r2()
-    return f"✅ History Cleared. Capital Preserved at ${preserved_capital:.2f}"
-
-async def reset_capital_handler():
-    if trade_manager.open_positions: return "⚠️ Close active trades first."
-    if trade_manager and trade_manager.smart_portfolio:
-         sp = trade_manager.smart_portfolio
-         sp.state["current_capital"] = INITIAL_CAPITAL 
-         sp.state["session_start_balance"] = INITIAL_CAPITAL
-         sp.state["allocated_capital_usd"] = 0.0
-         sp.state["daily_net_pnl"] = 0.0
-         sp.state["is_trading_halted"] = False
-         await sp._save_state_to_r2()
-    return f"✅ Capital Reset to ${INITIAL_CAPITAL} (History Kept)"
-
-async def toggle_auto_pilot(enable):
-    sys_state.auto_pilot = enable
-    return f"Auto-Pilot: {enable}"
-
-async def run_cycle_from_gradio():
-    if sys_state.cycle_running: return "Busy."
-    asyncio.create_task(run_unified_cycle())
-    return "🚀 Launched."
-
-# ------------------------------------------------------------------------------
-# UI Updates
-# ------------------------------------------------------------------------------
-async def check_live_pnl_and_status(selected_view="Dual-Core (Hybrid)"):
-    empty_chart = go.Figure()
-    empty_chart.update_layout(template="plotly_dark", paper_bgcolor="#0b0f19", plot_bgcolor="#0b0f19", xaxis={'visible':False}, yaxis={'visible':False})
-    wl_df_empty = pd.DataFrame(columns=["Coin", "Score"])
-    
-    if not sys_state.ready:
-        return "Initializing...", "...", empty_chart, "0.0", "0.0", "0.0", "0.0", "0.0%", wl_df_empty, "Loading...", "Loading...", "Loading..."
-
-    try:
-        sp = trade_manager.smart_portfolio
-        equity = sp.state.get('current_capital', 10.0) 
-        allocated = sp.state.get('allocated_capital_usd', 0.0)
-        free_cap = max(0.0, equity - allocated)
-        daily_pnl = sp.state.get('daily_net_pnl', 0.0)
-        is_halted = sp.state.get('is_trading_halted', False)
-        market_mood = sp.market_trend
-        fg_index = sp.fear_greed_index
-        
-        symbol = None; entry_p = 0.0; tp_p = 0.0; sl_p = 0.0; curr_p = 0.0; pnl_pct = 0.0; pnl_val_unrealized = 0.0
-        active_trade_info = ""
-        trade_dur_str = "--:--:--"
+            if self.trade_manager.r2:
+                data = await self.trade_manager.r2.get_file_async(self.state_file)
+                if data:
+                    state = json.loads(data)
+                    if state.get('last_weekly'):
+                        self.last_weekly_run = datetime.fromisoformat(state['last_weekly'])
+                    if state.get('last_monthly'):
+                        self.last_monthly_run = datetime.fromisoformat(state['last_monthly'])
+                    
+                    # استرجاع العدادات
+                    self.weekly_count = state.get('weekly_count', 0)
+                    self.monthly_count = state.get('monthly_count', 0)
+                    
+                    logger.info(f"   🕰️ [Scheduler] State Restored (W:{self.weekly_count} | M:{self.monthly_count}).")
+        except Exception: pass
 
-        if trade_manager.open_positions:
-            symbol = list(trade_manager.open_positions.keys())[0]
-            trade = trade_manager.open_positions[symbol]
-            entry_p = float(trade.get('entry_price', 0.0))
-            tp_p = float(trade.get('tp_price', 0.0))
-            sl_p = float(trade.get('sl_price', 0.0))
-            trade_dur_str = calculate_duration_str(trade.get('entry_time'))
-            sys_conf = trade.get('decision_data', {}).get('system_confidence', 0.0)
+    async def _save_state(self):
+        try:
+            state = {
+                "last_weekly": self.last_weekly_run.isoformat() if self.last_weekly_run else None,
+                "last_monthly": self.last_monthly_run.isoformat() if self.last_monthly_run else None,
+                "weekly_count": self.weekly_count,
+                "monthly_count": self.monthly_count
+            }
+            if self.trade_manager.r2:
+                await self.trade_manager.r2.upload_json_async(state, self.state_file)
+                logger.info("   💾 [Scheduler] State Saved.")
+        except Exception: pass
+
+    def _needs_run(self, period_type):
+        now = datetime.now()
+        if period_type == 'weekly':
+            if not self.last_weekly_run: return True
+            return (now - self.last_weekly_run).days >= 6
+        if period_type == 'monthly':
+            if not self.last_monthly_run: return True
+            return (now - self.last_monthly_run).days >= 25
+        return False
+
+    async def _try_run(self, period_type):
+        if len(self.trade_manager.open_positions) > 0:
+            logger.warning(f"⏳ [Scheduler] Postponing {period_type} run: Active trades present.")
+            return 
+
+        self.is_running = True
+        try:
+            # 1. Run Optimization (Isolated)
+            success = await run_surgical_tuning(period_type, use_fixed_list=True)
             
-            curr_p = await data_manager.get_latest_price_async(symbol)
-            if curr_p > 0 and entry_p > 0:
-                pnl_pct = ((curr_p - entry_p) / entry_p) * 100
-                size = float(trade.get('entry_capital', 0.0))
-                pnl_val_unrealized = size * (pnl_pct / 100)
+            if success:
+                # 2. Update Timestamps & Counters
+                if period_type == 'weekly': 
+                    self.last_weekly_run = datetime.now()
+                    self.weekly_count += 1
+                else: 
+                    self.last_monthly_run = datetime.now()
+                    self.monthly_count += 1
                 
-            active_trade_info = f"""
-             <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>⏱️ {symbol}:</span> <span style='color: #ffff00;'>{trade_dur_str}</span>
-             </div>
-             <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>🔮 Conf:</span> <span style='color: #00e5ff;'>{sys_conf:.1%}</span>
-             </div>
-            """
-
-        virtual_equity = equity + pnl_val_unrealized
-        active_trade_pnl_val = pnl_val_unrealized
-        active_pnl_color = "#00ff00" if active_trade_pnl_val >= 0 else "#ff0000"
-        portfolio = await r2.get_portfolio_state_async()
-        total_t = portfolio.get('total_trades', 0)
-        wins = portfolio.get('winning_trades', 0)
-        losses = portfolio.get('losing_trades', 0)
-        if losses == 0 and total_t > 0: losses = total_t - wins
-        tot_prof = portfolio.get('total_profit_usd', 0.0)
-        tot_loss = portfolio.get('total_loss_usd', 0.0)
-        net_prof = tot_prof - tot_loss
-        win_rate = (wins / total_t * 100) if total_t > 0 else 0.0
-        color = "#00ff00" if daily_pnl >= 0 else "#ff0000"
-        halt_status = "<span style='color:red; font-weight:bold;'>HALTED</span>" if is_halted else "<span style='color:#00ff00;'>ACTIVE</span>"
-        current_regime = getattr(SystemLimits, 'CURRENT_REGIME', 'N/A')
-
-        wallet_md = f"""
-        <div style='background-color: #1a1a1a; padding: 15px; border-radius: 8px; border: 1px solid #333; text-align:center;'>
-            <h3 style='margin:0; color:#888; font-size:14px;'>💼 Smart Portfolio</h3>
-            <div style='font-size: 24px; font-weight: bold; color: white; margin: 5px 0 0 0;'>${virtual_equity:,.2f}</div>
-            <div style='font-size: 14px; color: {active_pnl_color}; margin-bottom: 5px;'>({active_trade_pnl_val:+,.2f} USD)</div>
-            
-            <table style='width:100%; font-size:12px; margin-top:5px; color:#ccc;'>
-                <tr><td>Allocated:</td><td style='text-align:right; color:#ffa500;'>${allocated:.2f}</td></tr>
-                <tr><td>Free Cap:</td><td style='text-align:right; color:#00ff00;'>${free_cap:.2f}</td></tr>
-                <tr><td>Daily PnL:</td><td style='text-align:right; color:{color};'>${daily_pnl:+.2f}</td></tr>
-            </table>
-            
-            <hr style='border-color:#444; margin: 10px 0;'>
-            
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc;'>
-                <span>🦅 Market:</span> <span style='color: white;'>{market_mood} ({fg_index})</span>
-            </div>
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:3px;'>
-                <span>🧬 Regime:</span> <span style='color: #00e5ff; font-weight:bold;'>{current_regime}</span>
-            </div>
-            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
-                <span>🛡️ Status:</span> {halt_status}
-            </div>
-            {active_trade_info}
-        </div>
-        """
-
-        key_map = {
-            "Dual-Core (Hybrid)": "hybrid", 
-            "Hydra: Crash (Panic)": "crash", 
-            "Hydra: Giveback (Profit)": "giveback", 
-            "Hydra: Stagnation (Time)": "stagnation"
-        }
-        target_key = key_map.get(selected_view, "hybrid")
-        stats_data = trade_manager.ai_stats.get(target_key, {"total":0, "good":0, "saved":0.0, "missed":0.0})
-        
-        tot_ds = stats_data['total']
-        ds_acc = (stats_data['good'] / tot_ds * 100) if tot_ds > 0 else 0.0
-        
-        history_md = f"""
-        <div style='background-color: #1a1a1a; padding: 10px; border-radius: 8px; border: 1px solid #333; font-size: 12px;'>
-            <h3 style='margin:0 0 5px 0; color:#888; font-size:14px;'>📊 Performance</h3>
-            <table style='width:100%; color:white;'>
-                <tr><td>Trades:</td><td style='text-align:right;'>{total_t}</td></tr>
-                <tr><td>Win Rate:</td><td style='text-align:right; color:{"#00ff00" if win_rate>=50 else "#ff0000"};'>{win_rate:.1f}%</td></tr>
-                <tr><td>Wins:</td><td style='text-align:right; color:#00ff00;'>{wins} (+${tot_prof:,.2f})</td></tr>
-                <tr><td>Losses:</td><td style='text-align:right; color:#ff0000;'>{losses} (-${tot_loss:,.2f})</td></tr>
-                <tr><td style='border-top:1px solid #444;'>Net:</td><td style='border-top:1px solid #444; text-align:right; color:{"#00ff00" if net_prof>=0 else "#ff0000"};'>${net_prof:,.2f}</td></tr>
-            </table>
-            <hr style='border-color:#444; margin: 8px 0;'>
-            <h3 style='margin:0 0 5px 0; color: #00e5ff; font-size:14px;'>🛡️ Guard IQ ({target_key})</h3>
-            <table style='width:100%; color:white;'>
-                <tr><td>Interventions:</td><td style='text-align:right;'>{tot_ds}</td></tr>
-                <tr><td>Accuracy:</td><td style='text-align:right; color:#00e5ff;'>{ds_acc:.1f}%</td></tr>
-                <tr><td>Saved:</td><td style='text-align:right; color:#00ff00;'>${stats_data['saved']:.2f}</td></tr>
-                <tr><td>Missed:</td><td style='text-align:right; color:#ff0000;'>${stats_data['missed']:.2f}</td></tr>
-            </table>
-        </div>
-        """
-
-        # --- 🧠 Neural Cycles Status Construction ---
-        fast_learn_prog = "0/100"
-        if adaptive_hub:
-            if hasattr(adaptive_hub, 'get_learning_progress'):
-                fast_learn_prog = adaptive_hub.get_learning_progress()
-            else:
-                fast_learn_prog = "N/A"
-        
-        sch_w_time = "Wait"; sch_w_cnt = 0
-        sch_m_time = "Wait"; sch_m_cnt = 0
-        sch_running = False
-        
-        if scheduler:
-            metrics = scheduler.get_status_metrics()
-            sch_w_time = metrics["weekly_timer"]
-            sch_w_cnt = metrics["weekly_count"]
-            sch_m_time = metrics["monthly_timer"]
-            sch_m_cnt = metrics["monthly_count"]
-            sch_running = metrics["is_running"]
-
-        running_badge = "<span style='color:#00ff00; float:right; animation: blink 1s infinite;'>RUNNING ⚙️</span>" if sch_running else ""
-
-        neural_md = f"""
-        <div style='background-color: #1a1a1a; padding: 10px; border-radius: 8px; border: 1px solid #333; font-size: 12px; margin-top: 10px;'>
-            <div style='display:flex; justify-content:space-between; align-items:center; margin-bottom:5px;'>
-                <h3 style='margin:0; color:#00e5ff; font-size:14px;'>🧠 Neural Cycles</h3>
-                {running_badge}
-            </div>
-            <table style='width:100%; color:#ccc;'>
-                <tr style='border-bottom: 1px solid #333;'>
-                    <td style='padding:4px 0;'>⚡ Fast Learner:</td>
-                    <td style='text-align:right; color:#ffff00; font-weight:bold;'>{fast_learn_prog}</td>
-                    <td style='text-align:right; font-size:10px; color:#666;'>Trades</td>
-                </tr>
-                <tr style='border-bottom: 1px solid #333;'>
-                    <td style='padding:4px 0;'>📅 Weekly Tune:</td>
-                    <td style='text-align:right; color:#fff;'>{sch_w_time}</td>
-                    <td style='text-align:right; color:#00ff00;'>#{sch_w_cnt}</td>
-                </tr>
-                <tr>
-                    <td style='padding:4px 0;'>🗓️ Monthly Evo:</td>
-                    <td style='text-align:right; color:#fff;'>{sch_m_time}</td>
-                    <td style='text-align:right; color:#00ff00;'>#{sch_m_cnt}</td>
-                </tr>
-            </table>
-            <div style='margin-top:5px; font-size:10px; color:#555; text-align:center;'>
-                Adaptive DNA Active: {getattr(SystemLimits, 'CURRENT_REGIME', 'N/A')}
-            </div>
-        </div>
-        """
-
-        wl_data = [[k, f"{v.get('final_total_score',0):.2f}"] for k, v in trade_manager.watchlist.items()]
-        wl_df = pd.DataFrame(wl_data, columns=["Coin", "Score"])
-
-        status_txt = sys_state.last_cycle_logs
-        status_line = f"Cycle: {'RUNNING' if sys_state.cycle_running else 'IDLE'} | Auto-Pilot: {'ON' if sys_state.auto_pilot else 'OFF'}"
-        
-        fig = empty_chart
-        if symbol and curr_p > 0:
-            ohlcv = await data_manager.get_latest_ohlcv(symbol, '5m', 120)
-            if ohlcv:
-                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-                df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
-                fig = go.Figure(data=[go.Candlestick(
-                    x=df['datetime'], open=df['open'], high=df['high'], low=df['low'], close=df['close'],
-                    increasing_line_color='#00ff00', decreasing_line_color='#ff0000', name=symbol
-                )])
-                if entry_p > 0:
-                    fig.add_hline(y=entry_p, line_dash="dash", line_color="white", annotation_text="ENTRY", annotation_position="top left")
-                if tp_p > 0:
-                    fig.add_hline(y=tp_p, line_color="#00ff00", line_width=2, annotation_text="TARGET (TP)", annotation_position="top left")
-                if sl_p > 0:
-                    fig.add_hline(y=sl_p, line_color="#ff0000", line_width=2, annotation_text="STOP LOSS", annotation_position="bottom left")
-
-                fig.update_layout(
-                    template="plotly_dark", 
-                    paper_bgcolor="#0b0f19", 
-                    plot_bgcolor="#0b0f19",
-                    margin=dict(l=0, r=40, t=30, b=0), 
-                    height=400, 
-                    xaxis_rangeslider_visible=False,
-                    title=dict(text=f"{symbol} (Spot Long) | PnL: {pnl_pct:+.2f}%", font=dict(color="white"))
-                )
-
-        train_status = sys_state.training_status_msg
-        if sys_state.training_running: train_status = "🧪 Backtest Running..."
-
-        return (status_txt, status_line, fig, f"{curr_p:.6f}", f"{entry_p:.6f}", f"{tp_p:.6f}", f"{sl_p:.6f}",
-                f"{pnl_pct:+.2f}%", wl_df, wallet_md, history_md, neural_md)
-
-    except Exception:
-        traceback.print_exc()
-        return "Error", "Error", empty_chart, "0", "0", "0", "0", "0%", wl_df_empty, "Err", "Err", "Err"
-
-# ------------------------------------------------------------------------------
-# Gradio UI Construction
-# ------------------------------------------------------------------------------
-def create_gradio_ui():
-    custom_css = ".gradio-container {background:#0b0f19} .dataframe {background:#1a1a1a!important} .html-box {min-height:180px}"
-    
-    with gr.Blocks(title="Titan V36.3 (Neural Dashboard)") as demo:
-        gr.HTML(f"<style>{custom_css}</style>")
-        
-        gr.Markdown("# 🚀 Titan V36.3 (Cybernetic: Neural Dashboard)")
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                live_chart = gr.Plot(label="Chart")
-                with gr.Row():
-                    t_price = gr.Textbox(label="Price", interactive=False)
-                    t_pnl = gr.Textbox(label="PnL %", interactive=False)
-                with gr.Row():
-                    t_entry = gr.Textbox(label="Entry", interactive=False)
-                    t_tp = gr.Textbox(label="TP", interactive=False)
-                    t_sl = gr.Textbox(label="SL", interactive=False)
-
-            with gr.Column(scale=1):
-                wallet_out = gr.HTML(label="Smart Wallet", elem_classes="html-box")
-                # 🔥 إضافة المخرج الجديد
-                neural_out = gr.HTML(label="Neural Cycles", elem_classes="html-box")
+                await self._save_state()
                 
-                stats_dd = gr.Dropdown([
-                    "Dual-Core (Hybrid)", 
-                    "Hydra: Crash (Panic)", 
-                    "Hydra: Giveback (Profit)", 
-                    "Hydra: Stagnation (Time)"
-                ], value="Dual-Core (Hybrid)", label="View Guard Stats")
-                history_out = gr.HTML(label="Stats", elem_classes="html-box")
-                watchlist_out = gr.DataFrame(label="Watchlist")
-
-        gr.HTML("<hr style='border-color:#333'>")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                auto_pilot = gr.Checkbox(label="✈️ Auto-Pilot", value=True)
-                with gr.Row():
-                    btn_run = gr.Button("🚀 Scan", variant="primary")
-                    btn_close = gr.Button("🚨 Close", variant="stop")
-                with gr.Row():
-                    btn_train = gr.Button("🤖 Status", variant="secondary")
-                    btn_backtest = gr.Button("🧪 Run Strategic Backtest", variant="secondary")
-                with gr.Row():
-                    btn_history_reset = gr.Button("🗑️ Clear History", variant="secondary")
-                    btn_cap_reset = gr.Button("💰 Reset Capital", variant="secondary")
-                    
-                status = gr.Markdown("Init...")
-                alert = gr.Textbox(label="Alerts", interactive=False)
+                # 3. 🔥 HOT RELOAD LIVE SYSTEM (The Final Sync)
+                if self.trade_manager.learning_hub:
+                    logger.info("   🔄 [Scheduler] Hot-Reloading Live DNA...")
+                    await self.trade_manager.learning_hub.initialize()
+                    logger.info("   ✨ [Scheduler] Live System Updated Successfully.")
             
-            with gr.Column(scale=3):
-                logs = gr.Textbox(label="Logs", lines=14, autoscroll=True, elem_classes="log-box", type="text")
-                gr.HTML("<style>.log-box textarea { font-family: 'Consolas', 'Monaco', monospace !important; font-size: 12px !important; white-space: pre !important; }</style>")
-
-        # Event Handlers
-        btn_run.click(fn=run_cycle_from_gradio, outputs=alert)
-        btn_close.click(fn=manual_close_current_trade, outputs=alert)
-        btn_history_reset.click(fn=reset_history_handler, outputs=alert)
-        btn_cap_reset.click(fn=reset_capital_handler, outputs=alert)
-        btn_train.click(fn=trigger_training_cycle, outputs=alert)
-        btn_backtest.click(fn=trigger_strategic_backtest, outputs=alert)
-        auto_pilot.change(fn=toggle_auto_pilot, inputs=auto_pilot, outputs=alert)
-        
-        gr.Timer(3).tick(fn=check_live_pnl_and_status, inputs=stats_dd, 
-                         outputs=[logs, status, live_chart, t_price, t_entry, t_tp, t_sl, t_pnl, watchlist_out, wallet_out, history_out, neural_out])
-    return demo
-
-fast_api_server = FastAPI(lifespan=lifespan)
-gradio_dashboard = create_gradio_ui()
-app = gr.mount_gradio_app(app=fast_api_server, blocks=gradio_dashboard, path="/")
+        except Exception as e:
+            logger.error(f"❌ [Scheduler Fail] {e}")
+        finally:
+            self.is_running = False
+
+    # ✅ دالة جلب المقاييس للواجهة
+    def get_status_metrics(self):
+        def _fmt_time(last_dt):
+            if not last_dt: return "Pending"
+            diff = datetime.now() - last_dt
+            d = diff.days
+            h = diff.seconds // 3600
+            return f"{d}d {h}h"
+
+        return {
+            "weekly_timer": _fmt_time(self.last_weekly_run),
+            "weekly_count": self.weekly_count,
+            "monthly_timer": _fmt_time(self.last_monthly_run),
+            "monthly_count": self.monthly_count,
+            "is_running": self.is_running
+        }
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--type', type=str, default='weekly', help='weekly or monthly')
+    args = parser.parse_args()
+    asyncio.run(run_surgical_tuning(args.type, use_fixed_list=True))