Update app.py

app.py

@@ -1,290 +1,814 @@
-# ============================================================
-# 🗓️ periodic_tuner.py (V4.2 - GEM-Architect: Status Metrics)
-# ============================================================
+# ==============================================================================
+# 🚀 app.py (V36.3 - GEM-Architect: Neural Dashboard)
+# ==============================================================================
 
+import os
+import sys
+import traceback
 import asyncio
-import numpy as np
-import pandas as pd
-import pandas_ta as ta
+import gc
 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 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'
-]
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go 
 
+# ------------------------------------------------------------------------------
+# Logging Setup
+# ------------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(levelname)s] %(message)s", 
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
 logger = logging.getLogger("TitanCore")
 
-# ============================================================
-# 👁️ MARKET SENSOR V3.2
-# ============================================================
-async def detect_dominant_regime(dm: DataManager, days_back=7):
+# ------------------------------------------------------------------------------
+# 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
+    
+    # محاولة استيراد محرك الباكتست (اختياري للتشغيل عبر الواجهة)
     try:
-        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']
-            
-            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
-            
-        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)
+        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:
-        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']),
-        }
+        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
         
-        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"))
+        diff = datetime.now() - start_time
+        total_seconds = int(diff.total_seconds())
         
-        logger.info(f"   🚀 Optimizing for {detected_regime} (Last {days_back} days)...")
-        best_config, stats = await opt.run_optimization(detected_regime)
+        days = total_seconds // 86400
+        hours = (total_seconds % 86400) // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
         
-        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']
+        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
             
-            logger.info(f"   ✅ [Auto-Tuner] Success. Deltas: {new_deltas}")
-            hub.update_periodic_delta(detected_regime, period_type, new_deltas)
-            return True 
-        return False
+            # تحديث حالة الـ 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.error(f"❌ [Auto-Tuner Error] {e}")
-        return False
+        logger.critical(f"❌ [FATAL STARTUP ERROR] {e}")
+        traceback.print_exc()
     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:
+        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 '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()
+    
+    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]
+        
+        semi_finalists = sorted(valid_l2, key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)[:10]
+        
+        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)}...")
+        
+        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:
-                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:
-            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 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
 
-    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)
+            # 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 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
-                
-                await self._save_state()
-                
-                # 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.")
+            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)
+        
+        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..."
+        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"❌ [Scheduler Fail] {e}")
+            logger.error(f"❌ Backtest Failed: {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
+            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 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)
+            
+            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)
+                
+            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")
+                
+                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)
+            
+            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="/")
 
 if __name__ == "__main__":
-    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))
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)