Update app.py

app.py

@@ -1,5 +1,5 @@
 # ==============================================================================
-# 🚀 app.py (V69.0 - GEM-Architect: Monolithic Web Terminal)
+# 🚀 app.py (V67.5 - GEM-Architect: Full Visibility & Integrity)
 # ==============================================================================
 
 import os
@@ -15,12 +15,10 @@ from contextlib import asynccontextmanager, redirect_stdout, redirect_stderr
 from io import StringIO
 from typing import List, Dict, Any, Optional
 
-# ✅ استبدال Gradio بـ FastAPI و HTMLResponse
-import uvicorn
 from fastapi import FastAPI
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
+import gradio as gr
 import pandas as pd
+import plotly.graph_objects as go 
 
 # ------------------------------------------------------------------------------
 # Logging Setup
@@ -33,7 +31,7 @@ logging.basicConfig(
 logger = logging.getLogger("TitanCore")
 
 # ------------------------------------------------------------------------------
-# Imports (Core Logic)
+# Imports
 # ------------------------------------------------------------------------------
 try:
     from r2 import R2Service, INITIAL_CAPITAL 
@@ -45,6 +43,7 @@ try:
     from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
     from learning_hub.adaptive_hub import AdaptiveHub
     from trade_manager import TradeManager
+    # ✅ Import Continuous Tuner for injection
     from periodic_tuner import ContinuousTuner
     
     try:
@@ -92,7 +91,7 @@ class SystemState:
 
     def set_ready(self): 
         self.ready = True
-        self.last_cycle_logs = "✅ System Ready. Web Terminal Online."
+        self.last_cycle_logs = "✅ System Ready. Continuous Tuning ON."
         logger.info("✅ System State set to READY.")
     
     def set_cycle_start(self): 
@@ -138,6 +137,11 @@ def calculate_duration_str(timestamp_str):
         return f"{hours:02}:{minutes:02}:{seconds:02}"
     except: return "--:--:--"
 
+def format_pnl_split(profit, loss):
+    """تنسيق الربحية كجزأين (ربح / خسارة) بألوان"""
+    # ✅ FIX: Ensure distinct coloring for Profit vs Loss
+    return f"<span style='color:#00ff00'>+${profit:,.2f}</span> / <span style='color:#ff0000'>-${abs(loss):,.2f}</span>"
+
 # ------------------------------------------------------------------------------
 # Auto-Pilot Daemon
 # ------------------------------------------------------------------------------
@@ -154,11 +158,9 @@ async def auto_pilot_loop():
 
             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:
-                        # تحديث بسيط للسجل فقط في حالة عدم وجود مسح
-                        pass 
+                        sys_state.last_cycle_logs = trade_manager.latest_guardian_log
                 continue 
 
             if sys_state.auto_pilot and not sys_state.cycle_running and not sys_state.training_running:
@@ -176,13 +178,13 @@ async def auto_pilot_loop():
             await asyncio.sleep(30)
 
 # ------------------------------------------------------------------------------
-# Lifespan (Startup/Shutdown)
+# 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
     
-    logger.info("\n🚀 [System] Startup Sequence (Titan V69.0 - Monolithic Web)...")
+    logger.info("\n🚀 [System] Startup Sequence (Titan V67.5 - Full Integrity)...")
     try:
         r2 = R2Service()
         data_manager = DataManager(contracts_db={}, whale_monitor=None, r2_service=r2)
@@ -206,6 +208,7 @@ async def lifespan(app: FastAPI):
         trade_manager = TradeManager(r2_service=r2, data_manager=data_manager, processor=ml_processor)
         trade_manager.learning_hub = adaptive_hub 
         
+        # ✅ FIX: Inject Continuous Tuner directly into Hub
         adaptive_hub.tuner = ContinuousTuner(adaptive_hub)
         logger.info("🔧 [Tuner] Continuous Tuner Injected.")
         
@@ -214,7 +217,7 @@ async def lifespan(app: FastAPI):
         
         sys_state.set_ready()
         asyncio.create_task(auto_pilot_loop())
-        logger.info("✅ [System READY] All modules operational. Serving UI on port 7860.")
+        logger.info("✅ [System READY] All modules operational.")
         yield
         
     except Exception as e:
@@ -228,7 +231,7 @@ async def lifespan(app: FastAPI):
         logger.info("✅ [System] Shutdown Complete.")
 
 # ------------------------------------------------------------------------------
-# Helper Tasks (Logic)
+# Helper Tasks
 # ------------------------------------------------------------------------------
 async def _analyze_symbol_task(candidate_data: Dict[str, Any]) -> Dict[str, Any]:
     try:
@@ -267,7 +270,7 @@ async def _analyze_symbol_task(candidate_data: Dict[str, Any]) -> Dict[str, Any]
     except Exception: return None
 
 # ------------------------------------------------------------------------------
-# Unified Cycle (Full Logic)
+# Unified Cycle (FULL LOGIC with VISIBILITY)
 # ------------------------------------------------------------------------------
 async def run_unified_cycle():
     log_buffer = StringIO()
@@ -302,16 +305,20 @@ async def run_unified_cycle():
         tasks = [_analyze_symbol_task(c) for c in candidates]
         results = await asyncio.gather(*tasks)
         
+        # ✅ فصل المقبولين عن المرفوضين (Validity Check)
         valid_l2 = [res for res in results if res is not None and res.get('is_valid', False)]
         rejected_l2 = [res for res in results if res is not None and not res.get('is_valid', False)]
         
+        # ترتيب المرفوضين لعرض أفضلهم
         rejected_l2.sort(key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)
 
         if not valid_l2:
-            log_and_print("⚠️ No valid L2 candidates. Top 10 Rejected:")
+            log_and_print("⚠️ No valid L2 candidates (Hard Gates Active). Top 10 Rejected:")
+            # طباعة جدول يوضح سبب الرفض
             rej_header = f"{'SYM':<9} | {'TITAN':<5} | {'PATT':<5} | {'MC':<5} | {'FINAL':<5} | {'REASON'}"
             log_and_print(rej_header)
             log_and_print("-" * 100)
+            
             for rej in rejected_l2[:10]:
                 sym = rej['symbol']
                 tit = rej.get('titan_score', 0.0)
@@ -375,10 +382,11 @@ async def run_unified_cycle():
 
         approved_signals = []
         
+        # ✅ FIX: Updated Header with NEWS and MC(L) and MC(A)
         header = (f"{'SYM':<9} | {'TYPE':<10} | {'L2':<5} | {'TITAN':<5} | {'PATT':<5} | "
                   f"{'NEWS':<5} | {'WHALE':<6} | {'MC(L)':<5} | {'MC(A)':<5} | {'FINAL':<6} | {'ORACLE':<6} | {'STATUS'}")
         
-        log_and_print("-" * 130)
+        log_and_print("-" * 130) # Widen
         log_and_print(header)
         log_and_print("-" * 130)
         
@@ -400,17 +408,29 @@ async def run_unified_cycle():
             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)
