feat: implement P0 frontend UX improvements with tabbed interface

Implemented comprehensive UX improvements across authentication, navigation,
and results presentation to enhance user experience and reduce UI clutter.

Navigation & Authentication:
- Add native Gradio sidebar navigation with authentication-based visibility
- Sidebar hidden on login page, shown after authentication or demo mode
- Remove hamburger menu in favour of sidebar built-in controls
- Add navigation buttons for new analysis, history, settings, and help

UI Consistency & Polish:
- Standardise button font sizes across all large buttons with CSS
- Add emoji to demo section heading for visual consistency
- Remove redundant "View History" button from landing page
- Remove "Portfolio Analysis Results" header and all tab headers

Results Page Redesign:
- Replace single-page results with 5-tab interface
- Tabs: Analysis Results, Dashboard, Tax Analysis, Stress Testing, History
- Auto-load history when History tab selected
- Remove redundant action buttons from results header

Historical Analysis:
- Add get_analysis_by_id() method to database.py with auth checks
- Implement row selection in history tables
- Display full analysis details in accordion on selection
- Support history viewing in both standalone page and embedded tab

Bug Fixes:
- Fix type conversion in visualization code (string to float)
- Resolve TypeError in optimization comparison charts
- Resolve TypeError in risk metrics dashboard

app.py

@@ -169,6 +169,7 @@ else:
 
 # Global state for visualisations
 LAST_ANALYSIS_STATE = None
+HISTORY_RECORDS = []  # Stores loaded history records for row selection
 LAST_STRESS_TEST = None
 
 # Loading screen rotating messages with MCP phases and disclaimers
