Upload app (73).py

app (73).py

@@ -0,0 +1,838 @@
+# ==============================================================================
+# 🚀 app.py (V28.0 - GEM-Architect: Guardian Hydra Edition)
+# Architecture: Staged Filtering -> Top 10 Deep Dive -> Oracle -> Sniper -> Hydra.
+# Fixes: 
+# 1. Integration of Guardian Hydra stats keys (crash, giveback, stagnation).
+# 2. Updated UI Dropdowns for Hydra Heads.
+# 3. Preserved ALL Charting, Logic, Timers, and Stats features from V27.6.
+# 4. (V28.1 Update) Dynamic Scoring for Whales, News, and Advanced MC.
+# ==============================================================================
+
+import os
+import sys
+import traceback
+import asyncio
+import gc
+import time
+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 
+
+# ==============================================================================
+# 📝 إعداد نظام السجلات (Server Logging)
+# ==============================================================================
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(levelname)s] %(message)s", 
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger("TitanCore")
+
+# ==============================================================================
+# 📥 استيراد الوحدات الأساسية (Module Imports)
+# ==============================================================================
+try:
+    # Core Data & ML Modules
+    from r2 import R2Service
+    from ml_engine.data_manager import DataManager
+    from ml_engine.processor import MLProcessor
+    
+    # Whale & Network Analysis Modules
+    from whale_monitor.core import EnhancedWhaleMonitor
+    from whale_monitor.rpc_manager import AdaptiveRpcManager
+    
+    # Sentiment & News Modules
+    from sentiment_news import NewsFetcher
+    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+    
+    # Learning & Trading Execution Modules
+    from learning_hub.hub_manager import LearningHubManager
+    from trade_manager import TradeManager
+except ImportError as e:
+    logger.critical(f"❌ [FATAL ERROR] Failed to import core modules: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# ==============================================================================
+# 🌐 المتغيرات العامة (Global Context & Singletons)
+# ==============================================================================
+r2: R2Service = None
+data_manager: DataManager = None
+ml_processor: MLProcessor = None
+hub_manager: LearningHubManager = None 
+trade_manager: TradeManager = None
+whale_monitor: EnhancedWhaleMonitor = None
+news_fetcher: NewsFetcher = None
+senti_analyzer: SentimentIntensityAnalyzer = None
+sys_state: 'SystemState' = None
+
+# ==============================================================================
+# 🔄 حالة النظام (State Management System)
+# ==============================================================================
+class SystemState:
+    """
+    Holds the runtime state of the application.
+    Manages cycle flags, errors, status messages, and timestamps.
+    """
+    def __init__(self):
+        self.ready = False
+        self.cycle_running = False
+        self.training_running = False 
+        self.auto_pilot = True 
+        
+        # Timestamps & Logs
+        self.last_cycle_time: datetime = None
+        self.last_cycle_error = None
+        self.app_start_time = datetime.now()
+        
+        # Status Messages for UI
+        self.last_cycle_logs = "System Initializing..."
+        self.training_status_msg = "Waiting for data..." 
+        
+        # Configuration
+        self.scan_interval = 60 # Seconds (5 mins default)
+
+    def set_ready(self): 
+        """Mark system as fully initialized and ready."""
+        self.ready = True
+        self.last_cycle_logs = "✅ System Ready. Auto-Pilot ON."
+        logger.info("✅ System State set to READY.")
+    
+    def set_cycle_start(self): 
+        """Mark the start of a scanning cycle."""
+        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):
+        """Mark the end of a scanning cycle and store results."""
+        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.")
+
+# Initialize State Instance
+sys_state = SystemState()
+
+# ==============================================================================
+# 🛠️ دوال مساعدة (Utilities & Formatting)
+# ==============================================================================
+def format_crypto_price(price):
+    """Format price string nicely for UI (removing trailing zeros)."""
+    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):
+    """Calculate duration string (Days/Hours/Mins) from a timestamp."""
+    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 (Background Service)
+# ==============================================================================
+async def auto_pilot_loop():
+    """
+    Background task that manages scanning AND monitoring.
+    Fixes the 'Blind Spot' where Guardians were not checked if a trade was open.
+    """
+    logger.info("🤖 [Auto-Pilot] Daemon started (Monitoring Mode Enabled).")
+    while True:
+        try:
+            await asyncio.sleep(5) # Check every 5 seconds (Faster response)
+            
+            if not sys_state.ready: continue
+            
+            # 1. حالة التدريب
+            if hub_manager and int(time.time()) % 60 == 0:
+                is_ready, msg = await hub_manager.check_training_readiness()
+                sys_state.training_status_msg = msg
+
+            # 2. فحص حالة الصفقات المفتوحة (Watchdog Check)
+            # هذا هو الجزء الذي كان مفقوداً! نتأكد من أن الحراس يعملون.
+            if trade_manager and len(trade_manager.open_positions) > 0:
+                # التأكد من عمل الحلقات الخلفية
+                wd_status = await trade_manager.ensure_active_guardians()
+                
+                # تحديث واجهة المستخدم برسائل الحارس
+                # إذا كانت الرسالة "No active trades" نتجاهلها، غير ذلك نعرضها
+                if "No active" not in wd_status:
+                    sys_state.last_cycle_logs = trade_manager.latest_guardian_log
+                continue # ننتقل للدورة التالية ولا نقوم بمسح جديد
+
+            # 3. Trigger Cycle (فقط إذا لم تكن هناك صفقات)
+            if sys_state.auto_pilot and not sys_state.cycle_running and not sys_state.training_running:
+                # Check time since last cycle
+                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 (Server Startup/Shutdown & Injection)
+# ==============================================================================
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Application Lifecycle Manager.
+    Initializes all services, injects dependencies, and handles shutdown.
+    """
+    global r2, data_manager, ml_processor, hub_manager, trade_manager, whale_monitor, news_fetcher, senti_analyzer, sys_state
+    
+    logger.info("\n🚀 [System] Startup Sequence (Titan V28.0 - Guardian Hydra Edition)...")
+    try:
+        # 1. Initialize R2 & Data Manager
+        logger.info("   [1/7] Initializing R2 & Data Services...")
+        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. Initialize Auxiliary Services (Whale & News)
+        logger.info("   [2/7] Starting Auxiliary Services (Whale & News)...")
+        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)
+        logger.info("   ✅ [System] RPC Manager injected into Whale Monitor.")
+        
+        news_fetcher = NewsFetcher()
+        senti_analyzer = SentimentIntensityAnalyzer()
+        data_manager.whale_monitor = whale_monitor
+        
+        # 3. Initialize Learning Hub
+        logger.info("   [3/7] Initializing Learning Hub...")
+        hub_manager = LearningHubManager(r2_service=r2, data_manager=data_manager)
+        await hub_manager.initialize()
+
+        # 4. Initialize ML Processor (Oracle V4 Integration)
+        logger.info("   [4/7] Initializing Central ML Processor...")
+        ml_processor = MLProcessor(data_manager=data_manager)
+        await ml_processor.initialize()
+        ml_processor.hub_manager = hub_manager 
+        
+        # 5. Initialize Trade Manager (The Hand)
+        logger.info("   [5/7] Initializing Trade Manager...")
+        trade_manager = TradeManager(r2_service=r2, data_manager=data_manager, processor=ml_processor)
+        trade_manager.learning_hub = hub_manager 
+        await trade_manager.initialize_sentry_exchanges()
+        
+        # 6. Start Background Loops
+        logger.info("   [6/7] Restarting Active Sentries...")
+        await trade_manager.start_sentry_loops()
+        
+        # 7. Finalize Startup
+        logger.info("   [7/7] Launching Auto-Pilot...")
+        sys_state.set_ready()
+        asyncio.create_task(auto_pilot_loop())
+        logger.info("✅ [System READY] All modules operational.")
+        yield
+        
+    except Exception as e:
+        logger.critical(f"❌ [FATAL STARTUP ERROR] {e}")
+        traceback.print_exc()
+    finally:
+        logger.info("\n🛑 [System] Shutdown Sequence...")
+        sys_state.ready = False
+        
+        if hub_manager: await hub_manager.shutdown()
+        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 (Layer 2 Calculation)
+# ==============================================================================
+async def _analyze_symbol_task(symbol: str) -> Dict[str, Any]:
+    """
+    Task to analyze a single symbol.
+    Calculates L2 Base Score explicitly here based on user weights.
+    [FIX]: Now fetches '5m' data and enough candles for patterns (300).
+    """
+    try:
+        # [CRITICAL FIX] Added 5m for Titan, and increased limit for Patterns
+        required_tfs = ["5m", "15m", "1h", "4h"]
+        
+        # Fetch 300 candles to satisfy Pattern Engine's 200 candle requirement
+        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
+            
+        # Ensure we have critical timeframes
+        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()}
+        
+        # Run Processor (Titan, Patterns, MC)
+        res = await ml_processor.process_compound_signal(raw_data)
+        if not res: return None
+
+        # ---------------------------------------------------------
+        # ⚖️ EXPLICIT L2 SCORING (User Defined Weights)
+        # ---------------------------------------------------------
+        titan_s = res.get('titan_score', res.get('components', {}).get('titan_score', 0.5))
+        pattern_s = res.get('patterns_score', res.get('components', {}).get('patterns_score', 0.5))
+        mc_light_s = res.get('mc_score', res.get('components', {}).get('mc_score', 0.5))
+
+        # Formula: Titan (0.50) + Patterns (0.40) + MC Light (0.10)
+        l2_base_score = (titan_s * 0.50) + (pattern_s * 0.40) + (mc_light_s * 0.10)
+        
+        # Update packet
+        res['enhanced_final_score'] = l2_base_score # Used for initial sorting
+        res['l2_base_score'] = l2_base_score
+        res['titan_score'] = titan_s 
+        res['patterns_score'] = pattern_s
+        res['mc_score'] = mc_light_s
+        
+        return res
+        
+    except Exception: return None
+
+# ==============================================================================
+# 🚀 Unified Smart Cycle (Oracle V4 Logic + Deep Dive Top 10)
+# ==============================================================================
+async def run_unified_cycle():
+    """
+    Full Analysis Cycle with Strict Scoring & Re-Ranking.
+    Modified for Dynamic Scoring (Whales/News/MC-A).
+    """
+    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 ---
+        await trade_manager.sync_internal_state_with_r2()
+        if len(trade_manager.open_positions) > 0:
+            symbol = list(trade_manager.open_positions.keys())[0]
+            trade = trade_manager.open_positions[symbol]
+            log_and_print(f"🔒 [Guardian] Monitoring active trade: {symbol}")
+            curr_p = await data_manager.get_latest_price_async(symbol)
+            entry_p = float(trade.get('entry_price', 0))
+            if entry_p > 0:
+                pnl = ((curr_p - entry_p) / entry_p) * 100
+                log_and_print(f"   📊 PnL: {pnl:+.2f}% | TP: {trade.get('tp_price')} | SL: {trade.get('sl_price')}")
+            sys_state.set_cycle_end(logs=log_buffer.getvalue())
+            return 
+
+        # --- LAYER 1: Screening ---
+        log_and_print("   [1/5] 🔍 L1 Screening (Liquidity & Volume)...")
+        candidates = await data_manager.layer1_rapid_screening()
+        if not candidates:
+            log_and_print("⚠️ No L1 candidates found.")
+            sys_state.set_cycle_end(logs=log_buffer.getvalue())
+            return
+            
+        # --- LAYER 2: Deep Analysis (Titan, Patterns, MC-Light) ---
+        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]
+        
+        # Initial Sort by L2 Base Score to get the "Semi-Finalists"
+        semi_finalists = sorted(valid_l2, key=lambda x: x.get('l2_base_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 (Whales/News/MC-A) for TOP 10 ---
+        # [MODIFIED LOGIC FOR DYNAMIC SCORING]
+        log_and_print(f"   [3/5] 📡 L3 Deep Dive (Dynamic Scoring) for TOP {len(semi_finalists)}...")
+        
+        final_candidates = []
+
+        for sig in semi_finalists:
+            symbol = sig['symbol']
+            l2_score = sig.get('l2_base_score', 0.0)
+            
+            # -------------------------------------------------------
+            # A. Whale Analysis (Dynamic: -0.10 to +0.10)
+            # -------------------------------------------------------
+            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))
+                    
+                    # الشرط 1: عدم احتساب أي نقطة إذا لم يتم جلب البيانات أو كانت فارغة
+                    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)) # 0.1 to 1.0
+                        
+                        # حساب النقاط الديناميكية (بحسب قوة الإشارة)
+                        # Max Strength = 0.10
+                        dynamic_impact = 0.10 * confidence 
+                        
+                        # الشرط 2: المنصة -> المحفظة (إشارة احتفاظ/شراء) = إضافة نقاط
+                        if action == 'BUY': 
+                            whale_points = dynamic_impact 
+                            
+                        # الشرط 2: المحفظة -> المنصة (إشارة بيع) = خصم نقاط
+                        elif action == 'SELL':
+                            whale_points = -dynamic_impact
+                        
+                        # HOLD/WATCH/UNKNOWN = 0.0
+            except Exception: pass
+
+            # -------------------------------------------------------
+            # B. News Analysis (Dynamic: -0.05 to +0.05)
+            # -------------------------------------------------------
+            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:
+                        # VADER Compound: -1.0 (Very Neg) to +1.0 (Very Pos)
+                        sent = senti_analyzer.polarity_scores(summary_text)
+                        compound_score = sent['compound']
+                        
+                        # Mapping: 
+                        # Compound (+1.0) -> +0.05 Points
+                        # Compound (-1.0) -> -0.05 Points
+                        news_points = compound_score * 0.05
+            except Exception: pass
+
+            # -------------------------------------------------------
+            # C. Advanced Monte Carlo (Dynamic: -0.10 to +0.10)
+            # -------------------------------------------------------
+            mc_a_points = 0.0
+            try:
+                # The updated monte_carlo.py now returns values directly in range [-0.10, +0.10]
+                mc_a_points = await ml_processor.run_advanced_monte_carlo(symbol, '1h')
+            except Exception: pass
+
+            # --- CALCULATE FINAL SCORE ---
+            # Base Score + Whale (+/-) + News (+/-) + MC_A (+/-)
+            final_score = l2_score + whale_points + news_points + mc_a_points
+            
+            # Update Signal Packet
+            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 = []
+        
+        # SYM | TITAN | MC(L) | PATT | WHALE | NEWS | MC(A) | FINAL | ORACLE | STATUS
+        header = (f"{'SYM':<9} | {'TITAN':<5} | {'MC(L)':<5} | {'PATT':<5} | "
+                  f"{'WHALE':<6} | {'NEWS':<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']
+            
+            # E. Consult Oracle V4
+            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)
+
+            # Prepare columns for display
+            titan_d = sig.get('titan_score', 0.0)
+            mcl_d = sig.get('mc_score', 0.0)
+            patt_d = sig.get('patterns_score', 0.0)
+            whale_d = sig.get('whale_score', 0.0)
+            news_d = sig.get('news_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"{titan_d:.2f}  | "
+                f"{mcl_d:.2f}  | "
+                f"{patt_d:.2f}  | "
+                f"{whale_d:+.2f}  | " # Display with +/- sign
+                f"{news_d:+.2f}  | " # Display with +/- sign
+                f"{mca_d:+.2f}  | " # Display with +/- sign
+                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 Execution ({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())
+
+# ==============================================================================
+# 🎓 Training & Helper Logic
+# ==============================================================================
+async def trigger_training_cycle():
+    if sys_state.cycle_running or len(trade_manager.open_positions) > 0: return "⚠️ Busy."
+    sys_state.training_running = True
+    asyncio.create_task(_run_training_bg())
+    return "⏳ Training Started..."
+
+async def _run_training_bg():
+    try:
+        if hub_manager:
+            msg = await hub_manager.execute_training_session()
+            sys_state.last_cycle_logs = f"🎓 Report: {msg}"
+    except Exception: pass
+    finally: sys_state.training_running = False
+
+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_stats_handler():
+    if trade_manager.open_positions: return "⚠️ Close trade first."
+    await r2.reset_all_stats_async()
+    return "✅ Reset Done."
+
+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 & Charting (FIXED TIMERS & RESTORED FEATURES)
+# ==============================================================================
+async def check_live_pnl_and_status(selected_view="Guardian Hydra (Total)"):
+    """
+    Periodic update function for Gradio UI.
+    Features: Live Chart, Stats, Wallets, Watchlist, and Independent Timers.
+    """
+    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...", "Checking..."
+
+    try:
+        # 1. Portfolio Data
+        portfolio = await r2.get_portfolio_state_async()
+        curr_cap = portfolio.get('current_capital_usd', 100.0)
+        first_ts = portfolio.get('first_trade_timestamp')
+        uptime_str = calculate_duration_str(first_ts) # System Age
+        
+        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
+
+        # 2. Active Trade Data
+        symbol = None; entry_p = 0.0; tp_p = 0.0; sl_p = 0.0; curr_p = 0.0; pnl_pct = 0.0; pnl_val = 0.0
+        trade_dur_str = "--:--:--" # Default
+        oracle_str = "N/A"
+        
+        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))
+            
+            # [FIX] Calculate Active Trade Duration explicitly
+            trade_dur_str = calculate_duration_str(trade.get('entry_time'))
+            
+            # Oracle V4 Info
+            strength = trade.get('initial_oracle_strength', 0.0)
+            target_cls = trade.get('initial_oracle_class', 'N/A')
+            oracle_str = f"Str: {strength:.2f} | {target_cls}"
+            
+            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
+                pnl_val = curr_cap * (pnl_pct / 100)
+
+        final_bal = curr_cap + pnl_val
+        color = "#00ff00" if pnl_val >= 0 else "#ff0000"
+
+        # 3. HTML Construction
+        # We now have separated Uptime and Trade Duration rows
+        active_trade_row = ""
+        if symbol:
+             active_trade_row = f"""
+             <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
+                <span>⏱️ Trade:</span> <span style='color: #ffff00;'>{trade_dur_str}</span>
+             </div>"""
+
+        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;'>💰 Live Wallet</h3>
+            <div style='font-size: 26px; font-weight: bold; color: white; margin: 5px 0;'>${final_bal:,.2f}</div>
+            <div style='font-size: 14px; color: {color};'>({pnl_val:+,.2f} USD)</div>
+            <hr style='border-color:#444; margin: 10px 0;'>
+            
+            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc;'>
+                <span>⏳ System:</span> <span style='color: white;'>{uptime_str}</span>
+            </div>
+            {active_trade_row}
+            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
+                <span>🔮 Oracle:</span> <span style='color: #00e5ff;'>{oracle_str}</span>
+            </div>
+        </div>
+        """
+
+        # ✅ Hydra Stats Logic (Fixed Keys)
+        # Old: key_map = {"Hybrid System": "hybrid", "Model V2 (Radar)": "v2", "Model V3 (Sniper)": "v3"}
+        key_map = {
+            "Guardian Hydra (Total)": "hybrid", 
+            "Head: Crash (Panic)": "crash", 
+            "Head: Giveback (Profit)": "giveback",
+            "Head: 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;'>🐲 Hydra 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>
+        """
+
+        # 4. Watchlist Data
+        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'}"
+        
+        # 5. Full Chart (Restored)
+        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')
+                
+                # Spot Chart colors (Green/Red)
+                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
+                )])
+                
+                # Add Lines (Entry, TP, SL)
+                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 = "🏋️‍♂️ Training..."
+
+        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, train_status)
+
+    except Exception:
+        # traceback.print_exc()
+        return "Error", "Error", empty_chart, "0", "0", "0", "0", "0%", wl_df_empty, "Err", "Err", "Err"
+
+# ==============================================================================
+# 🎨 Gradio UI (Crash-Proof & Full Feature)
+# ==============================================================================
+def create_gradio_ui():
+    """
+    Creates the Gradio Interface.
+    """
+    custom_css = ".gradio-container {background:#0b0f19} .dataframe {background:#1a1a1a!important} .html-box {min-height:180px}"
+    
+    with gr.Blocks(title="Titan V28.0 (Guardian Hydra)") as demo:
+        gr.HTML(f"<style>{custom_css}</style>")
+        
+        gr.Markdown("# 🚀 Titan V28.0 (Guardian Hydra Edition)")
+        
+        with gr.Row():
+            # Left Column: Chart & Trade Info
+            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)
+
+            # Right Column: Wallet & Stats
+            with gr.Column(scale=1):
+                wallet_out = gr.HTML(label="Wallet", elem_classes="html-box")
+                # ✅ Updated Dropdown for Hydra Heads
+                stats_dd = gr.Dropdown([
+                    "Guardian Hydra (Total)", 
+                    "Head: Crash (Panic)", 
+                    "Head: Giveback (Profit)", 
+                    "Head: Stagnation (Time)"
+                ], value="Guardian Hydra (Total)", label="View AI 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():
+            # Control Panel
+            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("🎓 Train", variant="secondary")
+                    btn_reset = gr.Button("🗑️ Reset")
+                status = gr.Markdown("Init...")
+                train_status = gr.Textbox(label="Learning", interactive=False, value="Checking...")
+                alert = gr.Textbox(label="Alerts", interactive=False)
+            
+            # Logs Panel
+            with gr.Column(scale=3):
+                # Fix: Removed show_copy_button=True
+                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 Listeners
+        btn_run.click(fn=run_cycle_from_gradio, outputs=alert)
+        btn_close.click(fn=manual_close_current_trade, outputs=alert)
+        btn_reset.click(fn=reset_stats_handler, outputs=alert)
+        btn_train.click(fn=trigger_training_cycle, outputs=alert)
+        auto_pilot.change(fn=toggle_auto_pilot, inputs=auto_pilot, outputs=alert)
+        
+        # Periodic Update (3s)
+        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, train_status])
+    return demo
+
+# ==============================================================================
+# 🏁 Server Launch
+# ==============================================================================
+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__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)