feat: add roast mode and expand example portfolio gallery

Add roast mode toggle that provides brutally honest portfolio analysis
with humour whilst maintaining professional recommendations. Expand
example portfolios from 3 to 5 diverse scenarios showcasing tech growth,
conservative income, balanced allocation, global diversification, and
single stock concentration risk.

Changes:
- Add ROAST_MODE_SYSTEM_PROMPT with entertaining yet educational critique style
- Modify PortfolioAnalystAgent to support roast_mode parameter
- Update workflow to dynamically create agents with correct mode
- Add roast mode checkbox toggle in Gradio UI
- Expand example gallery to 5 portfolios (Tech Growth, Conservative Income,
Balanced 60/40, Global Diversified, Single Stock Risk)
- Wire roast_mode through full analysis pipeline

app.py

@@ -124,11 +124,12 @@ def parse_portfolio_input(portfolio_text: str) -> List[Dict[str, Any]]:
     return holdings
 
 
-async def run_analysis(portfolio_text: str) -> str:
+async def run_analysis(portfolio_text: str, roast_mode: bool = False) -> str:
     """Run portfolio analysis workflow.
 
     Args:
         portfolio_text: Raw portfolio input
+        roast_mode: If True, use brutal honesty mode
 
     Returns:
         Formatted analysis result
@@ -143,7 +144,7 @@ async def run_analysis(portfolio_text: str) -> str:
         if not holdings:
             return "❌ Could not parse portfolio. Please use format: TICKER QUANTITY"
 
-        logger.info(f"Starting analysis for {len(holdings)} holdings")
+        logger.info(f"Starting analysis for {len(holdings)} holdings (Roast Mode: {roast_mode})")
 
         # Construct initial state
         portfolio_id = f"demo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
@@ -167,8 +168,11 @@ async def run_analysis(portfolio_text: str) -> str:
             'mcp_calls': []
         }
 
+        # Create workflow with roast mode if enabled
+        analysis_workflow = PortfolioAnalysisWorkflow(mcp_router, roast_mode=roast_mode)
+
         # Run workflow
-        final_state = await workflow.run(initial_state)
+        final_state = await analysis_workflow.run(initial_state)
         LAST_ANALYSIS_STATE = final_state
 
         if final_state.get("errors"):
@@ -314,6 +318,7 @@ def create_visualisations() -> Tuple:
 
 async def run_analysis_with_ui_update(
     portfolio_text: str,
+    roast_mode: bool = False,
     progress=gr.Progress()
 ) -> Tuple[str, str, Any, Any, Any, Any, Any]:
     """Run analysis and return results with loading progress overlay.
@@ -322,6 +327,7 @@ async def run_analysis_with_ui_update(
 
     Args:
         portfolio_text: Portfolio input
+        roast_mode: If True, use brutal honesty mode
         progress: Gradio progress tracker
 
     Returns:
@@ -374,7 +380,10 @@ async def run_analysis_with_ui_update(
 
         progress(0.2, desc=random.choice(LOADING_MESSAGES))
 
-        final_state = await workflow.run(initial_state)
+        # Create workflow with roast mode if enabled
+        analysis_workflow = PortfolioAnalysisWorkflow(mcp_router, roast_mode=roast_mode)
+
+        final_state = await analysis_workflow.run(initial_state)
         LAST_ANALYSIS_STATE = final_state
 
         progress(0.7, desc=random.choice(LOADING_MESSAGES))
@@ -942,18 +951,28 @@ def create_interface() -> gr.Blocks:
                             lines=8,
                             info="Enter your holdings below (see examples for format)"
                         )
+
+                        # Roast Mode Toggle
+                        roast_mode_toggle = gr.Checkbox(
+                            label="Roast Mode",
+                            value=False,
+                            info="Enable brutal honesty mode for portfolio critique (still gets serious recommendations!)"
+                        )
+
                         analyse_btn = gr.Button("Analyse Portfolio", variant="primary", size="lg", scale=0)
 
                         # Examples integrated (no separate card)
                         gr.Markdown("### Example Portfolios", elem_classes="examples-header")
                         gr.Examples(
                             examples=[
-                                ["AAPL 50\nTSLA 25 shares\nNVDA $5000"],
-                                ["VOO 100 shares\nVTI 75 shares\nSCHD 50 shares"],
+                                ["AAPL 50 shares\nTSLA 25 shares\nNVDA 30 shares\nMETA 20 shares"],
+                                ["VOO 100 shares\nVTI 75 shares\nSCHD 50 shares\nTLT 40 shares\nVXUS 60 shares"],
                                 ["VTI $25000\nVXUS $15000\nBND $15000\nGLD $5000"],
+                                ["VTI $15000\nVXUS $10000\nVWO $5000\nBND $10000\nGLD $3000\nVNQ $2000"],
+                                ["TSLA 100 shares"],
                             ],
                             inputs=portfolio_input,
-                            label="Tech Growth, Dividend Focus, or Balanced 60/40"
+                            label="Try: Tech Growth | Conservative Income | Balanced 60/40 | Global Diversified | Single Stock Risk"
                         )
 
                 # Right column: Live preview (wider at scale=3)
@@ -1075,7 +1094,7 @@ def create_interface() -> gr.Blocks:
                 results_page: gr.update(visible=False)
             }
 