+            
+            # ✅ FIX: Extract NEW Columns
             news_d = sig.get('news_score', 0.0)
             whale_d = sig.get('whale_score', 0.0)
-            mcl_d = sig.get('mc_score', 0.0)   
-            mca_d = sig.get('mc_advanced_score', 0.0) 
+            mcl_d = sig.get('mc_score', 0.0)   # Light
+            mca_d = sig.get('mc_advanced_score', 0.0) # Advanced
+            
             final_d = sig.get('final_total_score', 0.0)
             strat_type = sig.get('strategy_type', 'N/A')
 
             log_and_print(
-                f"{symbol:<9} | {strat_type:<10} | {l2_hybrid:.2f}  | {titan_d:.2f}  | {patt_d:.2f}  | "
-                f"{news_d:+.2f} | {whale_d:+.2f}  | {mcl_d:.2f}  | {mca_d:+.2f}  | {final_d:.2f}   | " 
-                f"{oracle_conf:.2f}   | {status_str}"
+                f"{symbol:<9} | "
+                f"{strat_type:<10} | "
+                f"{l2_hybrid:.2f}  | "
+                f"{titan_d:.2f}  | "
+                f"{patt_d:.2f}  | "
+                f"{news_d:+.2f} | "  
+                f"{whale_d:+.2f}  | " 
+                f"{mcl_d:.2f}  | "   
+                f"{mca_d:+.2f}  | "  
+                f"{final_d:.2f}   | " 
+                f"{oracle_conf:.2f}   | "
+                f"{status_str}"
             )
 
         if approved_signals:
@@ -435,423 +455,418 @@ async def run_unified_cycle():
         traceback.print_exc()
         sys_state.set_cycle_end(error=e, logs=log_buffer.getvalue())
 
