Update scripts/app.py

scripts/app.py

@@ -1,5 +1,7 @@
 # scripts/app.py
 
+# scripts/app.py
+
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -10,38 +12,10 @@ 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
-# Import the new analysis function instead of RAG tools
-from scripts.llm_analysis_rag import analyze_agent_decision, analyze_historical_segment, setup_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
-# Import the environment for simulation
-from scripts.environment import PortfolioEnv
-# Import baseline functions
+from environment import PortfolioEnv
 from scripts.evaluate_baselines import buy_and_hold, equally_weighted_rebalanced
 
 # --- Configuration ---
@@ -98,7 +72,6 @@ def initialize_dashboard_data():
 
 # Initialize data at startup
 try:
-    setup_rag_chain() # Initialize RAG components if needed
     initialize_dashboard_data()
 except Exception as e:
     print(f"Warning: Data initialization failed. Error: {e}")
@@ -114,7 +87,7 @@ def evaluate_agent_pro(env, model):
     """
     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)
@@ -173,11 +146,6 @@ def calculate_feature_importance(model, obs):
     """
     # Convert observation to torch tensor and enable gradient tracking
     obs_tensor = torch.as_tensor(obs, dtype=torch.float32, device=model.device)
-    
-    # Ensure batch dimension exists
-    if obs_tensor.dim() == 1:
-        obs_tensor = obs_tensor.unsqueeze(0)
-        
     obs_tensor.requires_grad_()
 
     # Get the policy network (actor)
@@ -198,24 +166,28 @@ def calculate_feature_importance(model, obs):
         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)
 
-    # Stack and average gradients
-    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, flatten, and convert to numpy array
+    # 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:
@@ -253,72 +225,76 @@ def calculate_feature_importance(model, obs):
         yaxis={'categoryorder':'total ascending'},
         coloraxis_showscale=False,
         margin=dict(l=10, r=10, t=40, b=10),
-        height=300, # Keep it compact
-        # Style the hover labels for readability
-        hoverlabel=dict(
-            bgcolor="white",
-            font_size=14,
-            font_family="Roboto",
-            font_color="black"
-        )
+        height=300 # Keep it compact
     )
     
     return fig
 
 # =========================================
-# Tab 4 Logic: Historical Simulation
+# Tab 4 Logic: Historical Simulation (UPDATED)
 # =========================================
 
 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.", None
+        return go.Figure(), "Data not initialized. Please restart app.", gr.update(visible=False)
     
     status_msg = "Preparing simulation..."
-    yield go.Figure(), status_msg, None
+    yield go.Figure(), status_msg, gr.update(visible=False)
 
     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.", None
+             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():
              avail_start = DASHBOARD_DATA_DF.index.min().date()
              avail_end = DASHBOARD_DATA_DF.index.max().date()
-             yield go.Figure(), f"Error: Dates out of range ({avail_start} to {avail_end}).", None
+             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]
         
         if len(df_slice) < WINDOW_SIZE + 10:
-             yield go.Figure(), "Error: Time period too short.", None
+             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, None
+        yield go.Figure(), status_msg, gr.update(visible=False)
         
-        env = PortfolioEnv(df_slice, WINDOW_SIZE, initial_balance=10000)
+        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)
 
+        # 3. Run Simulation Loop & Get Values using Pro Function
         rl_portfolio_series = evaluate_agent_pro(env, model)
             
-        status_msg = "Calculating baselines..."
-        yield go.Figure(), status_msg, None
+        # 4. Calculate Baselines using Pro Functions
+        status_msg = "Calculating baselines and metrics..."
+        yield go.Figure(), status_msg, gr.update(visible=False)
 
-        bnh_portfolio_series = buy_and_hold(df_slice[asset_cols_only], initial_balance=10000)
+        # 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_balance=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')))
@@ -332,14 +308,15 @@ def run_historical_simulation(start_date_str, end_date_str):
             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_family="Roboto", font_color="black")
+            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}"
@@ -352,12 +329,16 @@ def run_historical_simulation(start_date_str, end_date_str):
         }
         metrics_df = pd.DataFrame(metrics_data)
         
-        yield fig, "Simulation Complete.", metrics_df
+        # 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:
         import traceback
         traceback.print_exc()
-        yield go.Figure(), f"Error: {str(e)}", None
+        yield go.Figure(), f"Error during simulation: {str(e)}", gr.update(visible=False)
 
 
 # =========================================
@@ -365,6 +346,7 @@ def run_historical_simulation(start_date_str, end_date_str):
 # =========================================
 
 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."
     
@@ -372,25 +354,27 @@ def run_historical_analysis(selected_assets, period_name):
     yield go.Figure(), status_html
 
     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."
+             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: {period_name}"
+             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",
-            hoverlabel=dict(bgcolor="white", font_size=14, font_family="Roboto", font_color="black"))
+            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
@@ -398,14 +382,15 @@ def run_historical_analysis(selected_assets, period_name):
     except Exception as e:
         import traceback
         traceback.print_exc()
