Update scripts/app.py

scripts/app.py

@@ -10,395 +10,232 @@ import os
 import sys
 import json
 import torch
-from fetch_market_data import fetch_market_data, ASSETS, FRED_IDS
-from llm_analysis_rag import analyze_agent_decision, analyze_historical_segment
+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 stable_baselines3 import SAC
-from environment import PortfolioEnv
+from scripts.environment import PortfolioEnv
 from scripts.evaluate_baselines import buy_and_hold, equally_weighted_rebalanced
 
 # --- Configuration ---
-MODEL_PATH = os.path.join("checkpoints", "sac_portfolio_model.zip")
+MODEL_PATH = os.path.join(project_root, "checkpoints", "sac_portfolio_model.zip")
 WINDOW_SIZE = 30
 MACRO_COLS = list(FRED_IDS.values())
-DASHBOARD_DATA_PATH = os.path.join("data", "historical_dashboard_data.csv")
-
-# *** UPDATE THESE DATES TO MATCH YOUR ACTUAL TRAINING PERIOD ***
+DASHBOARD_DATA_PATH = os.path.join(project_root, "data", "historical_dashboard_data.csv")
 TRAIN_START_DATE = "2015-01-01"
 TRAIN_END_DATE = "2023-01-01"
-
-# 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 # Sentinel value for max
+    "6 Months": 180, "1 Year": 365, "2 Years": 730, 
+    "5 Years": 1825, "Max Available": 9999
 }
 
-# =========================================
-# Initialization Functions
-# =========================================
-
+# --- Initialization ---
 def initialize_dashboard_data():
-    """Fetches and loads historical data at startup for Tabs 3 & 4."""
     global DASHBOARD_DATA_DF
-    print("--- Initializing Historical Data for Analyst/Simulation Tabs ---")
-    
-    # Fetching last 6 years to support longer analysis periods and simulation
+    print("--- Initializing Data ---")
     end_date = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
     start_date = (datetime.now() - timedelta(days=365*6)).strftime('%Y-%m-%d')
     
-    print(f"Fetching historical data from {start_date} to {end_date}...")
-    # This might take a minute on first run
+    os.makedirs(os.path.dirname(DASHBOARD_DATA_PATH), exist_ok=True)
     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)
-        # 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 successfully. Shape: {DASHBOARD_DATA_DF.shape}")
-        print(f"Data range: {DASHBOARD_DATA_DF.index.min().date()} to {DASHBOARD_DATA_DF.index.max().date()}")
+        print(f"Data loaded. Shape: {DASHBOARD_DATA_DF.shape}")
     else:
-        print("❌ Failed to initialize historical data.")
+        print("❌ Failed to initialize data.")
 
-# Initialize data at startup
 try:
+    setup_rag_chain()
     initialize_dashboard_data()
 except Exception as e:
-    print(f"Warning: Data initialization failed. Error: {e}")
-
-
-# =========================================
-# Professional Metrics & Evaluation Functions
-# =========================================
+    print(f"Init Warning: {e}")
 
+# --- 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_amount]
-
+    portfolio_values = [env.initial_balance]
     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):
-    """
-    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"]}
-
+    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%" if "%" in k else "0.00" for k in ["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio", "Volatility", "Max Drawdown", "Calmar Ratio"]}
+    if returns.empty: return {k: "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 np.nan
-
+    sharpe_ratio = np.sqrt(freq) * (returns.mean() - rf) / returns.std() if returns.std() > 0 else 0
     downside_returns = returns[returns < 0]
-    downside_std = downside_returns.std()
-    sortino_ratio = np.sqrt(freq) * (returns.mean() - rf) / downside_std if downside_std > 0 else np.nan
-
+    sortino_ratio = np.sqrt(freq) * (returns.mean() - rf) / downside_returns.std() if downside_returns.std() > 0 else 0
     volatility = returns.std() * np.sqrt(freq)
-
-    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
+    peak = portfolio_values.cummax()
+    max_drawdown = ((portfolio_values - peak) / peak).min()
+    calmar_ratio = cagr / abs(max_drawdown) if max_drawdown != 0 else 0
 
     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)
 
-    # 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)
+    # --- 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)
+    # -----------------------------------------------------------
 
-    # 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])
 
-    # 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
-    )
-    
+    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"))
     return fig
 
-# =========================================
-# Tab 4 Logic: Historical Simulation (UPDATED)
-# =========================================
-
+# --- Tab Functions ---
 def run_historical_simulation(start_date_str, end_date_str):
-    """
-    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)
-
+    if DASHBOARD_DATA_DF is None: return go.Figure(), "Data not initialized.", None
+    yield go.Figure(), "Preparing...", None
     try:
-        # 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
-
+        start_date, end_date = pd.to_datetime(start_date_str), pd.to_datetime(end_date_str)
         if start_date < DASHBOARD_DATA_DF.index.min() or end_date > DASHBOARD_DATA_DF.index.max():