-# ==============================================================================
-# 💻 THE EMBEDDED FRONTEND (HTML/JS/CSS)
-# ==============================================================================
-# This string contains the entire UI, served by FastAPI as the root route.
-# ==============================================================================
+# ------------------------------------------------------------------------------
+# Handlers
+# ------------------------------------------------------------------------------
+async def trigger_training_cycle():
+    if adaptive_hub: return f"🤖 Adaptive System: {adaptive_hub.get_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 "⛔ Active trades exist."
+    if sys_state.training_running: return "⚠️ Running."
+        
+    async def _run_bg_task():
+        sys_state.training_running = True
+        sys_state.training_status_msg = "🧪 Strategic Backtest Running..."
+        try:
+            logger.info("🧪 [Manual] Starting Strategic Backtest...")
+            await run_strategic_optimization_task()
+            if adaptive_hub: await adaptive_hub.initialize()
+            logger.info("✅ [Manual] Backtest Complete.")
+        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."
+
+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 reset_diagnostics_handler():
+    await r2.reset_diagnostic_stats_async()
+    return "✅ Diagnostic Matrix Reset."
+
+async def reset_guardians_handler():
+    await r2.reset_guardian_stats_async()
+    if trade_manager: trade_manager.ai_stats = await r2.get_guardian_stats_async()
+    return "✅ Guardian Stats Reset."
+
+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."
 
