Update scripts/app.py

scripts/app.py

@@ -10,232 +10,395 @@ import os
 import sys
 import json
 import torch
-import shutil
-import yfinance as yf
-
-# --- Fix YFinance Cache Lock ---
-try:
-    cache_dir = "/tmp/pytz_cache"
-    if os.path.exists(cache_dir): shutil.rmtree(cache_dir)
-    os.makedirs(cache_dir, exist_ok=True)
-    yf.set_tz_cache_location(cache_dir)
-except: pass
-
-# --- Add project root to sys.path ---
-try:
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    project_root = os.path.dirname(script_dir)
-    if project_root not in sys.path: sys.path.insert(0, project_root)
-except NameError:
-    project_root = os.getcwd()
-    if project_root not in sys.path: sys.path.insert(0, project_root)
-
-print(f"Project Root set to: {project_root}")
-
-# --- Imports ---
-from scripts.fetch_market_data import fetch_market_data, ASSETS, FRED_IDS
-from scripts.llm_analysis_rag import analyze_agent_decision, analyze_historical_segment, setup_rag_chain, query_rag_chain
+from fetch_market_data import fetch_market_data, ASSETS, FRED_IDS
+from llm_analysis_rag import analyze_agent_decision, analyze_historical_segment
 from stable_baselines3 import SAC
-from scripts.environment import PortfolioEnv
-from scripts.evaluate_baselines import buy_and_hold, equally_weighted_rebalanced
+from environment import PortfolioEnv
+from evaluate_baselines import buy_and_hold, equally_weighted_rebalanced
 
 # --- Configuration ---
-MODEL_PATH = os.path.join(project_root, "checkpoints", "sac_portfolio_model.zip")
+MODEL_PATH = os.path.join("checkpoints", "sac_portfolio_model.zip")
 WINDOW_SIZE = 30
 MACRO_COLS = list(FRED_IDS.values())
-DASHBOARD_DATA_PATH = os.path.join(project_root, "data", "historical_dashboard_data.csv")
+DASHBOARD_DATA_PATH = os.path.join("data", "historical_dashboard_data.csv")
+
+
 TRAIN_START_DATE = "2015-01-01"
-TRAIN_END_DATE = "2023-01-01"
+TRAIN_END_DATE = "2020-12-31"
+
+# Global variable for dashboard data needed for Tabs 3 & 4
 DASHBOARD_DATA_DF = None
 
+# Define Time Period mappings for the dropdown
 TIME_PERIODS = {
-    "6 Months": 180, "1 Year": 365, "2 Years": 730, 
-    "5 Years": 1825, "Max Available": 9999
+    "6 Months": 180,
+    "1 Year": 365,
+    "2 Years": 730,
+    "5 Years": 1825,
+    "Max Available": 9999 # Sentinel value for max
 }
 
-# --- Initialization ---
+# =========================================
+# Initialization Functions
+# =========================================
+
 def initialize_dashboard_data():
+    """Fetches and loads historical data at startup for Tabs 3 & 4."""
     global DASHBOARD_DATA_DF
-    print("--- Initializing Data ---")
+    print("--- Initializing Historical Data for Analyst/Simulation Tabs ---")
+
+    # Fetching last 6 years to support longer analysis periods and simulation
     end_date = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
     start_date = (datetime.now() - timedelta(days=365*6)).strftime('%Y-%m-%d')
-    
-    os.makedirs(os.path.dirname(DASHBOARD_DATA_PATH), exist_ok=True)
+
+    print(f"Fetching historical data from {start_date} to {end_date}...")
+    # This might take a minute on first run
     fetch_market_data(start_date, end_date, DASHBOARD_DATA_PATH)
 
     if os.path.exists(DASHBOARD_DATA_PATH):
         DASHBOARD_DATA_DF = pd.read_csv(DASHBOARD_DATA_PATH, index_col=0, parse_dates=True)
-        DASHBOARD_DATA_DF.dropna(how='all', inplace=True) 
+        # Basic cleaning
+        DASHBOARD_DATA_DF.dropna(how='all', inplace=True)
+        # Calculate equal weight return for dashboard metrics
         asset_cols = [c for c in ASSETS if c in DASHBOARD_DATA_DF.columns]
         if asset_cols:
              DASHBOARD_DATA_DF['Daily_Ret_Eq'] = DASHBOARD_DATA_DF[asset_cols].pct_change().mean(axis=1)
-        print(f"Data loaded. Shape: {DASHBOARD_DATA_DF.shape}")
+        print(f"Data loaded successfully. Shape: {DASHBOARD_DATA_DF.shape}")
+        print(f"Data range: {DASHBOARD_DATA_DF.index.min().date()} to {DASHBOARD_DATA_DF.index.max().date()}")
     else:
-        print("❌ Failed to initialize data.")
+        print("❌ Failed to initialize historical data.")
 
+# Initialize data at startup
 try:
-    setup_rag_chain()
     initialize_dashboard_data()
 except Exception as e:
-    print(f"Init Warning: {e}")
+    print(f"Warning: Data initialization failed. Error: {e}")
+
+
+# =========================================
+# Professional Metrics & Evaluation Functions
+# =========================================
 
-# --- Helper Functions ---
 def evaluate_agent_pro(env, model):
+    """
+    Runs the trained agent on the environment and returns portfolio values.
+    """
     obs, info = env.reset()
     terminated, truncated = False, False
-    portfolio_values = [env.initial_balance]
+    portfolio_values = [env.initial_amount]
+
     while not (terminated or truncated):
         action, _states = model.predict(obs, deterministic=True)
         obs, reward, terminated, truncated, info = env.step(action)
         portfolio_values.append(info['portfolio_value'])
+
+    # Align index with the actual steps taken
     valid_dates = env.df.index[env.window_size-1:]
     return pd.Series(portfolio_values, index=valid_dates[:len(portfolio_values)])
 
 def calculate_metrics_pro(portfolio_values, freq=252, rf=0.0):