@@ -531,9 +532,7 @@ def format_analysis_result(final_state: AgentState, holdings: List[Dict[str, Any
         recs_md += "*No specific recommendations generated.*\n"
 
     # Final output
-    output = f"""# Portfolio Analysis Results
-
-{holdings_md}
+    output = f"""{holdings_md}
 
 {metrics_md}
 
@@ -1165,6 +1164,47 @@ def create_interface() -> gr.Blocks:
         padding: 1.5rem 2rem;
     }
 
+    /* Sidebar Styling - Works with gr.Sidebar */
+    #main-sidebar {
+        background: linear-gradient(135deg, #1e3a5f 0%, #2d5a7b 100%) !important;
+    }
+
+    #main-sidebar .sidebar-header {
+        color: white !important;
+        border-bottom: 2px solid rgba(255,255,255,0.2);
+        padding-bottom: 10px;
+        margin-bottom: 20px;
+    }
+
+    .nav-btn {
+        width: 100%;
+        margin-bottom: 10px;
+        text-align: left !important;
+        justify-content: flex-start !important;
+        background: rgba(255,255,255,0.05) !important;
+        border: 1px solid rgba(255,255,255,0.1) !important;
+        color: white !important;
+    }
+
+    .nav-btn:hover {
+        background: rgba(255,255,255,0.15) !important;
+        border-color: rgba(255,255,255,0.3) !important;
+    }
+
+    .sidebar-header {
+        color: white !important;
+        border-bottom: 2px solid rgba(255,255,255,0.2);
+        padding-bottom: 10px;
+        margin-bottom: 20px;
+    }
+
+    /* Ensure all large buttons have consistent font size */
+    button.lg,
+    .lg button {
+        font-size: 1rem !important;
+        font-weight: 600 !important;
+    }
+
     /* Dark mode specific container adjustments - theme adaptive */
     .dark .gradio-container {
         background-color: var(--body-background-fill-dark);
@@ -1571,6 +1611,25 @@ def create_interface() -> gr.Blocks:
             with gr.Column(scale=1):
                 logout_btn = gr.Button("Sign Out", variant="secondary", size="sm", visible=False)
 
+        # Navigation sidebar using Gradio's native component
+        with gr.Sidebar(position="left", open=False, visible=False, elem_id="main-sidebar") as sidebar:
+            gr.Markdown("## Navigation", elem_classes="sidebar-header")
+
+            # Navigation options
+            nav_new_analysis = gr.Button("🏠 New Analysis", variant="secondary", size="lg", elem_classes="nav-btn")
+            nav_view_history = gr.Button("📜 View History", variant="secondary", size="lg", elem_classes="nav-btn")
+            nav_settings = gr.Button("⚙️ Settings", variant="secondary", size="lg", elem_classes="nav-btn")
+            nav_help = gr.Button("❓ Help & Documentation", variant="secondary", size="lg", elem_classes="nav-btn")
+
+            gr.Markdown("---")
+
+            # User section (when logged in)
+            with gr.Group(visible=False) as sidebar_user_section:
+                gr.Markdown("### Account")
+                sidebar_user_email = gr.Markdown("")
+                nav_profile_btn = gr.Button("👤 Profile", variant="secondary", size="sm")
+                nav_signout_btn = gr.Button("🚪 Sign Out", variant="secondary", size="sm")
+
         # Authentication container
         with gr.Group(visible=True, elem_id="auth-container") as login_container:
             gr.Markdown("## 🔐 Sign In to Continue")
@@ -1618,12 +1677,13 @@ def create_interface() -> gr.Blocks:
 
             # Demo mode option
             gr.Markdown("---")
-            gr.Markdown("### Or try without signing up")
+            gr.Markdown("## 🎯 Or Try Without Signing Up")
             demo_btn = gr.Button(
-                "🎯 Try Demo (1 free analysis per day)",
+                "Try Demo",
                 variant="secondary",
                 size="lg"
             )
+            gr.Markdown("*1 free analysis per day • No account required*", elem_classes="demo-subtitle")
             demo_message = gr.Markdown("")
 
         # Input Page with side-by-side layout (hidden until authenticated)
@@ -1661,7 +1721,12 @@ def create_interface() -> gr.Blocks:
                             info="Enable brutal honesty mode for portfolio critique (only works with Standard Analysis)"
                         )
 
-                        analyse_btn = gr.Button("Analyse Portfolio", variant="primary", size="sm", scale=1)
+                        # Action button
+                        analyse_btn = gr.Button(
+                            "Analyse Portfolio",
+                            variant="primary",
+                            size="lg"
+                        )
 
                         # Examples integrated as simple buttons
                         gr.Markdown("### Example Portfolios", elem_classes="examples-header")
@@ -1776,147 +1841,158 @@ def create_interface() -> gr.Blocks:
                         """
                     )
 
-        # Results Page (unified dashboard)
+        # Results Page (tabbed interface)
         with gr.Group(visible=False) as results_page:
-            with gr.Row():
-                with gr.Column(scale=3):
-                    gr.Markdown("### Analysis Results")
-                    analysis_output = gr.Markdown("")
-
-                    # Performance Metrics Accordion (progressive disclosure)
-                    with gr.Accordion("Performance Metrics & Reasoning", open=False):
-                        performance_metrics_output = gr.Markdown("")
-
-                with gr.Column(scale=1):
-                    new_analysis_btn = gr.Button("New Analysis", variant="secondary")
-                    view_history_btn_results = gr.Button("View History", variant="secondary")
-
-            gr.Markdown("---")
-            gr.Markdown("### Interactive Dashboard")
-
-            # Top row - Portfolio allocation + Risk metrics
-            with gr.Row(equal_height=True):
-                with gr.Column(scale=1, min_width=400):
-                    allocation_plot = gr.Plot(label="Portfolio Allocation", container=True)
-                with gr.Column(scale=1, min_width=400):
-                    risk_plot = gr.Plot(label="Risk Metrics Dashboard", container=True)
-
-            # Middle row - Performance (full width)
-            with gr.Row():
-                performance_plot = gr.Plot(label="Historical Performance", container=True)
-
-            # Bottom row - Correlation + Optimisation
-            with gr.Row(equal_height=True):
-                with gr.Column(scale=1, min_width=400):
-                    correlation_plot = gr.Plot(label="Asset Correlation Matrix", container=True)
-                with gr.Column(scale=1, min_width=400):
-                    optimization_plot = gr.Plot(label="Optimisation Methods Comparison", container=True)
-
-            # Tax Impact Analysis Section (Enhancement #5)
-            gr.Markdown("---")
-            gr.Markdown("### Tax Impact Analysis")
-            gr.Markdown("Analyse tax implications and identify tax-loss harvesting opportunities.")
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    tax_filing_status = gr.Dropdown(
-                        choices=[
-                            ("Single", "single"),
-                            ("Married Filing Jointly", "married_joint"),
-                            ("Married Filing Separately", "married_separate"),
-                            ("Head of Household", "head_of_household"),
-                        ],
-                        value="single",
-                        label="Filing Status",
-                        info="Your tax filing status"
-                    )
-                    tax_annual_income = gr.Slider(
-                        minimum=0,
-                        maximum=1000000,
-                        value=75000,
-                        step=5000,
-                        label="Annual Income ($)",
-                        info="Total taxable income"
-                    )
-                    tax_cost_basis_method = gr.Dropdown(
-                        choices=[
-                            ("First In, First Out (FIFO)", "fifo"),
-                            ("Last In, First Out (LIFO)", "lifo"),
-                            ("Highest In, First Out (HIFO)", "hifo"),
-                            ("Average Cost", "average"),
-                        ],
-                        value="fifo",
-                        label="Cost Basis Method",
-                        info="Method for calculating gains/losses"
-                    )
-                    tax_calculate_btn = gr.Button("Calculate Tax Impact", variant="primary")
-
-                with gr.Column(scale=2):
-                    tax_analysis_output = gr.Markdown("")
-
-            # Stress Testing Section
-            gr.Markdown("---")
-            gr.Markdown("### Portfolio Stress Testing")
-            gr.Markdown("Test your portfolio's resilience against historical crises and market scenarios.")
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    scenario_choices = [
-                        ("Monte Carlo Simulation (10,000 paths)", "monte_carlo"),
-                        ("All Scenarios Comparison", "all_scenarios"),
-                        ("2008 Financial Crisis", "2008_financial_crisis"),
-                        ("COVID-19 Pandemic (2020)", "covid_2020"),
-                        ("Dot-com Bubble (2000-2002)", "dotcom_bubble"),
-                        ("European Debt Crisis (2011)", "european_debt_2011"),
-                        ("China Devaluation (2015)", "china_2015"),
-                        ("Inflation Shock (2022)", "inflation_2022"),
-                        ("Severe Recession (Hypothetical)", "severe_recession"),
-                        ("Stagflation (Hypothetical)", "stagflation"),
-                        ("Flash Crash (Hypothetical)", "flash_crash"),
-                    ]
-                    stress_scenario_dropdown = gr.Dropdown(
-                        choices=scenario_choices,
-                        value="monte_carlo",
-                        label="Select Stress Scenario",
-                        info="Choose a historical crisis or simulation method"
-                    )
-
+            # Main tabbed interface
+            with gr.Tabs() as results_tabs:
+                # Tab 1: Analysis Results
+                with gr.Tab("📊 Analysis Results"):
+                    with gr.Column():
+                        analysis_output = gr.Markdown("")
+
+                        # Performance Metrics Accordion (progressive disclosure)
+                        with gr.Accordion("Performance Metrics & Reasoning", open=False):
+                            performance_metrics_output = gr.Markdown("")
+
+                # Tab 2: Dashboard
+                with gr.Tab("📈 Dashboard"):
+                    # Top row - Portfolio allocation + Risk metrics
+                    with gr.Row(equal_height=True):
+                        with gr.Column(scale=1, min_width=400):
+                            allocation_plot = gr.Plot(label="Portfolio Allocation", container=True)
+                        with gr.Column(scale=1, min_width=400):
+                            risk_plot = gr.Plot(label="Risk Metrics Dashboard", container=True)
+
+                    # Middle row - Performance (full width)
                     with gr.Row():
-                        stress_n_sims = gr.Slider(
-                            minimum=1000,
-                            maximum=50000,
-                            value=10000,
-                            step=1000,
-                            label="Monte Carlo Simulations",
-                            info="More simulations = more accuracy (slower)"
-                        )
-                        stress_horizon = gr.Slider(
-                            minimum=30,
-                            maximum=756,
-                            value=252,
-                            step=30,
-                            label="Time Horizon (days)",
-                            info="1 year = 252 trading days"
-                        )
+                        performance_plot = gr.Plot(label="Historical Performance", container=True)
 
-                    stress_test_btn = gr.Button("Run Stress Test", variant="primary", size="lg")
+                    # Bottom row - Correlation + Optimisation
+                    with gr.Row(equal_height=True):
+                        with gr.Column(scale=1, min_width=400):
+                            correlation_plot = gr.Plot(label="Asset Correlation Matrix", container=True)
+                        with gr.Column(scale=1, min_width=400):
+                            optimization_plot = gr.Plot(label="Optimisation Methods Comparison", container=True)
 
-            # Stress test results
-            with gr.Column():
-                stress_summary = gr.Markdown("", visible=True)
+                # Tab 3: Tax Analysis
+                with gr.Tab("💰 Tax Analysis"):
+                    gr.Markdown("Analyse tax implications and identify tax-loss harvesting opportunities.")
 
-                with gr.Tabs():
-                    with gr.Tab("Dashboard"):
-                        stress_dashboard_plot = gr.Plot(label="Stress Test Dashboard")
-
-                    with gr.Tab("Monte Carlo Paths"):
-                        stress_mc_plot = gr.Plot(label="Monte Carlo Simulation Paths")
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            tax_filing_status = gr.Dropdown(
+                                choices=[
+                                    ("Single", "single"),
+                                    ("Married Filing Jointly", "married_joint"),
+                                    ("Married Filing Separately", "married_separate"),
+                                    ("Head of Household", "head_of_household"),
+                                ],
+                                value="single",
+                                label="Filing Status",
+                                info="Your tax filing status"
+                            )
+                            tax_annual_income = gr.Slider(
+                                minimum=0,
+                                maximum=1000000,
+                                value=75000,
+                                step=5000,
+                                label="Annual Income ($)",
+                                info="Total taxable income"
+                            )
+                            tax_cost_basis_method = gr.Dropdown(
+                                choices=[
+                                    ("First In, First Out (FIFO)", "fifo"),
+                                    ("Last In, First Out (LIFO)", "lifo"),
+                                    ("Highest In, First Out (HIFO)", "hifo"),
+                                    ("Average Cost", "average"),
+                                ],
+                                value="fifo",
+                                label="Cost Basis Method",
+                                info="Method for calculating gains/losses"
+                            )
+                            tax_calculate_btn = gr.Button("Calculate Tax Impact", variant="primary")
+
+                        with gr.Column(scale=2):
+                            tax_analysis_output = gr.Markdown("")
+
+                # Tab 4: Stress Testing
+                with gr.Tab("🎲 Stress Testing"):
+                    gr.Markdown("Test your portfolio's resilience against historical crises and market scenarios.")
 
-                    with gr.Tab("Scenario Comparison"):
-                        stress_scenario_plot = gr.Plot(label="All Scenarios Comparison")
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            scenario_choices = [
+                                ("Monte Carlo Simulation (10,000 paths)", "monte_carlo"),
+                                ("All Scenarios Comparison", "all_scenarios"),
+                                ("2008 Financial Crisis", "2008_financial_crisis"),
+                                ("COVID-19 Pandemic (2020)", "covid_2020"),
+                                ("Dot-com Bubble (2000-2002)", "dotcom_bubble"),
+                                ("European Debt Crisis (2011)", "european_debt_2011"),
+                                ("China Devaluation (2015)", "china_2015"),
+                                ("Inflation Shock (2022)", "inflation_2022"),
+                                ("Severe Recession (Hypothetical)", "severe_recession"),
+                                ("Stagflation (Hypothetical)", "stagflation"),
+                                ("Flash Crash (Hypothetical)", "flash_crash"),
+                            ]
+                            stress_scenario_dropdown = gr.Dropdown(
+                                choices=scenario_choices,
+                                value="monte_carlo",
+                                label="Select Stress Scenario",
+                                info="Choose a historical crisis or simulation method"
+                            )
+
+                            with gr.Row():
+                                stress_n_sims = gr.Slider(
+                                    minimum=1000,
+                                    maximum=50000,
+                                    value=10000,
+                                    step=1000,
+                                    label="Monte Carlo Simulations",
+                                    info="More simulations = more accuracy (slower)"
+                                )
+                                stress_horizon = gr.Slider(
+                                    minimum=30,
+                                    maximum=756,
+                                    value=252,
+                                    step=30,
+                                    label="Time Horizon (days)",
+                                    info="1 year = 252 trading days"
+                                )
+
+                            stress_test_btn = gr.Button("Run Stress Test", variant="primary", size="lg")
+
+                    # Stress test results
+                    with gr.Column():
+                        stress_summary = gr.Markdown("", visible=True)
+
+                        with gr.Tabs():
+                            with gr.Tab("Dashboard"):
+                                stress_dashboard_plot = gr.Plot(label="Stress Test Dashboard")
+
+                            with gr.Tab("Monte Carlo Paths"):
+                                stress_mc_plot = gr.Plot(label="Monte Carlo Simulation Paths")
+
+                            with gr.Tab("Scenario Comparison"):
+                                stress_scenario_plot = gr.Plot(label="All Scenarios Comparison")
+
+                            with gr.Tab("Drawdown Analysis"):
+                                stress_drawdown_plot = gr.Plot(label="Maximum Drawdown Distribution")
+
+                # Tab 5: History (embedded)
+                with gr.Tab("📜 History"):
+                    gr.Markdown("View your previous portfolio analyses")
+
+                    history_table_results = gr.Dataframe(
+                        headers=["ID", "Date", "Holdings", "Risk Tolerance", "AI Synthesis Preview"],
+                        datatype=["str", "str", "str", "str", "str"],
+                        interactive=False,
+                        wrap=True,
+                        elem_id="history-table-results",
+                        column_widths=["5%", "15%", "25%", "15%", "40%"]
+                    )
 
-                    with gr.Tab("Drawdown Analysis"):
-                        stress_drawdown_plot = gr.Plot(label="Maximum Drawdown Distribution")
+                    with gr.Accordion("Selected Analysis Details", open=False):
+                        history_details_output_results = gr.Markdown("")
 
         # History Page (Enhancement #4 - Historical Analysis Storage)
         with gr.Group(visible=False) as history_page:
@@ -1930,11 +2006,12 @@ def create_interface() -> gr.Blocks:
                     back_to_input_btn = gr.Button("New Analysis", variant="secondary")
 
             history_table = gr.Dataframe(
-                headers=["Date", "Holdings", "Risk Tolerance", "AI Synthesis Preview"],
-                datatype=["str", "str", "str", "str"],
+                headers=["ID", "Date", "Holdings", "Risk Tolerance", "AI Synthesis Preview"],
+                datatype=["str", "str", "str", "str", "str"],
                 interactive=False,
                 wrap=True,
-                elem_id="history-table"
+                elem_id="history-table",
+                column_widths=["5%", "15%", "25%", "15%", "40%"]
             )
 
             with gr.Accordion("Selected Analysis Details", open=False) as history_details:
@@ -1982,8 +2059,12 @@ def create_interface() -> gr.Blocks:
                 logger.info(f"Loaded {len(history)} analyses for user {user_id}")
 
                 # Format history for dataframe
+                # Store analysis records globally for row selection
+                global HISTORY_RECORDS
+                HISTORY_RECORDS = history
+
                 rows = []
-                for record in history:
+                for i, record in enumerate(history):
                     # Format holdings as comma-separated tickers
                     holdings_str = ", ".join([h.get("ticker", "?") for h in record.get("holdings_snapshot", [])])
 
@@ -1991,6 +2072,7 @@ def create_interface() -> gr.Blocks:
                     synthesis_preview = record.get("ai_synthesis", "")[:100] + "..."
 
                     rows.append([
+                        str(i),  # Row index for selection
                         record.get("created_at", "").split("T")[0],  # Date only
                         holdings_str,
                         record.get("portfolios", {}).get("risk_tolerance", "moderate"),
@@ -2006,6 +2088,79 @@ def create_interface() -> gr.Blocks:
             """Synchronous wrapper for load_history."""
             return asyncio.run(load_history(session_state))
 
+        def view_historical_analysis(evt: gr.SelectData):
+            """View full details of a selected historical analysis.
+
+            Args:
+                evt: Gradio SelectData event containing row index
+
+            Returns:
+                Markdown string with full analysis details
+            """
+            global HISTORY_RECORDS
+
+            try:
+                # Get the row index from the selected row
+                row_index = int(evt.value)  # First column contains the index
+
+                if not HISTORY_RECORDS or row_index >= len(HISTORY_RECORDS):
+                    return "**Error**: Could not load analysis. Please refresh the history table."
+
+                record = HISTORY_RECORDS[row_index]
+
+                # Format detailed analysis view
+                details = f"""# Analysis Details
+
+**Date**: {record.get('created_at', 'Unknown').split('T')[0]}
+**Portfolio**: {record.get('portfolios', {}).get('name', 'Unnamed Portfolio')}
+**Risk Tolerance**: {record.get('portfolios', {}).get('risk_tolerance', 'moderate')}
+
+---
+
+## Holdings Snapshot
+"""
+                # Format holdings as table
+                holdings = record.get('holdings_snapshot', [])
+                if holdings:
+                    details += "\n| Ticker | Shares | Value |\n|--------|--------|-------|\n"
+                    for holding in holdings:
+                        details += f"| {holding.get('ticker', '?')} | {holding.get('shares', 0)} | ${holding.get('value', 0):,.2f} |\n"
+                else:
+                    details += "\n*No holdings data available*\n"
+
+                details += f"""
+
+---
+
+## AI Analysis
+
+{record.get('ai_synthesis', '*No analysis available*')}
+
+---
+
+## Recommendations
+"""
+                recommendations = record.get('recommendations', [])
+                if recommendations:
+                    for i, rec in enumerate(recommendations, 1):
+                        details += f"\n{i}. {rec}"
+                else:
+                    details += "\n*No recommendations available*"
+
+                details += f"""
+
+---
+
+**Model**: {record.get('model_version', 'Unknown')}
+**Execution Time**: {record.get('execution_time_ms', 0):,.0f}ms
+"""
+
+                return details
+
+            except Exception as e:
+                logger.error(f"Failed to view historical analysis: {e}")
+                return f"**Error**: Failed to load analysis details: {str(e)}"
+
         def show_history_page():
             """Navigate to history page."""
             return {
@@ -2166,19 +2321,17 @@ Please try again with different parameters.
             show_progress="full"
         )
 
-        new_analysis_btn.click(
-            show_input_page,
-            outputs=[input_page, results_page, history_page]
-        )
+        # Auto-load history when History tab is selected
+        def load_history_if_selected(evt: gr.SelectData, session):
+            """Load history only when History tab is selected."""
+            if evt.index == 4:  # History tab is index 4 (0-indexed: Analysis, Dashboard, Tax, Stress, History)
+                return sync_load_history(session)
+            return gr.skip(), gr.skip()
 
-        # History page navigation
-        view_history_btn_results.click(
-            show_history_page,
-            outputs=[input_page, results_page, history_page]
-        ).then(
-            sync_load_history,
+        results_tabs.select(
+            load_history_if_selected,
             inputs=[session_state],
-            outputs=[history_table, history_details_output]
+            outputs=[history_table_results, history_details_output_results]
         )
 
         back_to_input_btn.click(
@@ -2186,6 +2339,17 @@ Please try again with different parameters.
             outputs=[input_page, results_page, history_page]
         )
 
+        # History table selection handlers
+        history_table.select(
+            view_historical_analysis,
+            outputs=[history_details_output]
+        )
+
+        history_table_results.select(
+            view_historical_analysis,
+            outputs=[history_details_output_results]
+        )
+
         # Tax calculator button (Enhancement #5)
         tax_calculate_btn.click(
             calculate_tax_impact,
@@ -2282,8 +2446,8 @@ Please try again with different parameters.
             inputs=[login_email, login_password, session_state],
             outputs=[session_state, login_message, login_container, input_page, user_info]
         ).then(
-            lambda: gr.update(visible=True),
-            outputs=[logout_btn]
+            lambda: (gr.update(visible=True), gr.update(visible=True)),
+            outputs=[logout_btn, sidebar]
         )
 
         signup_btn.click(
@@ -2314,6 +2478,9 @@ Please try again with different parameters.
             handle_demo_mode,
             inputs=[session_state],
             outputs=[session_state, demo_message, login_container, input_page, user_info, logout_btn]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[sidebar]
         )
 
         logout_btn.click(
@@ -2321,8 +2488,33 @@ Please try again with different parameters.
             inputs=[session_state],
             outputs=[session_state, login_message, login_container, input_page, user_info]
         ).then(
-            lambda: gr.update(visible=False),
-            outputs=[logout_btn]
+            lambda: (gr.update(visible=False), gr.update(visible=False)),
+            outputs=[logout_btn, sidebar]
+        )
+
+        # Navigation event handlers
+        nav_new_analysis.click(
+            show_input_page,
+            outputs=[input_page, results_page, history_page]
+        )
+
+        nav_view_history.click(
+            show_history_page,
+            outputs=[input_page, results_page, history_page]
+        ).then(
+            sync_load_history,
+            inputs=[session_state],
+            outputs=[history_table, history_details_output]
+        )
+
+        # Sidebar sign out button (mirrors main logout button)
+        nav_signout_btn.click(
+            sync_logout,
+            inputs=[session_state],
+            outputs=[session_state, login_message, login_container, input_page, user_info]
+        ).then(
+            lambda: (gr.update(visible=False), gr.update(visible=False)),
+            outputs=[logout_btn, sidebar]
         )
 
     return demo

backend/database.py

@@ -279,6 +279,41 @@ class Database:
             logger.error(f"Failed to get analysis history: {e}")
             return []
 
+    async def get_analysis_by_id(
+        self,
+        analysis_id: str,
+        user_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get a specific analysis by ID with user authorisation check.
+
+        Args:
+            analysis_id: Analysis ID to retrieve
+            user_id: User ID for authorisation check
+
+        Returns:
+            Analysis data if found and authorised, None otherwise
+        """
+        if not self.is_connected():
+            return None
+
+        try:
+            # Join with portfolios to ensure user owns this analysis
+            result = self.client.table('portfolio_analyses') \
+                .select('*, portfolios!inner(user_id, risk_tolerance, name)') \
+                .eq('id', analysis_id) \
+                .eq('portfolios.user_id', user_id) \
+                .execute()
+
+            if result.data:
+                return result.data[0]
+            else:
+                logger.warning(f"Analysis {analysis_id} not found or not authorised for user {user_id}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Failed to get analysis by ID: {e}")
+            return None
+
 
 # Global database instance
 db = Database()

backend/visualizations/plotly_charts.py

@@ -115,6 +115,12 @@ def create_risk_metrics_dashboard(
     Returns:
         Plotly figure with 4 gauge charts
     """
+    # Convert to float in case values are strings from serialization
+    sharpe = float(sharpe) if sharpe else 0
+    var = float(var) if var else 0
+    cvar = float(cvar) if cvar else 0
+    volatility = float(volatility) if volatility else 0
+
     fig = make_subplots(
         rows=2, cols=2,
         specs=[
@@ -434,6 +440,10 @@ def create_optimization_comparison(
             sharpe = result.get('sharpe_ratio', 0)
             vol = result.get('volatility', 0)
 
+            # Convert to float in case values are strings
+            sharpe = float(sharpe) if sharpe else 0
+            vol = float(vol) if vol else 0
+
             methods.append(method.replace('_', ' ').title())
             sharpe_ratios.append(sharpe)
             volatilities.append(vol * 100 if vol < 1 else vol)  # Convert to percentage