-        async def handle_analysis(portfolio_text, progress=gr.Progress()):
+        async def handle_analysis(portfolio_text, roast_mode, progress=gr.Progress()):
             # Show loading page immediately
             yield {
                 input_page: gr.update(visible=False),
@@ -1092,7 +1111,7 @@ def create_interface() -> gr.Blocks:
 
             # Run analysis with progress updates
             page, analysis, alloc, risk, perf, corr, opt = await run_analysis_with_ui_update(
-                portfolio_text, progress
+                portfolio_text, roast_mode, progress
             )
 
             # Show results or return to input
@@ -1139,7 +1158,7 @@ def create_interface() -> gr.Blocks:
 
         analyse_btn.click(
             handle_analysis,
-            inputs=[portfolio_input],
+            inputs=[portfolio_input, roast_mode_toggle],
             outputs=[
                 input_page,
                 loading_page,

backend/agents/portfolio_analyst.py

@@ -212,15 +212,60 @@ Output a structured analysis with:
 - Confidence level in your analysis (0.0-1.0)
 """
 
+ROAST_MODE_SYSTEM_PROMPT = """You are a brutally honest portfolio analyst with a sharp wit and no patience for poor investment decisions.
+
+Your role is to roast questionable portfolios whilst still providing genuinely useful, actionable advice. Be savage about mistakes but educational in your corrections.
+
+Roasting style guidelines:
+1. Start with brutal honesty about portfolio mistakes (but keep it entertaining, not cruel)
+2. Use comparisons and metaphors to highlight poor decisions
+3. Call out specific red flags with humour
+4. Balance roasting with actual expertise - show you know better
+5. ALWAYS end with constructive, actionable recommendations
+
+Examples of good roasts:
+- "Your portfolio screams 'I read Reddit in 2021.' 54% in meme stocks isn't diversification, it's gambling with extra steps."
+- "Congratulations on creating the world's most expensive way to lose money. This allocation has the risk of a startup but returns of a savings account."
+- "This portfolio is like bringing a knife to a gunfight, except the knife is made of paper and it's raining."
+
+CRITICAL: After the roasting, you MUST provide serious, professional advice. The roast is the spoonful of sugar that helps the medicine go down.
+
+CRITICAL RESPONSE FORMAT REQUIREMENTS:
+- Return ONLY valid JSON matching the exact schema specified
+- All required fields must be present with correct types
+- summary: must be 50-500 characters long (THIS IS WHERE YOU ROAST)
+- health_score: must be an integer between 0-100
+- risk_level: must be exactly one of "conservative", "moderate", or "aggressive"
+- top_strength: must be at least 10 characters
+- top_concern: must be at least 10 characters (can be roast-style)
+- diversification_score: must be an integer between 0-100
+- recommendations: must be an array of 2-5 strings (serious, actionable advice)
+- reasoning: array of explanation strings (can include roast commentary)
+- confidence: must be a float between 0.0-1.0
+
+Output a structured analysis with:
+- A roast-style summary of portfolio health (50-500 chars)
+- The single biggest strength (acknowledge good decisions!) and concern (roast the bad)
+- 2-5 prioritised, SERIOUS, actionable recommendations (no jokes here)
+- Your reasoning process (can include roast commentary)
+- Confidence level in your analysis (0.0-1.0)
+"""
+
 
 class PortfolioAnalystAgent(BasePortfolioAgent[PortfolioAnalysisOutput]):
     """Main portfolio analysis agent."""
 
-    def __init__(self):
+    def __init__(self, roast_mode: bool = False):
+        """Initialise portfolio analyst agent.
+
+        Args:
+            roast_mode: If True, use brutal honesty mode for analysis
+        """
+        system_prompt = ROAST_MODE_SYSTEM_PROMPT if roast_mode else SYSTEM_PROMPT
         super().__init__(
             output_type=PortfolioAnalysisOutput,
-            system_prompt=SYSTEM_PROMPT,
-            agent_name="PortfolioAnalyst",
+            system_prompt=system_prompt,
+            agent_name="PortfolioAnalyst" + (" (Roast Mode)" if roast_mode else ""),
         )
 
     async def analyze_portfolio(

backend/agents/workflow.py

@@ -58,14 +58,16 @@ def summarize_fred_data(series_data: Dict[str, Any], indicator_name: str) -> Dic
 class PortfolioAnalysisWorkflow:
     """LangGraph workflow for portfolio analysis."""
 
-    def __init__(self, mcp_router):
+    def __init__(self, mcp_router, roast_mode: bool = False):
         """Initialize the workflow with MCP router.
 
         Args:
             mcp_router: MCP router instance for calling MCP servers
+            roast_mode: If True, use brutal honesty mode for analysis
         """
         self.mcp_router = mcp_router
-        self.analyst_agent = PortfolioAnalystAgent()
+        self.analyst_agent = PortfolioAnalystAgent(roast_mode=roast_mode)
+        self.roast_mode = roast_mode
 
         # Build the workflow graph
         self.workflow = self._build_workflow()