-    if len(portfolio_values) < 2: return {k: "N/A" for k in ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility", "Max Drawdown", "Calmar Ratio"]}
+    """
+    Calculates key professional performance metrics from a series of portfolio values.
+    """
+    if len(portfolio_values) < 2:
+        return {k: "N/A" for k in ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility", "Max Drawdown", "Calmar Ratio"]}
+
     returns = portfolio_values.pct_change().dropna()
-    if returns.empty: return {k: "0.00" for k in ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility", "Max Drawdown", "Calmar Ratio"]}
+    if returns.empty:
+         return {k: "0.00%" if "%" in k else "0.00" for k in ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility", "Max Drawdown", "Calmar Ratio"]}
 
     total_return = (portfolio_values.iloc[-1] / portfolio_values.iloc[0]) - 1
     num_years = (len(portfolio_values) - 1) / freq
     cagr = (portfolio_values.iloc[-1] / portfolio_values.iloc[0]) ** (1/num_years) - 1 if num_years > 0 else 0.0
-    sharpe_ratio = np.sqrt(freq) * (returns.mean() - rf) / returns.std() if returns.std() > 0 else 0
+
+    sharpe_ratio = np.sqrt(freq) * (returns.mean() - rf) / returns.std() if returns.std() > 0 else np.nan
+
     downside_returns = returns[returns < 0]
-    sortino_ratio = np.sqrt(freq) * (returns.mean() - rf) / downside_returns.std() if downside_returns.std() > 0 else 0
+    downside_std = downside_returns.std()
+    sortino_ratio = np.sqrt(freq) * (returns.mean() - rf) / downside_std if downside_std > 0 else np.nan
+
     volatility = returns.std() * np.sqrt(freq)
-    peak = portfolio_values.cummax()
-    max_drawdown = ((portfolio_values - peak) / peak).min()
-    calmar_ratio = cagr / abs(max_drawdown) if max_drawdown != 0 else 0
+
+    rolling_max = portfolio_values.cummax()
+    drawdown = portfolio_values / rolling_max - 1.0
+    max_drawdown = drawdown.min()
+
+    calmar_ratio = cagr / abs(max_drawdown) if max_drawdown != 0 and cagr != 0 else np.nan
 
     return {
-        "Total Return": total_return, "CAGR": cagr, "Sharpe Ratio": sharpe_ratio,
-        "Sortino Ratio": sortino_ratio, "Volatility": volatility, "Max Drawdown": max_drawdown,
+        "Total Return": total_return,
+        "CAGR": cagr,
+        "Sharpe Ratio": sharpe_ratio,
+        "Sortino Ratio": sortino_ratio,
+        "Volatility": volatility,
+        "Max Drawdown": max_drawdown,
         "Calmar Ratio": calmar_ratio
     }
 
+# =========================================
+# XAI: Feature Importance Function
+# =========================================
 def calculate_feature_importance(model, obs):
+    """
+    Calculates feature importance using Integrated Gradients on the RL agent's policy network.
+    """
+    # Convert observation to torch tensor and enable gradient tracking
     obs_tensor = torch.as_tensor(obs, dtype=torch.float32, device=model.device)
-    if obs_tensor.dim() == 1: obs_tensor = obs_tensor.unsqueeze(0)
     obs_tensor.requires_grad_()
-    
+
+    # Get the policy network (actor)
     actor = model.policy.actor
+
+    # Define a baseline (e.g., a zero observation)
     baseline = torch.zeros_like(obs_tensor)
+
+    # Number of steps for integral approximation
     steps = 50
+
+    # Generate scaled inputs along the path from baseline to input
     scaled_inputs = [baseline + (float(i) / steps) * (obs_tensor - baseline) for i in range(steps + 1)]
-    
+
     grads = []
     for scaled_input in scaled_inputs:
+        # Forward pass to get action distribution parameters (mean)
         action_mean = actor(scaled_input)
+
+        # We need a scalar output to calculate gradients against.
+        # Here we sum, representing overall sensitivity of the action vector.
         target_output = action_mean.sum()
+
+        # Calculate gradients of the target output with respect to the input features
         grad = torch.autograd.grad(outputs=target_output, inputs=scaled_input)[0]
         grads.append(grad)
 
-    # --- FIX 1: Stack gradients first, then perform arithmetic ---
-    stacked_grads = torch.stack(grads)
-    avg_grads = (stacked_grads[:-1] + stacked_grads[1:]) / 2.0
-    avg_grads = avg_grads.mean(dim=0)
-    # -----------------------------------------------------------
+    # Average the gradients using the trapezoidal rule approximation
+    avg_grads = (grads[:-1] + grads[1:]) / 2.0
+    avg_grads = torch.stack(avg_grads).mean(dim=0)
 
+    # Calculate Integrated Gradients: (input - baseline) * average_gradients
     integrated_grads = (obs_tensor - baseline) * avg_grads
+
+    # Detach, move to cpu, and convert to numpy array
     importance_scores = integrated_grads.detach().cpu().numpy().flatten()
-    
+
+    # Feature Names mapping
+    num_assets = len(ASSETS)
+    num_macro = len(MACRO_COLS)
+
+    # Create feature names based on the observation structure
     feature_names = []
     for i in range(WINDOW_SIZE):
-        for asset in ASSETS: feature_names.append(f"{asset}_t-{WINDOW_SIZE-1-i}")
+        for asset in ASSETS:
+            feature_names.append(f"{asset}_t-{WINDOW_SIZE-1-i}")
     for i in range(WINDOW_SIZE):
-        for macro in MACRO_COLS: feature_names.append(f"{macro}_t-{WINDOW_SIZE-1-i}")
+        for macro in MACRO_COLS:
+            feature_names.append(f"{macro}_t-{WINDOW_SIZE-1-i}")
 
+    # Combine into a dictionary and sort by absolute importance
     feature_importance_dict = dict(zip(feature_names, importance_scores))
+
+    # Aggregate importance by feature type (sum of absolute values across time steps)
     aggregated_importance = {}
     for base_feature in ASSETS + MACRO_COLS:
         total_imp = sum(abs(val) for key, val in feature_importance_dict.items() if key.startswith(base_feature))
         aggregated_importance[base_feature] = total_imp
 
+    # Sort and take top N for display
     top_features = dict(sorted(aggregated_importance.items(), key=lambda item: item[1], reverse=True)[:8])
 
-    fig = px.bar(x=list(top_features.values()), y=list(top_features.keys()), orientation='h',
-        title="Top Influential Features (XAI)", labels={'x': 'Importance', 'y': 'Feature'},
-        color=list(top_features.values()), color_continuous_scale=px.colors.sequential.Viridis)
-    fig.update_layout(template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
-        yaxis={'categoryorder':'total ascending'}, coloraxis_showscale=False, margin=dict(l=10, r=10, t=40, b=10), height=300,
-        hoverlabel=dict(bgcolor="white", font_size=14, font_family="Roboto", font_color="black"))
+    # Create a Plotly bar chart
+    fig = px.bar(
+        x=list(top_features.values()),
+        y=list(top_features.keys()),
+        orientation='h',
+        title="Top Influential Features (XAI)",
+        labels={'x': 'Relative Importance Score', 'y': 'Feature'},
+        color=list(top_features.values()),
+        color_continuous_scale=px.colors.sequential.Viridis
+    )
+    fig.update_layout(
+        template="plotly_dark",
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        yaxis={'categoryorder':'total ascending'},
+        coloraxis_showscale=False,
+        margin=dict(l=10, r=10, t=40, b=10),
+        height=300 # Keep it compact
+    )
+
     return fig
 
-# --- Tab Functions ---
+# =========================================
+# Tab 4 Logic: Historical Simulation 
+# =========================================
+
 def run_historical_simulation(start_date_str, end_date_str):
-    if DASHBOARD_DATA_DF is None: return go.Figure(), "Data not initialized.", None
-    yield go.Figure(), "Preparing...", None
+    """
+    Runs the RL agent on historical data and compares to baselines using professional metrics.
+    """
+    if DASHBOARD_DATA_DF is None:
+        return go.Figure(), "Data not initialized. Please restart app.", gr.update(visible=False)
+
+    status_msg = "Preparing simulation..."
+    yield go.Figure(), status_msg, gr.update(visible=False)
+
     try:
-        start_date, end_date = pd.to_datetime(start_date_str), pd.to_datetime(end_date_str)
+        # 1. Validate and Slice Data
+        try:
+            start_date = pd.to_datetime(start_date_str)
+            end_date = pd.to_datetime(end_date_str)
+        except ValueError:
+             yield go.Figure(), "Error: Invalid date format. Use YYYY-MM-DD.", gr.update(visible=False)
+             return
+
         if start_date < DASHBOARD_DATA_DF.index.min() or end_date > DASHBOARD_DATA_DF.index.max():
-             yield go.Figure(), "Dates out of range.", None; return
-        
+             avail_start = DASHBOARD_DATA_DF.index.min().date()
+             avail_end = DASHBOARD_DATA_DF.index.max().date()
+             yield go.Figure(), f"Error: Selected dates outside available range ({avail_start} to {avail_end}).", gr.update(visible=False)
+             return
+
         df_slice = DASHBOARD_DATA_DF.loc[start_date:end_date].copy()
         asset_cols_only = [c for c in ASSETS if c in df_slice.columns]
-        
-        yield go.Figure(), "Running RL Agent...", None
-        env = PortfolioEnv(df_slice, WINDOW_SIZE, initial_balance=10000)
-        if not os.path.exists(MODEL_PATH): raise FileNotFoundError("Model not found")
+
+        if len(df_slice) < WINDOW_SIZE + 10:
+             yield go.Figure(), "Error: Time period too short for simulation.", gr.update(visible=False)
+             return
+
+        # 2. Setup Environment and Agent
+        status_msg = "Running RL Agent simulation..."
+        yield go.Figure(), status_msg, gr.update(visible=False)
+
+        env = PortfolioEnv(df_slice, WINDOW_SIZE, initial_amount=10000)
+
+        if not os.path.exists(MODEL_PATH):
+             raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
         model = SAC.load(MODEL_PATH)
-        rl_vals = evaluate_agent_pro(env, model)
 
-        yield go.Figure(), "Calculating baselines...", None
-        bnh_vals = buy_and_hold(df_slice[asset_cols_only], initial_balance=10000).loc[rl_vals.index[0]:]
-        bnh_vals = bnh_vals / bnh_vals.iloc[0] * 10000
-        eq_vals = equally_weighted_rebalanced(df_slice[asset_cols_only], initial_balance=10000).loc[rl_vals.index[0]:]
-        eq_vals = eq_vals / eq_vals.iloc[0] * 10000
+        # 3. Run Simulation Loop & Get Values using Pro Function
+        rl_portfolio_series = evaluate_agent_pro(env, model)
+
+        # 4. Calculate Baselines using Pro Functions
+        status_msg = "Calculating baselines and metrics..."
+        yield go.Figure(), status_msg, gr.update(visible=False)
 
+        # Pass only asset columns to baseline functions
+        bnh_portfolio_series = buy_and_hold(df_slice[asset_cols_only], initial_amount=10000)
+        # Realign B&H index to match RL agent's start date
+        bnh_portfolio_series = bnh_portfolio_series.loc[rl_portfolio_series.index[0]:]
+        # Normalize B&H starting value to match RL agent's start
+        bnh_portfolio_series = bnh_portfolio_series / bnh_portfolio_series.iloc[0] * 10000
+
+        eq_portfolio_series = equally_weighted_rebalanced(df_slice[asset_cols_only], initial_amount=10000)
+        eq_portfolio_series = eq_portfolio_series.loc[rl_portfolio_series.index[0]:]
+        eq_portfolio_series = eq_portfolio_series / eq_portfolio_series.iloc[0] * 10000
+
+        # 5. Generate Plot
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=rl_vals.index, y=rl_vals, name='RL Agent (SAC)', line=dict(color='#10b981', width=3)))
-        fig.add_trace(go.Scatter(x=bnh_vals.index, y=bnh_vals, name='Buy & Hold (SPY)', line=dict(color='#6b7280', dash='dash')))
-        fig.add_trace(go.Scatter(x=eq_vals.index, y=eq_vals, name='Equal Weight', line=dict(color='#a855f7', dash='dot')))
-        fig.update_layout(title="Simulation Performance", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', hovermode="x unified",
-            legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1), hoverlabel=dict(bgcolor="white", font_size=14, font_color="black"))
-
-        rl_m, bnh_m, eq_m = calculate_metrics_pro(rl_vals), calculate_metrics_pro(bnh_vals), calculate_metrics_pro(eq_vals)
-        def fmt(v, p=True): return f"{v:.2%}" if p else f"{v:.2f}"
-        
-        metrics = {
-            "Metric": ["Return", "CAGR", "Sharpe", "Sortino", "Vol", "MaxDD", "Calmar"],
-            "RL Agent": [fmt(rl_m["Total Return"]), fmt(rl_m["CAGR"]), fmt(rl_m["Sharpe Ratio"],0), fmt(rl_m["Sortino Ratio"],0), fmt(rl_m["Volatility"]), fmt(rl_m["Max Drawdown"]), fmt(rl_m["Calmar Ratio"],0)],
-            "Buy&Hold": [fmt(bnh_m["Total Return"]), fmt(bnh_m["CAGR"]), fmt(bnh_m["Sharpe Ratio"],0), fmt(bnh_m["Sortino Ratio"],0), fmt(bnh_m["Volatility"]), fmt(bnh_m["Max Drawdown"]), fmt(bnh_m["Calmar Ratio"],0)],
-            "Eq Weight": [fmt(eq_m["Total Return"]), fmt(eq_m["CAGR"]), fmt(eq_m["Sharpe Ratio"],0), fmt(eq_m["Sortino Ratio"],0), fmt(eq_m["Volatility"]), fmt(eq_m["Max Drawdown"]), fmt(eq_m["Calmar Ratio"],0)]
+        fig.add_trace(go.Scatter(x=rl_portfolio_series.index, y=rl_portfolio_series, mode='lines', name='RL Agent (SAC)', line=dict(color='#10b981', width=3)))
+        fig.add_trace(go.Scatter(x=bnh_portfolio_series.index, y=bnh_portfolio_series, mode='lines', name='Buy & Hold (SPY)', line=dict(color='#6b7280', dash='dash')))
+        fig.add_trace(go.Scatter(x=eq_portfolio_series.index, y=eq_portfolio_series, mode='lines', name='Equal Weighted', line=dict(color='#a855f7', dash='dot')))
+
+        fig.update_layout(
+            title="Simulation: Strategy Performance Comparison ($10k Start)",
+            xaxis_title="Date",
+            yaxis_title="Portfolio Value ($)",
+            template="plotly_dark",
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            hovermode="x unified",
+            legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+        )
+
+        # 6. Calculate Professional Metrics Table
+        rl_m = calculate_metrics_pro(rl_portfolio_series)
+        bnh_m = calculate_metrics_pro(bnh_portfolio_series)
+        eq_m = calculate_metrics_pro(eq_portfolio_series)
+
+        # Helper to format based on metric type
+        def fmt(val, is_pct=True):
+            if pd.isna(val): return "N/A"
+            return f"{val:.2%}" if is_pct else f"{val:.2f}"
+
+        metrics_data = {
+            "Metric": ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility (Ann.)", "Max Drawdown", "Calmar Ratio"],
+            "RL Agent (SAC)": [fmt(rl_m["Total Return"]), fmt(rl_m["CAGR"]), fmt(rl_m["Sharpe Ratio"], False), fmt(rl_m["Sortino Ratio"], False), fmt(rl_m["Volatility"]), fmt(rl_m["Max Drawdown"]), fmt(rl_m["Calmar Ratio"], False)],
+            "Buy & Hold (SPY)": [fmt(bnh_m["Total Return"]), fmt(bnh_m["CAGR"]), fmt(bnh_m["Sharpe Ratio"], False), fmt(bnh_m["Sortino Ratio"], False), fmt(bnh_m["Volatility"]), fmt(bnh_m["Max Drawdown"]), fmt(bnh_m["Calmar Ratio"], False)],
+            "Equal Weighted": [fmt(eq_m["Total Return"]), fmt(eq_m["CAGR"]), fmt(eq_m["Sharpe Ratio"], False), fmt(eq_m["Sortino Ratio"], False), fmt(eq_m["Volatility"]), fmt(eq_m["Max Drawdown"]), fmt(eq_m["Calmar Ratio"], False)],
         }
-        yield fig, "Complete", pd.DataFrame(metrics)
+        metrics_df = pd.DataFrame(metrics_data)
+
+        # Format the dataframe as a markdown table for cleaner display
+        metrics_md = metrics_df.to_markdown(index=False)
+        final_metrics_display = f"### 📊 Professional Performance Metrics\n\n{metrics_md}"
+
+        yield fig, "Simulation Complete.", final_metrics_display
+
     except Exception as e:
-        yield go.Figure(), f"Error: {e}", None
+        import traceback
+        traceback.print_exc()
+        yield go.Figure(), f"Error during simulation: {str(e)}", gr.update(visible=False)
+
+
+# =========================================
+# Tab 3 Logic: Historical Data Analyst
+# =========================================
+
+def run_historical_analysis(selected_assets, period_name):
+    """Backend for Tab 3."""
+    if DASHBOARD_DATA_DF is None or not selected_assets:
+        return go.Figure(), "Please wait for data initialization or select assets."
+
+    status_html = """<div style="color: #9ca3af;">🔄 Processing data and running AI analysis...</div>"""
+    yield go.Figure(), status_html
 
-def run_hist_analysis(selected_assets, period):
-    if DASHBOARD_DATA_DF is None: return go.Figure(), "No Data"
-    yield go.Figure(), "Analyzing..."
     try:
-        days = TIME_PERIODS.get(period, 365)
-        start = datetime.now() - timedelta(days=days)
-        valid = [a for a in selected_assets if a in DASHBOARD_DATA_DF.columns]
-        df_sub = DASHBOARD_DATA_DF.loc[start:, valid].copy()
-        
-        if df_sub.empty: return go.Figure(), "No Data"
-        
-        df_norm = df_sub / df_sub.iloc[0] * 100
-        fig = px.line(df_norm, x=df_norm.index, y=df_norm.columns, title=f"Performance {period}", color_discrete_sequence=px.colors.qualitative.Bold)
-        fig.update_layout(template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', hoverlabel=dict(bgcolor="white", font_size=14, font_color="black"))
-        
-        txt = analyze_historical_segment(df_sub, valid, period)
-        yield fig, f"### 🤖 Analysis\n\n{txt}"
+        # 1. Filter Data by Time Period
+        days = TIME_PERIODS.get(period_name, 365)
+        cutoff_date = datetime.now() - timedelta(days=days)
+        valid_assets = [a for a in selected_assets if a in DASHBOARD_DATA_DF.columns]
+        if not valid_assets:
+             yield go.Figure(), "Error: Selected assets not found in available data."
+             return
+        df_filtered = DASHBOARD_DATA_DF.loc[cutoff_date:, valid_assets].copy()
+        if df_filtered.empty:
+             yield go.Figure(), f"No data found for the selected period: {period_name}"
+             return
+
+        # 2. Generate Normalized Price Plot
+        df_normalized = df_filtered / df_filtered.iloc[0] * 100
+        fig = px.line(df_normalized, x=df_normalized.index, y=df_normalized.columns,
+                      title=f"Performance Comparison: {period_name} (Base=100)",
+                      color_discrete_sequence=px.colors.qualitative.Bold)
+        fig.update_layout(template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+            yaxis_title="Normalized Price", xaxis_title="Date", legend_title_text="", hovermode="x unified")
+
+        # 3. Run AI Analysis
+        analysis_text = analyze_historical_segment(df_filtered, valid_assets, period_name)
+        formatted_analysis = f"### 🤖 AI Analyst Report: {period_name}\n\n{analysis_text}"
+        yield fig, formatted_analysis
+
     except Exception as e:
-        yield go.Figure(), f"Error: {e}"
+        import traceback
+        traceback.print_exc()
+        yield go.Figure(), f"### Error during analysis\n\n{str(e)}"
+
+
+# =========================================
+# Tab 2 Logic: Forecast & Analysis (XAI)
+# =========================================
 
-def get_prediction_data(window_size=30):
+def get_latest_data_window(window_size=30):
+    """Fetches latest data needed for prediction."""
     print("Fetching prediction data...")
-    lookback = window_size + 150
-    end = datetime.now().strftime('%Y-%m-%d')
-    start = (datetime.now() - timedelta(days=lookback)).strftime('%Y-%m-%d')
-    tmp_file = os.path.join(project_root, "data", "temp_pred.csv")
-    fetch_market_data(start, end, tmp_file)
-    if not os.path.exists(tmp_file): raise Exception("Fetch failed.")
-    df = pd.read_csv(tmp_file, index_col=0, parse_dates=True)
+    lookback_days = window_size + 150
+    end_date = datetime.now().strftime('%Y-%m-%d')
+    start_date = (datetime.now() - timedelta(days=lookback_days)).strftime('%Y-%m-%d')
+    temp_filename = os.path.join(project_root, "data", "temp_gradio_prediction_data.csv")
+    fetch_market_data(start_date, end_date, temp_filename)
+    if not os.path.exists(temp_filename): raise Exception("Failed to fetch market data file.")
+    df = pd.read_csv(temp_filename, index_col=0, parse_dates=True)
     df.dropna(inplace=True)
-    if len(df) < window_size: raise Exception("Not enough data.")
+    if len(df) < window_size: raise Exception(f"Not enough clean data fetched for prediction.")
     return df.iloc[-window_size:].copy()
 
 def prepare_observation(data_window):
@@ -244,141 +407,257 @@ def prepare_observation(data_window):
     norm_prices = price_data / (price_data[0] + 1e-8)
     norm_macro = macro_data / (macro_data[0] + 1e-8)
     obs = np.concatenate([norm_prices, norm_macro], axis=1)
-    # Return flattened obs for prediction AND flat obs for XAI calc function 
-    # (Note: XAI calc func re-shapes it internally, but expects a tensor)
+    # Return both flattened obs for model and raw obs for XAI
     return obs.flatten().astype(np.float32), obs.astype(np.float32), data_window
 
 def predict_and_analyze():
-    yield "Starting...", None, go.Figure(), "Loading..."
+    """Main function for Forecast Tab."""
+    status_msg = "Starting process..."
+    loading_html = """<div style="color: #9ca3af;">🔄 Fetching data & running prediction...</div>"""
+    # Update to yield an empty plot for the XAI chart initially
+    yield status_msg, None, go.Figure(), loading_html
+
     try:
-        data_window = get_prediction_data(WINDOW_SIZE)
+        data_window = get_latest_data_window(WINDOW_SIZE)
+        # Get flattened obs for prediction and raw obs for XAI
         flat_obs, raw_obs, df_window_for_analyst = prepare_observation(data_window)
-        
-        if not os.path.exists(MODEL_PATH): raise FileNotFoundError("Model not found.")
+
+        if not os.path.exists(MODEL_PATH): raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
         model = SAC.load(MODEL_PATH)
-        
-        # --- FIX 2: Pass the FLATTENED observation to XAI function ---
-        # The XAI function logic expects an input that matches the model's input layer.
-        yield "XAI Calc...", None, go.Figure(), "Calculating XAI..."
-        xai_plot = calculate_feature_importance(model, flat_obs)
 
+        # --- XAI: Calculate Feature Importance ---
+        status_msg = "Calculating feature importance..."
+        yield status_msg, None, go.Figure(), loading_html
+        xai_plot = calculate_feature_importance(model, raw_obs)
+
+        # --- Prediction ---
         action, _ = model.predict(flat_obs, deterministic=True)
-        exp_act = np.exp(np.asarray(action).flatten())
-        weights = exp_act / np.sum(exp_act)
-        
-        allocs = {ASSETS[i]: weights[i] for i in range(len(ASSETS))}
-        allocs['Cash'] = weights[-1]
-        alloc_df = pd.DataFrame(list(allocs.items()), columns=['Asset', 'Alloc'])
-        alloc_df['Alloc'] = alloc_df['Alloc'].apply(lambda x: f"{x:.2%}")
-
-        yield "AI Analysis...", alloc_df, xai_plot, "Running AI..."
-        llm_allocs = {k: float(v) for k, v in allocs.items()}
-        res = analyze_agent_decision(df_window_for_analyst, llm_allocs)
-        
-        if isinstance(res, dict):
-            strat, risk, just, conf = res.get('strategy_summary','N/A'), res.get('risk_level','N/A').upper(), res.get('justification','N/A'), res.get('confidence_score','N/A')
-            border_col = "#ef4444" if 'HIGH' in risk else "#10b981"
-            bg_col = "#7f1d1d" if 'HIGH' in risk else "#064e3b"
-            icon = "⛔" if 'HIGH' in risk else "🚀"
-            status = "TRADE BLOCKED" if 'HIGH' in risk else "TRADE APPROVED"
-            
-            html = f"""<div style="background-color: #1f2937; padding: 20px; border-radius: 12px; border: 1px solid #374151;">
-                <h3 style="margin-top: 0; color: #e5e7eb;">🤖 AI Report</h3>
-                <p><strong>Strategy:</strong> <span style="color:#d1d5db">{strat}</span></p>
-                <p><strong>Risk:</strong> <span style="color:{border_col}; font-weight:bold">{risk}</span></p>
-                <p><strong>Reason:</strong> <span style="color:#d1d5db">{just}</span></p>
-                <p><strong>Conf:</strong> <span style="color:#d1d5db">{conf}/10</span></p></div>
-                <div style="background-color:{bg_col}; color:white; padding:15px; margin-top:10px; border-radius:12px; text-align:center; font-weight:bold;">{icon} {status}</div>"""
+        exp_action = np.exp(np.asarray(action).flatten())
+        weights = exp_action / np.sum(exp_action)
+        allocations_dict = {asset: weights[i] for i, asset in enumerate(ASSETS)}
+        allocations_dict['Cash'] = weights[-1]
+        alloc_df = pd.DataFrame(list(allocations_dict.items()), columns=['Asset', 'Proposed Allocation'])
+        alloc_df['Proposed Allocation'] = alloc_df['Proposed Allocation'].apply(lambda x: f"{x:.2%}")
+
+        status_msg = "Prediction done. Running AI Risk Analysis..."
+        analysing_html = """<div style="color: #9ca3af;">🤖 Running Qwen-2.5-3B Risk Analysis...</div>"""
+        # Yield XAI plot along with other outputs
+        yield status_msg, alloc_df, xai_plot, analysing_html
+
+        allocations_for_llm = {k: float(v) for k, v in allocations_dict.items()}
+        analysis_result = analyze_agent_decision(df_window_for_analyst, allocations_for_llm)
+        status_msg = "Analysis complete!"
+
+        if isinstance(analysis_result, dict):
+            strat = analysis_result.get('strategy_summary', 'N/A')
+            risk = analysis_result.get('risk_level', 'N/A').upper()
+            just = analysis_result.get('justification', 'N/A')
+            conf = analysis_result.get('confidence_score', 'N/A')
+            if 'HIGH' in risk:
+                risk_css = "color: #ef4444; font-weight: bold;"
+                status_bg = "#7f1d1d"
+                status_border = "#ef4444"
+                status_icon = "⛔"
+                status_text = "TRADE BLOCKED: High Risk Detected"
+            else:
+                risk_css = "color: #10b981; font-weight: bold;"
+                status_bg = "#064e3b"
+                status_border = "#10b981"
+                status_icon = "🚀"
+                status_text = "TRADE APPROVED"
+
+            report_html = f"""
+            <div style="background-color: #1f2937; padding: 20px; border-radius: 12px 12px 0 0; border: 1px solid #374151; border-bottom: none;">
+                <h3 style="margin-top: 0; color: #e5e7eb;">🤖 AI Risk Analyst Report</h3>
+                <div style="margin-bottom: 15px;"><strong style="color: #9ca3af;">Strategy:</strong><br><span style="color: #d1d5db;">{strat}</span></div>
+                <div style="margin-bottom: 15px;"><strong style="color: #9ca3af;">Risk Level:</strong><span style="margin-left: 8px; {risk_css}">{risk}</span></div>
+                <div style="margin-bottom: 15px;"><strong style="color: #9ca3af;">Justification:</strong><br><span style="color: #d1d5db;">{just}</span></div>
+                <div><strong style="color: #9ca3af;">Confidence:</strong> <span style="color: #d1d5db;">{conf}/10</span></div>
+            </div>
+            <div style="background-color: {status_bg}; color: white; padding: 15px; border-radius: 0 0 12px 12px; border: 2px solid {status_border}; text-align: center; font-size: 1.2em; font-weight: bold; display: flex; align-items: center; justify-content: center;">
+                <span style="margin-right: 10px; font-size: 1.4em;">{status_icon}</span>{status_text}
+            </div>"""
         else:
-            html = f"<div style='color:red'>{str(res)}</div>"
-        
-        yield "Done", alloc_df, xai_plot, html
+            report_html = f"""<div style="padding: 20px; background-color: #7f1d1d; color: #fca5a5; border-radius: 12px;"><h3>❌ Analysis Failed to Parse</h3><p>{str(analysis_result)}</p></div>"""
+        # Final yield with all outputs including XAI plot
+        yield status_msg, alloc_df, xai_plot, report_html
     except Exception as e:
         import traceback
         traceback.print_exc()
-        yield f"Error: {str(e)}", None, go.Figure(), f"Error: {str(e)}"
-
-# Dashboard Placeholders
-def get_dash_metrics():
-    if DASHBOARD_DATA_DF is None: return "$---", "..."
-    cum_ret = (1 + DASHBOARD_DATA_DF['Daily_Ret_Eq'].fillna(0)).cumprod()
-    curr = 100000 * cum_ret.iloc[-1]
-    last = DASHBOARD_DATA_DF['Daily_Ret_Eq'].iloc[-1] * 100
-    col = "#10b981" if last >= 0 else "#ef4444"
-    return f"${curr:,.2f}", f"<span style='color:{col}'>{last:+.2f}%</span>"
-
-def get_hist_plot():
-    if DASHBOARD_DATA_DF is None: return go.Figure()
-    dates = DASHBOARD_DATA_DF.index
-    vals = 100000 * (1 + DASHBOARD_DATA_DF['Daily_Ret_Eq'].fillna(0)).cumprod()
-    fig = go.Figure(go.Scatter(x=dates, y=vals, mode='lines', name='Portfolio', line=dict(color='#10b981', width=2)))
-    fig.update_layout(title="Simulated Net Worth", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', hoverlabel=dict(bgcolor="white", font_size=14, font_color="black"))
+        status_msg = f"Error: {str(e)}"
+        error_html = f"""<div style="padding: 20px; background-color: #7f1d1d; color: #fca5a5; border-radius: 12px;"><h3>❌ Process Error</h3><p>{str(e)}</p></div>"""
+        # Final yield in case of error
+        yield status_msg, None, go.Figure(), error_html
+
+
+# =========================================
+# Tab 1 Logic: Live Dashboard (DUMMY DATA)
+# =========================================
+def get_dashboard_metrics():
+    return "$135,400", "+3.07%"
+
+def get_portfolio_history_plot():
+    dates = pd.date_range(start="2023-01-01", periods=100)
+    np.random.seed(42)
+    rl_returns = np.random.normal(0.001, 0.01, 100)
+    bnh_returns = np.random.normal(0.0005, 0.012, 100)
+    rl_value = 10000 * np.cumprod(1 + rl_returns)
+    bnh_value = 10000 * np.cumprod(1 + bnh_returns)
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=dates, y=rl_value, mode='lines', name='RL Agent (Live)', line=dict(color='#10b981', width=3)))
+    fig.add_trace(go.Scatter(x=dates, y=bnh_value, mode='lines', name='Benchmark', line=dict(color='#6b7280', dash='dash')))
+    fig.update_layout(title="Portfolio Net Worth (Live Tracking)", xaxis_title="Date", yaxis_title="Net Worth ($)", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1))
     return fig
 
-def get_alloc_plot():
-    fig = px.pie(values=[0.2]*5, names=ASSETS, title="Target Allocation", color_discrete_sequence=px.colors.qualitative.Bold)
-    fig.update_layout(template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)')
+def get_current_allocation_plot():
+    labels = ASSETS + ['Cash']
+    values = [0.25, 0.10, 0.30, 0.15, 0.05, 0.15]
+    fig = px.pie(values=values, names=labels, title="Current Holdings Breakdown", color_discrete_sequence=px.colors.qualitative.Bold)
+    fig.update_traces(textposition='inside', textinfo='percent+label', hole=.4)
+    fig.update_layout(template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', legend=dict(orientation="h", yanchor="bottom", y=-0.1))
     return fig
 
-def get_trans():
-    return pd.DataFrame([["2025-11-24", "REBALANCE", "ALL", "N/A"]], columns=["Date", "Type", "Asset", "Value"])
+def get_recent_transactions():
+    data = [["2025-11-24", "Rebalance", "MULTIPLE", "N/A"], ["2025-11-24", "SELL", "SPY", "$4,500"], ["2025-11-24", "BUY", "TLT", "$4,200"], ["2025-11-21", "BUY", "BTC-USD", "$1,000"]]
+    return pd.DataFrame(data, columns=["Date", "Type", "Asset", "Approx. Value"])
+
+
+# =========================================
+# Gradio Interface
+# =========================================
 
-# --- UI ---
 custom_css = """
 .metric-box { background-color: #1f2937; padding: 20px; border-radius: 12px; border: 1px solid #374151; text-align: center; }
-.metric-label { font-size: 1.1em; color: #9ca3af; }
+.metric-label { font-size: 1.1em; color: #9ca3af; margin-bottom: 5px; }
 .metric-value { font-size: 2.2em; font-weight: 700; color: #e5e7eb; }
+.disclaimer-box { background-color: #374151; padding: 15px; border-radius: 8px; border-left: 4px solid #f59e0b; color: #d1d5db; font-size: 0.9em; margin-bottom: 20px; }
 """
 
-# REMOVED theme= argument to fix Gradio conflict
-with gr.Blocks(css=custom_css, title="Deep RL Manager") as demo:
-    gr.HTML("""<script>function f(){document.body.classList.add('dark');} f(); setTimeout(f, 500);</script>""")
+# theme = gr.themes.Soft(primary_hue="emerald", secondary_hue="slate", neutral_hue="zinc").set(
+#     body_background_fill="#111827", block_background_fill="#1f2937", block_border_width="1px", block_border_color="#374151"
+# )
+
+with gr.Blocks(
+    # theme=theme, css=custom_css,
+               title="Deep RL Portfolio Manager") as demo:
+    gr.HTML("""<script>function forceDark(){document.body.classList.add('dark');} forceDark(); setTimeout(forceDark, 500);</script>""")
+
     gr.Markdown("# 🧠 Deep RL & LLM Portfolio Manager")
-    
+
     with gr.Tabs():
-        with gr.TabItem("📊 Dashboard"):
-            nw, ch = get_dash_metrics()
+        # ================= TAB 1: DASHBOARD (RESTORED) =================
+        with gr.TabItem("📊 Live Dashboard"):
+            # Metrics Row
             with gr.Row():
-                gr.HTML(f"<div class='metric-box'><div class='metric-label'>Simulated Net Worth</div><div class='metric-value'>{nw}</div></div>")
-                gr.HTML(f"<div class='metric-box'><div class='metric-label'>24h Change</div><div class='metric-value' style='color:#10b981'>{ch}</div></div>")
+                nw_val, dc_val = get_dashboard_metrics()
+                with gr.Column(elem_classes=["metric-box"]):
+                    gr.HTML(f"<div class='metric-label'>Current Net Worth</div><div class='metric-value'>{nw_val}</div>")
+                with gr.Column(elem_classes=["metric-box"]):
+                    gr.HTML(f"<div class='metric-label'>24h Change</div><div class='metric-value' style='color: #10b981;'>{dc_val}</div>")
+
+            # Main Chart row
             with gr.Row():
-                with gr.Column(scale=3): gr.Plot(value=get_hist_plot())
-                with gr.Column(scale=1): gr.Plot(value=get_alloc_plot())
+                with gr.Column(scale=3):
+                    history_chart = gr.Plot(value=get_portfolio_history_plot(), label="Net Worth History")
+
+            # Bottom Row: Allocations and Transactions
             with gr.Row():
-                with gr.Column(): gr.Dataframe(value=get_trans(), label="Transactions")
+                with gr.Column(scale=1):
+                    allocation_chart = gr.Plot(value=get_current_allocation_plot(), label="Current Allocation")
+                with gr.Column(scale=2):
+                    gr.Markdown("### Recent Transactions")
+                    transactions_table = gr.Dataframe(value=get_recent_transactions(), interactive=False, wrap=True)
+
+        # ================= TAB 2: FORECAST (UPDATED with XAI) =================
+        with gr.TabItem("🔮 Forecast & AI Analysis"):
+            gr.Markdown("### Generate Tomorrow's Portfolio Strategy")
+            run_btn = gr.Button("🚀 Run Overnight Analysis", variant="primary", size="lg")
+            status_output = gr.Textbox(label="System Status", placeholder="Ready...", interactive=False, lines=1)
+            gr.Markdown("---")
 
-        with gr.TabItem("🔮 Forecast"):
-            btn = gr.Button("🚀 Run Analysis", variant="primary")
-            stat = gr.Textbox(label="Status", interactive=False)
             with gr.Row():
+                # Left Column: Allocations & XAI Plot
                 with gr.Column(scale=2):
-                    alloc = gr.Dataframe(label="Allocation")
-                    xai = gr.Plot(label="XAI")
+                    gr.Markdown("### 📈 Suggested Position")
+                    allocation_output = gr.Dataframe(headers=["Asset", "Allocation"], datatype=["str", "str"], interactive=False)
+
+                    # NEW: XAI Feature Importance Plot
+                    gr.Markdown("### 🧠 Why did the agent choose this?")
+                    xai_output_plot = gr.Plot(label="Top Influential Factors (XAI)", show_label=False)
+
+                # Right Column: AI Analysis Report
                 with gr.Column(scale=3):
-                    rep = gr.HTML(label="Report")
-            btn.click(predict_and_analyze, None, [stat, alloc, xai, rep])
+                    analysis_report_html = gr.HTML(label="AI Risk Analysis Report")
+
+            # Updated click event with new XAI output
+            run_btn.click(
+                fn=predict_and_analyze,
+                inputs=None,
+                outputs=[status_output, allocation_output, xai_output_plot, analysis_report_html]
+            )
+
+        # ================= TAB 3: HISTORICAL DATA ANALYST =================
+        with gr.TabItem("📅 Historical Data Analyst"):
+            gr.Markdown("### Analyze Past Market Performance with AI")
 
-        with gr.TabItem("📅 Analyst"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    ticks = ASSETS + FRED_IDS.values() if DASHBOARD_DATA_DF is None else [c for c in ASSETS + list(FRED_IDS.values()) if c in DASHBOARD_DATA_DF.columns]
-                    sel = gr.Dropdown(choices=ticks, multiselect=True, label="Assets")
-                    per = gr.Dropdown(choices=list(TIME_PERIODS.keys()), value="1 Year", label="Period")
-                    btn = gr.Button("Analyze", variant="primary")
+                    all_tickers_hist = ASSETS + list(FRED_IDS.values())
+                    if DASHBOARD_DATA_DF is not None:
+                        available_tickers_hist = [t for t in all_tickers_hist if t in DASHBOARD_DATA_DF.columns]
+                    else:
+                        available_tickers_hist = []
+                    default_tickers_hist = available_tickers_hist[:3] if available_tickers_hist else []
+
+                    asset_selector = gr.Dropdown(choices=available_tickers_hist, value=default_tickers_hist, multiselect=True, label="1. Select Assets")
+                    period_selector = gr.Dropdown(choices=list(TIME_PERIODS.keys()), value="1 Year", label="2. Select Period")
+                    analyze_btn = gr.Button("🔎 Run Analysis", variant="primary")
+
                 with gr.Column(scale=3):
-                    plot = gr.Plot()
-            out = gr.Markdown()
-            btn.click(run_hist_analysis, [sel, per], [plot, out])
+                    historical_plot = gr.Plot(label="Performance Plot")
+
+            gr.Markdown("---")
+            historical_analysis_md = gr.Markdown("### 🤖 AI Analyst Report\n\n*Click 'Run Analysis' to generate.*")
+
+            analyze_btn.click(
+                fn=run_historical_analysis,
+                inputs=[asset_selector, period_selector],
+                outputs=[historical_plot, historical_analysis_md]
+            )
+
+        # ================= TAB 4: HISTORICAL SIMULATION (UPDATED with Pro Metrics) =================
+        with gr.TabItem("🔙 Historical Simulation"):
+            gr.Markdown("### Backtest the RL Agent against Baselines")
+
+            # Disclaimer Box
+            gr.HTML(f"""
+            <div class='disclaimer-box'>
+                <strong>⚠️ IMPORTANT DISCLAIMER:</strong> The RL model was trained on data from approximately
+                <strong>{TRAIN_START_DATE} to {TRAIN_END_DATE}</strong>. Running simulations outside or overlapping significantly
+                with this period may not accurately reflect real-world performance (lookahead bias or out-of-distribution data).
+                Use for educational purposes only.
+            </div>
+            """)
 
-        with gr.TabItem("🔙 Simulation"):
             with gr.Row():
-                s_d = gr.Textbox(label="Start", value="2024-01-01")
-                e_d = gr.Textbox(label="End", value="2025-01-01")
-                btn = gr.Button("Run", variant="primary")
-                stat = gr.Textbox(label="Status")
-            plot = gr.Plot()
-            met = gr.Dataframe(label="Metrics")
-            btn.click(run_historical_simulation, [s_d, e_d], [plot, stat, met])
+                with gr.Column(scale=1):
+                    start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", value=(datetime.now() - timedelta(days=365)).strftime('%Y-%m-%d'))
+                    end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", value=(datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d'))
+                    sim_btn = gr.Button("▶️ Run Simulation", variant="primary")
+                    sim_status = gr.Textbox(label="Status", interactive=False, lines=1)
+
+                with gr.Column(scale=3):
+                    sim_plot = gr.Plot(label="Simulation Performance")
+
+            gr.Markdown("---")
+            # Updated to Markdown component for better table formatting
+            sim_metrics_md = gr.Markdown("### 📊 Professional Performance Metrics\n\n*Run simulation to see metrics.*")
+
+            sim_btn.click(
+                fn=run_historical_simulation,
+                inputs=[start_date_input, end_date_input],
+                outputs=[sim_plot, sim_status, sim_metrics_md]
+            )
 
 if __name__ == "__main__":
     demo.queue().launch(server_name="0.0.0.0", server_port=7860, debug=True, share=True)