-        yield go.Figure(), f"### Error: {str(e)}"
+        yield go.Figure(), f"### Error during analysis\n\n{str(e)}"
 
 
 # =========================================
-# Tab 2 Logic: Forecast & Analysis
+# Tab 2 Logic: Forecast & Analysis (XAI)
 # =========================================
 
 def get_latest_data_window(window_size=30):
+    """Fetches latest data needed for prediction."""
     print("Fetching prediction data...")
     lookback_days = window_size + 150
     end_date = datetime.now().strftime('%Y-%m-%d')
@@ -415,7 +400,7 @@ def get_latest_data_window(window_size=30):
     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(f"Not enough clean data fetched.")
+    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):
@@ -424,24 +409,30 @@ 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 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
 
     try:
         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(f"Model not found: {MODEL_PATH}")
         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, flat_obs)
+        xai_plot = calculate_feature_importance(model, raw_obs)
 
+        # --- Prediction ---
         action, _ = model.predict(flat_obs, deterministic=True)
         exp_action = np.exp(np.asarray(action).flatten())
         weights = exp_action / np.sum(exp_action)
@@ -452,6 +443,7 @@ def predict_and_analyze():
 
         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()}
@@ -463,12 +455,18 @@ def predict_and_analyze():
             risk = analysis_result.get('risk_level', 'N/A').upper()
             just = analysis_result.get('justification', 'N/A')
             conf = analysis_result.get('confidence_score', 'N/A')
-            
-            risk_css = "color: #ef4444;" if 'HIGH' in risk else "color: #10b981;"
-            status_bg = "#7f1d1d" if 'HIGH' in risk else "#064e3b"
-            status_border = "#ef4444" if 'HIGH' in risk else "#10b981"
-            status_icon = "⛔" if 'HIGH' in risk else "🚀"
-            status_text = "TRADE BLOCKED: High Risk Detected" if 'HIGH' in risk else "TRADE APPROVED"
+            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;">
@@ -483,38 +481,53 @@ def predict_and_analyze():
             </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
     except Exception as e:
         import traceback
         traceback.print_exc()
-        yield status_msg, None, go.Figure(), f"Error: {str(e)}"
+        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_value = 10000 * np.cumprod(1 + np.random.normal(0.001, 0.01, 100))
-    bnh_value = 10000 * np.cumprod(1 + np.random.normal(0.0005, 0.012, 100))
+    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', line=dict(color='#10b981', width=3)))
+    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)", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', hoverlabel=dict(bgcolor="white", font_size=14, font_color="black"))
+    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_current_allocation_plot():
-    fig = px.pie(values=[0.25, 0.1, 0.3, 0.15, 0.05, 0.15], names=ASSETS+['Cash'], title="Holdings", 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"))
+    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_recent_transactions():
-    return pd.DataFrame([["2025-11-24", "SELL", "SPY", "$4,500"], ["2025-11-21", "BUY", "BTC-USD", "$1,000"]], columns=["Date", "Type", "Asset", "Value"])
+    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
 # =========================================
+
 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; }
@@ -522,55 +535,132 @@ custom_css = """
 .disclaimer-box { background-color: #374151; padding: 15px; border-radius: 8px; border-left: 4px solid #f59e0b; color: #d1d5db; font-size: 0.9em; margin-bottom: 20px; }
 """
 
-# Using theme=gr.themes.Soft(...) here because we forced requirements to support it
-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_dashboard_metrics()
-            with gr.Row():
-                gr.HTML(f"<div class='metric-box'><div>Net Worth</div><div class='metric-value'>{nw}</div></div>")
-                gr.HTML(f"<div class='metric-box'><div>Change</div><div class='metric-value' style='color:#10b981'>{ch}</div></div>")
+        # ================= TAB 1: DASHBOARD (RESTORED) =================
+        with gr.TabItem("📊 Live Dashboard"):
+            # Metrics Row
             with gr.Row():
-                with gr.Column(scale=3): gr.Plot(value=get_portfolio_history_plot())
-                with gr.Column(scale=1): gr.Plot(value=get_current_allocation_plot())
+                # 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
             with gr.Row():
-                with gr.Column(): gr.Dataframe(value=get_recent_transactions(), label="Transactions")
+                with gr.Column(scale=3):
+                    history_chart = gr.Plot(value=get_portfolio_history_plot(), label="Net Worth History")
 
-        with gr.TabItem("🔮 Forecast"):
-            btn = gr.Button("🚀 Run Analysis", variant="primary")
-            stat = gr.Textbox(label="Status", interactive=False)
+            # Bottom Row: Allocations and Transactions
             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):
-                    alloc = gr.Dataframe(label="Allocation")
-                    xai = gr.Plot(label="XAI")
+                    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.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
                 with gr.Column(scale=3):
-                    rep = gr.HTML(label="Report")
-            btn.click(predict_and_analyze, None, [stat, alloc, xai, rep])
-
-        with gr.TabItem("📅 Analyst"):
+                    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):
-                    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_historical_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)