-HTML_CONTENT = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>TITAN Terminal V69</title>
-    <script src="https://unpkg.com/lightweight-charts/dist/lightweight-charts.standalone.production.js"></script>
-    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;700&display=swap" rel="stylesheet">
-    <style>
-        :root {
-            --bg-color: #0b0f19;
-            --panel-bg: #161b29;
-            --text-color: #d1d5db;
-            --accent-green: #00ff9d;
-            --accent-red: #ff3b30;
-            --accent-blue: #00e5ff;
-            --border: #2d3748;
-        }
-        body { margin: 0; padding: 0; font-family: 'JetBrains Mono', monospace; background-color: var(--bg-color); color: var(--text-color); height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
-        
-        /* Layout Grid */
-        .grid-container {
-            display: grid;
-            grid-template-columns: 260px 1fr 320px;
-            grid-template-rows: 60px 1fr 200px;
-            height: 100vh;
-            gap: 1px;
-            background-color: var(--border);
-        }
+# ------------------------------------------------------------------------------
+# 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"])
+    diag_df_empty = pd.DataFrame(columns=["Model", "Wins", "Losses", "PnL (USD)"])
+    type_df_empty = pd.DataFrame(columns=["Coin Type", "Wins", "Losses", "Profitability"])
+    
+    if not sys_state.ready:
+        return "Initializing...", "...", empty_chart, "0.0", "0.0", "0.0", "0.0", "0.0%", wl_df_empty, diag_df_empty, type_df_empty, "Loading...", "Loading...", "Loading..."
 
-        /* Header */
-        header { grid-column: 1 / -1; background-color: var(--panel-bg); display: flex; align-items: center; padding: 0 20px; justify-content: space-between; border-bottom: 1px solid var(--border); }
-        .brand { font-size: 20px; font-weight: bold; color: var(--accent-blue); letter-spacing: 2px; text-shadow: 0 0 10px rgba(0, 229, 255, 0.3); }
-        .header-stats { display: flex; gap: 20px; font-size: 13px; }
-        .status-pill { padding: 4px 10px; border-radius: 4px; font-size: 12px; background: #2d3748; border: 1px solid transparent; }
-        .status-pill.active { background: rgba(0, 255, 157, 0.1); color: var(--accent-green); border-color: var(--accent-green); }
-        .status-pill.busy { background: rgba(255, 59, 48, 0.1); color: var(--accent-red); border-color: var(--accent-red); }
-
-        /* Sidebar */
-        aside { grid-row: 2 / -1; background-color: var(--panel-bg); padding: 20px; display: flex; flex-direction: column; gap: 15px; border-right: 1px solid var(--border); }
-        .sidebar-section { margin-bottom: 10px; }
-        .section-title { font-size: 11px; color: #6b7280; margin-bottom: 8px; font-weight: bold; letter-spacing: 1px; }
-        
-        button {
-            width: 100%; background: #2d3748; border: 1px solid #4a5568; color: white; padding: 12px; border-radius: 6px; cursor: pointer; font-family: inherit; font-weight: bold; transition: 0.2s; display: flex; align-items: center; justify-content: center; gap: 8px;
-        }
-        button:hover { background: #4a5568; transform: translateY(-1px); }
-        button:active { transform: translateY(0); }
-        button.primary { background: var(--accent-blue); color: #0b0f19; border: none; box-shadow: 0 0 10px rgba(0, 229, 255, 0.2); }
-        button.primary:hover { background: #33ecff; }
-        button.danger { background: rgba(255, 59, 48, 0.1); color: var(--accent-red); border-color: var(--accent-red); }
-        button.danger:hover { background: rgba(255, 59, 48, 0.3); }
-
-        /* Main Chart Area */
-        main { grid-column: 2; grid-row: 2; background-color: var(--bg-color); position: relative; }
-        #chart-container { width: 100%; height: 100%; }
-        .chart-overlay { position: absolute; top: 15px; left: 15px; background: rgba(11, 15, 25, 0.85); padding: 8px 12px; border-radius: 6px; border: 1px solid var(--border); backdrop-filter: blur(4px); pointer-events: none; z-index: 10; }
-        .overlay-symbol { font-size: 20px; font-weight: bold; color: white; }
-        .overlay-price { font-size: 14px; color: var(--accent-green); }
-
-        /* Right Panel (Stats) */
-        .stats-panel { grid-column: 3; grid-row: 2; background-color: var(--panel-bg); padding: 0; overflow-y: auto; display: flex; flex-direction: column; }
-        .panel-header { padding: 15px; background: #1f2937; border-bottom: 1px solid var(--border); font-weight: bold; }
-        .stat-card { padding: 15px; border-bottom: 1px solid var(--border); }
-        .stat-value { font-size: 26px; margin-top: 5px; color: white; font-weight: bold; }
-        .stat-label { font-size: 11px; color: #9ca3af; text-transform: uppercase; }
-        .pnl-pos { color: var(--accent-green); text-shadow: 0 0 10px rgba(0,255,157,0.2); }
-        .pnl-neg { color: var(--accent-red); }
-
-        /* Positions List */
-        .positions-container { flex-grow: 1; overflow-y: auto; }
-        .position-card { padding: 12px 15px; border-bottom: 1px solid var(--border); cursor: pointer; transition: 0.2s; }
-        .position-card:hover { background: #2d3748; }
-        .pos-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 5px; }
-        .pos-symbol { font-weight: bold; color: white; font-size: 14px; }
-        .pos-pnl { font-weight: bold; font-size: 14px; }
-        .pos-details { display: flex; justify-content: space-between; font-size: 11px; color: #9ca3af; }
-
-        /* Logs Area */
-        footer { grid-column: 2 / -1; grid-row: 3; background-color: #0d1117; color: #3fb950; padding: 10px; font-size: 12px; overflow-y: auto; border-top: 1px solid var(--border); font-family: 'Consolas', monospace; }
-        .log-entry { margin-bottom: 3px; white-space: pre-wrap; line-height: 1.4; }
-        .log-time { color: #8b949e; margin-right: 8px; }
-
-        /* Scrollbar */
-        ::-webkit-scrollbar { width: 6px; height: 6px; }
-        ::-webkit-scrollbar-track { background: var(--bg-color); }
-        ::-webkit-scrollbar-thumb { background: #4b5563; border-radius: 3px; }
-        ::-webkit-scrollbar-thumb:hover { background: #6b7280; }
-    </style>
-</head>
-<body>
-
-    <div class="grid-container">
-        <header>
-            <div class="brand">⚡ TITAN TERMINAL</div>
-            <div class="header-stats">
-                <div class="status-pill" id="sys-status">System: Idle</div>
-                <div class="status-pill" id="auto-pilot-status">Auto-Pilot: ON</div>
-                <div class="status-pill" id="tuner-status">Tuner: Init</div>
-            </div>
-        </header>
-
-        <aside>
-            <div class="sidebar-section">
-                <div class="section-title">PRIMARY ACTIONS</div>
-                <button class="primary" onclick="triggerScan()">
-                    <span>🚀</span> RUN MARKET SCAN
-                </button>
-            </div>
+    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)
+        
+        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'))
             
-            <div class="sidebar-section">
-                <div class="section-title">CONTROLS</div>
-                <button onclick="toggleAutoPilot()">✈️ Toggle Auto-Pilot</button>
-                <button onclick="refreshData()">🔄 Force Refresh</button>
-            </div>
-
-            <div style="flex-grow: 1;"></div>
+            decision_data = trade.get('decision_data', {})
+            gov_grade = decision_data.get('governance_grade', 'N/A')
+            gov_score = decision_data.get('governance_score', 0.0)
+            sys_conf = decision_data.get('system_confidence', 0.0)
+            strat_type = trade.get('strategy_type', 'NORMAL')
             
-            <div class="sidebar-section">
-                <div class="section-title">DANGER ZONE</div>
-                <button class="danger" onclick="triggerClose()">🚨 PANIC CLOSE ALL</button>
-            </div>
-        </aside>
-
-        <main>
-            <div id="chart-container"></div>
-            <div class="chart-overlay">
-                <div class="overlay-symbol" id="chart-symbol">WAITING...</div>
-                <div class="overlay-price" id="chart-regime">Scanning for signals...</div>
-            </div>
-        </main>
-
-        <div class="stats-panel">
-            <div class="panel-header">INSTITUTIONAL WALLET</div>
-            <div class="stat-card">
-                <div class="stat-label">TOTAL EQUITY</div>
-                <div class="stat-value" id="equity-val">$0.00</div>
-            </div>
+            grade_color = "#ccc"
+            if gov_grade == "ULTRA": grade_color = "#ff00ff" 
+            elif gov_grade == "STRONG": grade_color = "#00ff00" 
+            elif gov_grade == "NORMAL": grade_color = "#00e5ff" 
+            elif gov_grade == "WEAK": grade_color = "#ffff00" 
+            elif gov_grade == "REJECT": grade_color = "#ff0000" 
+
+            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; border-top: 1px solid #333; padding-top: 5px;'>
+                <span>⏱️ Time:</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>🏛️ Grade:</span> <span style='color: {grade_color}; font-weight:bold;'>{gov_grade} ({gov_score:.1f})</span>
+             </div>
+             <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc; margin-top:5px;'>
+                <span>🏷️ Type:</span> <span style='color: #orange;'>{strat_type}</span>
+             </div>
+            """
+
+        virtual_equity = equity + pnl_val_unrealized
+        active_pnl_color = "#00ff00" if pnl_val_unrealized >= 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
+        halt_status = "<span style='color:red; font-weight:bold;'>HALTED</span>" if is_halted else "<span style='color:#00ff00;'>ACTIVE</span>"
+
+        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;'>💼 Institutional 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;'>({pnl_val_unrealized:+,.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:{"#00ff00" if daily_pnl>=0 else "#ff0000"};'>${daily_pnl:+.2f}</td></tr>
+            </table>
+            
+            <hr style='border-color:#444; margin: 10px 0;'>
             
-            <div class="stat-card">
-                <div class="stat-label">DAILY PNL</div>
-                <div class="stat-value" id="pnl-val">$0.00</div>
+            <div style='display: flex; justify-content: space-between; font-size: 12px; color: #ccc;'>
+                <span>🦅 Mood:</span> <span style='color: white;'>{sp.market_trend}</span>
             </div>
-
-            <div class="panel-header" style="margin-top: 10px;">OPEN POSITIONS</div>
-            <div class="positions-container" id="positions-list">
-                <div style="padding: 20px; text-align: center; color: #6b7280; font-size: 12px;">
-                    No Active Trades
-                </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>
-
-        <footer id="logs-area">
-            <div class="log-entry">System Initialized... Connecting to Neural Core...</div>
-        </footer>
-    </div>
-
-    <script>
-        // --- API Config ---
-        // Using relative path ensures compatibility with localhost and Hugging Face
-        const API_URL = "/api"; 
-
-        // --- Chart Setup ---
-        const chartContainer = document.getElementById('chart-container');
-        const chart = LightweightCharts.createChart(chartContainer, {
-            layout: { background: { color: '#0b0f19' }, textColor: '#d1d5db' },
-            grid: { vertLines: { color: '#1f2937' }, horzLines: { color: '#1f2937' } },
-            timeScale: { timeVisible: true, secondsVisible: false, borderColor: '#2d3748' },
-            rightPriceScale: { borderColor: '#2d3748' },
-        });
-
-        const candleSeries = chart.addCandlestickSeries({
-            upColor: '#00ff9d', downColor: '#ff3b30', 
-            borderVisible: false, wickUpColor: '#00ff9d', wickDownColor: '#ff3b30',
-        });
-        
-        window.addEventListener('resize', () => {
-            chart.resize(chartContainer.clientWidth, chartContainer.clientHeight);
-        });
-
-        // --- State ---
-        let currentSymbol = "";
-        let isScanning = false;
-
-        // --- Core Functions ---
-
-        async function updateStatus() {
-            try {
-                const res = await fetch(`${API_URL}/status`);
-                const data = await res.json();
-                
-                // Update Wallet
-                document.getElementById('equity-val').innerText = `$${data.capital.toFixed(2)}`;
-                const pnlEl = document.getElementById('pnl-val');
-                pnlEl.innerText = `$${data.daily_pnl.toFixed(2)}`;
-                pnlEl.className = `stat-value ${data.daily_pnl >= 0 ? 'pnl-pos' : 'pnl-neg'}`;
-
-                // Update Status Pills
-                const sysStatus = document.getElementById('sys-status');
-                if (data.cycle_running) {
-                    sysStatus.innerText = "System: 🌀 SCANNING";
-                    sysStatus.className = "status-pill busy";
-                    isScanning = true;
-                } else {
-                    sysStatus.innerText = "System: ✅ IDLE";
-                    sysStatus.className = "status-pill active";
-                    isScanning = false;
-                }
-
-                const apStatus = document.getElementById('auto-pilot-status');
-                apStatus.innerText = data.auto_pilot ? "Auto-Pilot: ON" : "Auto-Pilot: OFF";
-                apStatus.className = `status-pill ${data.auto_pilot ? 'active' : ''}`;
-
-                document.getElementById('tuner-status').innerText = data.tuner_status.substring(0, 20) + "..";
-
-                // Update Logs
-                const logsArea = document.getElementById('logs-area');
-                if (logsArea.innerText !== data.logs) {
-                    logsArea.innerText = data.logs; 
-                    logsArea.scrollTop = logsArea.scrollHeight;
-                }
-
-            } catch (e) { console.error("Status Sync Error:", e); }
-        }
-
-        async function updatePositions() {
-            try {
-                const res = await fetch(`${API_URL}/positions`);
-                const data = await res.json();
-                const container = document.getElementById('positions-list');
-                
-                if (data.length === 0) {
-                    container.innerHTML = "<div style='padding: 20px; text-align: center; color: #6b7280; font-size: 12px;'>No Active Trades</div>";
-                    return;
-                }
-
-                // If trades exist, load chart for the first one if no symbol selected
-                if (currentSymbol === "" && data.length > 0) {
-                    loadChart(data[0].symbol);
-                }
-
-                let html = "";
-                data.forEach(pos => {
-                    const pnlClass = pos.pnl_pct >= 0 ? 'pnl-pos' : 'pnl-neg';
-                    const activeClass = pos.symbol === currentSymbol ? 'background: #2d3748;' : '';
-                    
-                    html += `
-                        <div class="position-card" style="${activeClass}" onclick="loadChart('${pos.symbol}')">
-                            <div class="pos-header">
-                                <span class="pos-symbol">${pos.symbol}</span>
-                                <span class="pos-pnl ${pnlClass}">${pos.pnl_pct}%</span>
-                            </div>
-                            <div class="pos-details">
-                                <span>${pos.strategy}</span>
-                                <span>${pos.duration}</span>
-                            </div>
-                        </div>
-                    `;
-                });
-                container.innerHTML = html;
-
-            } catch (e) { console.error("Pos Sync Error:", e); }
-        }
-
-        async function loadChart(symbol) {
-            if (symbol === currentSymbol && symbol !== "") return;
-            currentSymbol = symbol;
-            
-            document.getElementById('chart-symbol').innerText = symbol;
-            document.getElementById('chart-regime').innerText = "Loading data...";
-            
-            try {
-                const res = await fetch(`${API_URL}/chart/${symbol}`);
-                const data = await res.json();
-                if (data.length > 0) {
-                    candleSeries.setData(data);
-                    const last = data[data.length - 1];
-                    document.getElementById('chart-regime').innerText = `Price: ${last.close}`;
-                    chart.timeScale().fitContent();
-                } else {
-                     document.getElementById('chart-regime').innerText = "No Data Available";
-                }
-            } catch (e) { console.error("Chart Load Error:", e); }
-        }
-
-        // --- Actions ---
-        async function triggerScan() { 
-            if(isScanning) return;
-            await fetch(`${API_URL}/action/scan`, {method: 'POST'}); 
-            updateStatus(); 
+        """
+
+        # Guardian Stats
+        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>
+        """
+
+        # TUNER STATUS
+        status_msg = "Inactive"
+        if adaptive_hub:
+            status_msg = adaptive_hub.get_status()
+
+        neural_md = f"""
+        <div style='background-color: #1a1a1a; padding: 10px; border-radius: 8px; border: 1px solid #333; font-size: 12px; margin-top: 10px;'>
+            <h3 style='margin:0; color:#00e5ff; font-size:14px;'>🧠 Micro-Tuner</h3>
+            <table style='width:100%; color:#ccc;'>
+                <tr style='border-bottom: 1px solid #333;'>
+                    <td style='padding:4px 0;'>⚡ Status:</td>
+                    <td style='text-align:right; color:#ffff00; font-weight:bold;'>Active</td>
+                </tr>
+                <tr>
+                    <td style='padding:4px 0;'>🔧 Logic:</td>
+                    <td style='text-align:right; color:#fff;'>{status_msg}</td>
+                </tr>
+            </table>
+        </div>
+        """
         
-        async function triggerClose() { 
-            if(confirm("Are you sure you want to close ALL positions?")) {
-                await fetch(`${API_URL}/action/close_all`, {method: 'POST'}); 
-                updateStatus(); 
-            }
-        }
+        # ✅ FIX: Diagnostic Matrix with Split PnL (Accumulated Profit vs Loss)
+        diag_data = await r2.get_diagnostic_stats_async()
+        diag_list = []
+        ordered_models = ["Titan", "Patterns", "Oracle", "Sniper", "MonteCarlo_L", "MonteCarlo_A", "News", "Governance"]
         
-        async function toggleAutoPilot() {
-            // Simple toggle via endpoint (need to implement in backend if strictly needed, 
-            // for now we just show alert as placeholder or map to an endpoint)
-            await fetch(`${API_URL}/action/toggle_autopilot`, {method: 'POST'});
-            updateStatus();
-        }
-
-        function refreshData() { updateStatus(); updatePositions(); }
-
-        // --- Loop ---
-        setInterval(() => {
-            updateStatus();
-            updatePositions();
-        }, 2000);
-
-        // --- Init ---
-        refreshData();
-
-    </script>
-</body>
-</html>
-"""
+        for m in ordered_models:
+            stats = diag_data.get(m, {"wins": 0, "losses": 0, "pnl": 0.0, "profit_accum": 0.0, "loss_accum": 0.0})
+            
+            profit_accum = stats.get('profit_accum', 0.0)
+            loss_accum = stats.get('loss_accum', 0.0)
+            
+            # If accum values are missing (legacy data), try to infer from net PnL (imperfect fallback)
+            if profit_accum == 0.0 and loss_accum == 0.0 and stats['pnl'] != 0.0:
+                 if stats['pnl'] > 0: profit_accum = stats['pnl']
+                 else: loss_accum = abs(stats['pnl'])
+
+            pnl_str = format_pnl_split(profit_accum, loss_accum)
+            diag_list.append([m, stats['wins'], stats['losses'], pnl_str])
+        
+        diag_df = pd.DataFrame(diag_list, columns=["Model", "Wins", "Losses", "PnL (USD)"])
+
+        # Type Stats DataFrame
+        type_stats_list = []
+        if trade_manager and hasattr(trade_manager, 'type_stats'):
+            for t_name, t_data in trade_manager.type_stats.items():
+                name_clean = t_name.replace("_", " ")
+                wins = t_data.get('wins', 0)
+                losses = t_data.get('losses', 0)
+                prof = t_data.get('profit_usd', 0.0)
+                loss_val = t_data.get('loss_usd', 0.0)
+                profitability_html = format_pnl_split(prof, loss_val)
+                type_stats_list.append([name_clean, wins, losses, profitability_html])
+        
+        type_df = pd.DataFrame(type_stats_list, columns=["Coin Type", "Wins", "Losses", "Profitability"])
+
+        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="TP", annotation_position="top left")
+                if sl_p > 0:
+                    fig.add_hline(y=sl_p, line_color="#ff0000", line_width=2, annotation_text="SL", 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} (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, diag_df, type_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, diag_df_empty, type_df_empty, "Err", "Err", "Err"
 
 # ------------------------------------------------------------------------------
-# 🔌 API Endpoints
+# Gradio UI Construction
 # ------------------------------------------------------------------------------
-app = FastAPI(lifespan=lifespan, title="Titan Terminal")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.get("/")
-async def root():
-    """Serves the Embedded HTML Frontend"""
-    return HTMLResponse(content=HTML_CONTENT)
-
-@app.get("/api/status")
-async def get_status():
-    if not trade_manager or not trade_manager.smart_portfolio:
-        return {"capital": 0.0, "daily_pnl": 0.0, "logs": "Loading...", "tuner_status": "Init"}
-    
-    sp = trade_manager.smart_portfolio
+def create_gradio_ui():
+    custom_css = ".gradio-container {background:#0b0f19} .dataframe {background:#1a1a1a!important} .html-box {min-height:180px}"
     
-    return {
-        "cycle_running": sys_state.cycle_running,
-        "auto_pilot": sys_state.auto_pilot,
-        "capital": sp.state.get("current_capital", 10.0),
-        "daily_pnl": sp.state.get("daily_net_pnl", 0.0),
-        "logs": sys_state.last_cycle_logs,
-        "tuner_status": adaptive_hub.get_status() if adaptive_hub else "Init"
-    }
-
-@app.get("/api/positions")
-async def get_positions():
-    positions = []
-    if trade_manager:
-        for sym, trade in trade_manager.open_positions.items():
-            curr_p = await data_manager.get_latest_price_async(sym)
-            entry_p = float(trade['entry_price'])
-            pnl_pct = ((curr_p - entry_p) / entry_p) * 100 if entry_p > 0 else 0.0
+    with gr.Blocks(title="Titan V67.5 (Full)") as demo:
+        gr.HTML(f"<style>{custom_css}</style>")
+        
+        gr.Markdown("# 🚀 Titan V67.5 (Full Visibility)")
+        
+        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")
+                
+                # Type Stats Table
+                gr.Markdown("### 💎 Opportunity Types")
+                type_stats_out = gr.Dataframe(
+                    headers=["Coin Type", "Wins", "Losses", "Profitability"],
+                    datatype=["str", "number", "number", "html"],
+                    interactive=False,
+                    label="Type Performance"
+                )
+
+                gr.Markdown("### 🕵️ Diagnostic Matrix")
+                diagnostic_out = gr.Dataframe(
+                    headers=["Model", "Wins", "Losses", "PnL (USD)"],
+                    datatype=["str", "number", "number", "html"], 
+                    interactive=False,
+                    label="Model Performance"
+                )
+                
+                with gr.Row():
+                    btn_reset_diag = gr.Button("🧹 Reset Matrix", size="sm", variant="secondary")
+                    btn_reset_guard = gr.Button("🛡️ Reset Guardians", size="sm", variant="secondary")
+                
+                gr.HTML("<hr style='border-color:#444; margin: 10px 0;'>")
+                
+                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)
             
-            positions.append({
-                "symbol": sym,
-                "entry": entry_p,
-                "current": curr_p,
-                "pnl_pct": round(pnl_pct, 2),
-                "duration": calculate_duration_str(trade['entry_time']),
-                "strategy": trade.get('strategy_type', 'NORMAL')
-            })
-    return positions
-
-@app.get("/api/chart/{symbol}")
-async def get_chart_data(symbol: str):
-    ohlcv = await data_manager.get_latest_ohlcv(symbol, '5m', 200)
-    formatted = []
-    if ohlcv:
-        for c in ohlcv:
-            # [ts, o, h, l, c, v]
-            formatted.append({
-                "time": int(c[0] / 1000), 
-                "open": c[1], "high": c[2], "low": c[3], "close": c[4]
-            })
-    return formatted
-
-@app.post("/api/action/scan")
-async def action_scan():
-    if sys_state.cycle_running: return {"msg": "Busy"}
-    asyncio.create_task(run_unified_cycle())
-    return {"msg": "Scan Started"}
+            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>")
 
-@app.post("/api/action/close_all")
-async def action_close():
-    if not trade_manager.open_positions: return {"msg": "No trades"}
-    # Close all logic
-    for sym in list(trade_manager.open_positions.keys()):
-        await trade_manager.force_exit_by_manager(sym, "MANUAL_WEB_PANIC")
-    return {"msg": "Closing all..."}
+        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)
+        
+        btn_reset_diag.click(fn=reset_diagnostics_handler, outputs=alert)
+        btn_reset_guard.click(fn=reset_guardians_handler, 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, diagnostic_out, type_stats_out, wallet_out, history_out, neural_out])
+    return demo
 
-@app.post("/api/action/toggle_autopilot")
-async def action_toggle_autopilot():
-    sys_state.auto_pilot = not sys_state.auto_pilot
-    return {"msg": f"Auto-Pilot: {sys_state.auto_pilot}"}
+fast_api_server = FastAPI(lifespan=lifespan)
+gradio_dashboard = create_gradio_ui()
+app = gr.mount_gradio_app(app=fast_api_server, blocks=gradio_dashboard, path="/")
 
-# ------------------------------------------------------------------------------
-# Entry Point
-# ------------------------------------------------------------------------------
 if __name__ == "__main__":
-    # Port 7860 is mandatory for Hugging Face Spaces
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)