-             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
-
+             yield go.Figure(), "Dates out of range.", None; 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]
         
-        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}")
+        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")
         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_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.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}"
         
-        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)],
+        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)]
         }
-        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
-
+        yield fig, "Complete", pd.DataFrame(metrics)
     except Exception as e:
-        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
+        yield go.Figure(), f"Error: {e}", None
 
+def run_hist_analysis(selected_assets, period):
+    if DASHBOARD_DATA_DF is None: return go.Figure(), "No Data"
+    yield go.Figure(), "Analyzing..."
     try:
-        # 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")
+        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()
         
-        # 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
-
+        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}"
     except Exception as e:
-        import traceback
-        traceback.print_exc()
-        yield go.Figure(), f"### Error during analysis\n\n{str(e)}"
-
+        yield go.Figure(), f"Error: {e}"
 
-# =========================================
-# Tab 2 Logic: Forecast & Analysis (XAI)
-# =========================================
-
-def get_latest_data_window(window_size=30):
-    """Fetches latest data needed for prediction."""
+def get_prediction_data(window_size=30):
     print("Fetching prediction data...")
-    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("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)
+    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)
     df.dropna(inplace=True)
-    if len(df) < window_size: raise Exception(f"Not enough clean data fetched for prediction.")
+    if len(df) < window_size: raise Exception("Not enough data.")
     return df.iloc[-window_size:].copy()
 
 def prepare_observation(data_window):
@@ -407,258 +244,141 @@ 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 both flattened obs for model and raw obs for XAI
+    # 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 obs.flatten().astype(np.float32), obs.astype(np.float32), data_window
 
 def predict_and_analyze():
-    """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
-
+    yield "Starting...", None, go.Figure(), "Loading..."
     try:
-        data_window = get_latest_data_window(WINDOW_SIZE)
-        # Get flattened obs for prediction and raw obs for XAI
+        data_window = get_prediction_data(WINDOW_SIZE)
         flat_obs, raw_obs, df_window_for_analyst = prepare_observation(data_window)
         
-        if not os.path.exists(MODEL_PATH): raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
+        if not os.path.exists(MODEL_PATH): raise FileNotFoundError("Model not found.")
         model = SAC.load(MODEL_PATH)
         
-        # --- 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)
+        # --- 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)
 
-        # --- Prediction ---
         action, _ = model.predict(flat_obs, deterministic=True)
-        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>"""
+        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>"""
         else:
-            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
+            html = f"<div style='color:red'>{str(res)}</div>"
+        
+        yield "Done", alloc_df, xai_plot, html
     except Exception as e:
         import traceback
         traceback.print_exc()
-        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))
+        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"))
     return fig
 
-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))
+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)')
     return fig
 
-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
-# =========================================
+def get_trans():
+    return pd.DataFrame([["2025-11-24", "REBALANCE", "ALL", "N/A"]], columns=["Date", "Type", "Asset", "Value"])
 
+# --- 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; margin-bottom: 5px; }
+.metric-label { font-size: 1.1em; color: #9ca3af; }
 .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; }
 """
 
-# 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>""")
-    
+# 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>""")
     gr.Markdown("# 🧠 Deep RL & LLM Portfolio Manager")
     
     with gr.Tabs():
-        # ================= TAB 1: DASHBOARD (RESTORED) =================
-        with gr.TabItem("📊 Live Dashboard"):
-            # Metrics Row
+        with gr.TabItem("📊 Dashboard"):
+            nw, ch = get_dash_metrics()
             with gr.Row():
-                # MOVED THIS LINE INSIDE THE TAB
-                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
+                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>")
             with gr.Row():
-                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.Column(scale=3): gr.Plot(value=get_hist_plot())
+                with gr.Column(scale=1): gr.Plot(value=get_alloc_plot())
             with gr.Row():
-                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.Column(): gr.Dataframe(value=get_trans(), label="Transactions")
+
+        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):
-                    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
+                    alloc = gr.Dataframe(label="Allocation")
+                    xai = gr.Plot(label="XAI")
                 with gr.Column(scale=3):
-                    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.Row():
-                with gr.Column(scale=1):
-                    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):
-                    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>
-            """)
+                    rep = gr.HTML(label="Report")
+            btn.click(predict_and_analyze, None, [stat, alloc, xai, rep])
 
+        with gr.TabItem("📅 Analyst"):
             with gr.Row():
                 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)
-                
+                    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")
                 with gr.Column(scale=3):
-                    sim_plot = gr.Plot(label="Simulation Performance")
+                    plot = gr.Plot()
+            out = gr.Markdown()
+            btn.click(run_hist_analysis, [sel, per], [plot, out])
 
-            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]
-            )
+        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])
 
 if __name__ == "__main__":
     demo.queue().launch(server_name="0.0.0.0", server_port=7860, debug=True, share=True)