Update scripts/app.py

scripts/app.py

@@ -10,17 +10,45 @@ 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
+# 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 stable_baselines3 import SAC
-from environment import PortfolioEnv
+# Import the environment for simulation
+from scripts.environment import PortfolioEnv
+# Import baseline functions
 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")
+DASHBOARD_DATA_PATH = os.path.join(project_root, "data", "historical_dashboard_data.csv")
 
 # *** UPDATE THESE DATES TO MATCH YOUR ACTUAL TRAINING PERIOD ***
 TRAIN_START_DATE = "2015-01-01"
@@ -70,6 +98,7 @@ 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}")
@@ -85,7 +114,7 @@ def evaluate_agent_pro(env, model):
     """
     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)
@@ -144,6 +173,11 @@ 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)
@@ -164,28 +198,24 @@ 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)
 
-    # 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)
+    # 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)
 
     # Calculate Integrated Gradients: (input - baseline) * average_gradients
     integrated_grads = (obs_tensor - baseline) * avg_grads
     
-    # Detach, move to cpu, and convert to numpy array
+    # Detach, move to cpu, flatten, 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:
@@ -223,76 +253,72 @@ 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
+        height=300, # Keep it compact
+        # Style the hover labels for readability
+        hoverlabel=dict(
+            bgcolor="white",
+            font_size=14,
+            font_family="Roboto",
+            font_color="black"
+        )
     )
     
     return fig
 
 # =========================================
-# Tab 4 Logic: Historical Simulation (UPDATED)
+# Tab 4 Logic: Historical Simulation
 # =========================================
 
 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)
+        return go.Figure(), "Data not initialized. Please restart app.", None
     
     status_msg = "Preparing simulation..."
-    yield go.Figure(), status_msg, gr.update(visible=False)
+    yield go.Figure(), status_msg, 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)
+             yield go.Figure(), "Error: Invalid date format. Use YYYY-MM-DD.", None
              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: Selected dates outside available range ({avail_start} to {avail_end}).", gr.update(visible=False)
+             yield go.Figure(), f"Error: Dates out of range ({avail_start} to {avail_end}).", 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)
+             yield go.Figure(), "Error: Time period too short.", None
              return
 
-        # 2. Setup Environment and Agent
         status_msg = "Running RL Agent simulation..."
-        yield go.Figure(), status_msg, gr.update(visible=False)
+        yield go.Figure(), status_msg, None
         
-        env = PortfolioEnv(df_slice, WINDOW_SIZE, initial_amount=10000)
+        env = PortfolioEnv(df_slice, WINDOW_SIZE, initial_balance=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)
             
-        # 4. Calculate Baselines using Pro Functions
-        status_msg = "Calculating baselines and metrics..."
-        yield go.Figure(), status_msg, gr.update(visible=False)
+        status_msg = "Calculating baselines..."
+        yield go.Figure(), status_msg, None
 
-        # 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 = buy_and_hold(df_slice[asset_cols_only], initial_balance=10000)
         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 = equally_weighted_rebalanced(df_slice[asset_cols_only], initial_balance=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')))
@@ -306,15 +332,14 @@ 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)
+            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")
         )
 
-        # 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}"
@@ -327,16 +352,12 @@ def run_historical_simulation(start_date_str, end_date_str):
         }
         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, "Simulation Complete.", metrics_df
 
     except Exception as e:
         import traceback
         traceback.print_exc()
-        yield go.Figure(), f"Error during simulation: {str(e)}", gr.update(visible=False)
+        yield go.Figure(), f"Error: {str(e)}", None
 
 
 # =========================================
@@ -344,7 +365,6 @@ 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."
     
@@ -352,27 +372,25 @@ 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 in available data."
+             yield go.Figure(), "Error: Selected assets not found."
              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}"
+             yield go.Figure(), f"No data found for: {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")
+            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"))
         
-        # 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
@@ -380,25 +398,24 @@ def run_historical_analysis(selected_assets, period_name):
     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: {str(e)}"
 
 
 # =========================================
-# Tab 2 Logic: Forecast & Analysis (XAI)
+# Tab 2 Logic: Forecast & Analysis
 # =========================================
 
 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')
     start_date = (datetime.now() - timedelta(days=lookback_days)).strftime('%Y-%m-%d')
-    temp_filename = os.path.join("data", "temp_gradio_prediction_data.csv")
+    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(f"Not enough clean data fetched for prediction.")
+    if len(df) < window_size: raise Exception(f"Not enough clean data fetched.")
     return df.iloc[-window_size:].copy()
 
 def prepare_observation(data_window):
@@ -407,30 +424,24 @@ 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, raw_obs)
+        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)
@@ -441,7 +452,6 @@ 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()}
@@ -453,18 +463,12 @@ 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')
-            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"
+            
+            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"
 
             report_html = f"""
             <div style="background-color: #1f2937; padding: 20px; border-radius: 12px 12px 0 0; border: 1px solid #374151; border-bottom: none;">
@@ -479,53 +483,38 @@ 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()
-        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
-
+        yield status_msg, None, go.Figure(), f"Error: {str(e)}"
 
 # =========================================
 # 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)
+    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))
     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=rl_value, mode='lines', name='RL Agent', 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))
+    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"))
     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))
+    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"))
     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"])
-
+    return pd.DataFrame([["2025-11-24", "SELL", "SPY", "$4,500"], ["2025-11-21", "BUY", "BTC-USD", "$1,000"]], columns=["Date", "Type", "Asset", "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; }
@@ -533,133 +522,55 @@ 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; }
 """
 
-# 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>""")
-    
+# 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>""")
     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_dashboard_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;'>{daily_change}</div>")
-            
-            # Main Chart 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>")
             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_portfolio_history_plot())
+                with gr.Column(scale=1): gr.Plot(value=get_current_allocation_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_recent_transactions(), 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_historical_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)