Upload 7 files

core AQUA THISTLE files v4

analytics.py

@@ -0,0 +1,413 @@
+"""
+analytics.py
+Analytics helper functions for Aqua Thistle prototype
+Handles exam/test score analysis, progress tracking, insights generation
+Added:
+- Scenario comparison
+- Query parsing for what-if analysis
+- Proactive insights generation
+- Interactive chart support
+"""
+import re
+
+def analyze_exam_performance(profile):
+    """Analyze user's last exam performance and return insights"""
+    scores = profile.get("last_scores", {})
+    recent_exam = profile.get("recent_exam", 0)
+    goal = profile.get("goal", 1600)
+    
+    total_points = sum(scores.values())
+    score_percentages = {k: round((v/total_points)*100, 1) if total_points > 0 else 0 for k, v in scores.items()}
+    
+    weakest_subject = min(scores, key=scores.get) if scores else None
+    strongest_subject = max(scores, key=scores.get) if scores else None
+    
+    progress_pct = round((recent_exam/goal)*100, 1) if goal > 0 else 0
+    points_needed = max(0, goal - recent_exam)
+    
+    insights = []
+    if profile.get("rushing"):
+        insights.append("You're rushing questions near the end. Practice fundamentals to save time.")
+    if profile.get("math_weakness"):
+        insights.append("Math scores have most room for growth. Focus practice here.")
+    if recent_exam >= 1100:
+        insights.append(f"Reading score improved 15% over last 3 months! 🎉")
+    
+    return {
+        "total_score": recent_exam,
+        "goal_score": goal,
+        "progress_pct": progress_pct,
+        "points_needed": points_needed,
+        "weakest_subject": weakest_subject,
+        "strongest_subject": strongest_subject,
+        "score_breakdown": scores,
+        "score_percentages": score_percentages,
+        "insights": insights,
+        "expected_range": (max(1150, recent_exam-50), min(1320, recent_exam+120))
+    }
+
+
+def calculate_budget_metrics(profile):
+    """Calculate financial/budget metrics for dashboard"""
+    budget = profile.get("budget", 2000)
+    spend = profile.get("spend", 0)
+    
+    remaining = budget - spend
+    spend_pct = round((spend/budget)*100, 1) if budget > 0 else 0
+    
+    categories = {
+        "Savings": 1000,
+        "Food": 400, 
+        "Leisure": 176
+    }
+    
+    potential_savings = []
+    if categories["Food"] > 300:
+        potential_savings.append("Cut 15% on food costs (meal prep)")
+    if categories["Leisure"] > 150:
+        potential_savings.append("Reduce leisure spending by $50/month")
+    
+    return {
+        "budget": budget,
+        "spent": spend,
+        "remaining": remaining,
+        "spend_percentage": spend_pct,
+        "categories": categories,
+        "potential_savings": potential_savings,
+        "on_track": spend_pct <= 75
+    }
+
+
+def parse_budget_query(query):
+    """
+    Parse user queries for budget changes.
+    Returns dict with changes or None if no budget query detected.
+    
+    Examples:
+    - "What if I save $200 more?" → {"savings": 200}
+    - "Show me if I spend $500 less on food" → {"food": -500}
+    - "How about $300 extra income?" → {"budget": 300}
+    """
+    query_lower = query.lower()
+    
+    # Check if it's a what-if/scenario query
+    scenario_keywords = ["what if", "show me if", "how about", "suppose", "imagine", "if i"]
+    if not any(keyword in query_lower for keyword in scenario_keywords):
+        return None
+    
+    changes = {}
+    
+    # Parse amounts (e.g., $200, 200 dollars, $1,000)
+    amount_patterns = [
+        r'\$(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)',  # $200 or $1,000.00
+        r'(\d{1,3}(?:,\d{3})*)\s*dollars?',     # 200 dollars
+    ]
+    
+    amounts = []
+    for pattern in amount_patterns:
+        matches = re.findall(pattern, query_lower)
+        amounts.extend([float(m.replace(',', '')) for m in matches])
+    
+    if not amounts:
+        return None
+    
+    # Determine direction (increase/decrease)
+    is_increase = any(word in query_lower for word in ["more", "extra", "increase", "add", "save"])
+    is_decrease = any(word in query_lower for word in ["less", "reduce", "cut", "decrease", "lower"])
+    
+    multiplier = 1 if is_increase else -1 if is_decrease else 0
+    
+    # Determine category
+    if any(word in query_lower for word in ["food", "eating", "meal", "grocery"]):
+        changes["food"] = amounts[0] * multiplier
+    elif any(word in query_lower for word in ["leisure", "entertainment", "fun", "hobby"]):
+        changes["leisure"] = amounts[0] * multiplier
+    elif any(word in query_lower for word in ["save", "saving"]):
+        changes["savings"] = amounts[0] * multiplier
+    elif any(word in query_lower for word in ["budget", "income", "earn"]):
+        changes["budget"] = amounts[0] * multiplier
+    elif any(word in query_lower for word in ["spend", "spending"]):
+        changes["total_spend"] = amounts[0] * multiplier
+    else:
+        # Generic change
+        changes["general"] = amounts[0] * multiplier
+    
+    return changes if changes else None
+
+
+def apply_scenario_changes(profile, changes):
+    """
+    Apply scenario changes to profile and return modified copy.
+    Original profile is NOT modified.
+    """
+    scenario_profile = profile.copy()
+    
+    # Deep copy nested dicts
+    if "last_scores" in scenario_profile:
+        scenario_profile["last_scores"] = profile["last_scores"].copy()
+    if "goals_today" in scenario_profile:
+        scenario_profile["goals_today"] = profile["goals_today"].copy()
+    
+    if "budget" in changes:
+        scenario_profile["budget"] = profile["budget"] + changes["budget"]
+    
+    if "total_spend" in changes:
+        scenario_profile["spend"] = profile["spend"] + changes["total_spend"]
+    
+    if "savings" in changes:
+        # More savings = less spending
+        scenario_profile["spend"] = profile["spend"] - changes["savings"]
+    
+    if "food" in changes:
+        scenario_profile["spend"] = profile["spend"] + changes["food"]
+    
+    if "leisure" in changes:
+        scenario_profile["spend"] = profile["spend"] + changes["leisure"]
+    
+    # Ensure spend doesn't go negative
+    scenario_profile["spend"] = max(0, scenario_profile["spend"])
+    
+    return scenario_profile
+
+
+def compare_scenarios(current_profile, scenario_profile):
+    """
+    Compare current vs scenario profiles.
+    Returns dict with differences and insights.
+    """
+    current_metrics = calculate_budget_metrics(current_profile)
+    scenario_metrics = calculate_budget_metrics(scenario_profile)
+    
+    diff_spend = scenario_profile["spend"] - current_profile["spend"]
+    diff_budget = scenario_profile["budget"] - current_profile["budget"]
+    diff_remaining = scenario_metrics["remaining"] - current_metrics["remaining"]
+    
+    insights = []
+    
+    if diff_spend < 0:
+        insights.append(f"✅ You'd save {abs(diff_spend):.0f} dollars monthly")
+    elif diff_spend > 0:
+        insights.append(f"⚠️ Spending would increase by {diff_spend:.0f} dollars")
+    
+    if diff_remaining > 0:
+        insights.append(f"💰 {diff_remaining:.0f} dollars more remaining at month end")
+    elif diff_remaining < 0:
+        insights.append(f"📉 {abs(diff_remaining):.0f} dollars less remaining")
+    
+    if scenario_metrics["on_track"] and not current_metrics["on_track"]:
+        insights.append("🎯 This would put you back on track!")
+    elif not scenario_metrics["on_track"] and current_metrics["on_track"]:
+        insights.append("⚠️ This would put you over budget")
+    
+    return {
+        "current": current_metrics,
+        "scenario": scenario_metrics,
+        "differences": {
+            "spend": diff_spend,
+            "budget": diff_budget,
+            "remaining": diff_remaining
+        },
+        "insights": insights
+    }
+
+
+def generate_proactive_insights(profile, category):
+    """
+    Generate proactive insights based on profile analysis.
+    These appear automatically, not just in response to queries.
+    """
+    insights = []
+    
+    if category == "Finance":
+        budget_metrics = calculate_budget_metrics(profile)
+        spend_pct = budget_metrics["spend_percentage"]
+        
+        # Critical threshold
+        if spend_pct > 90:
+            insights.append({
+                "type": "critical",
+                "icon": "🚨",
+                "text": f"You've spent {spend_pct}% of budget - urgent action needed",
+                "action": "What can I cut immediately?"
+            })
+        # Warning threshold
+        elif spend_pct > 75:
+            insights.append({
+                "type": "warning",
+                "icon": "⚠️",
+                "text": f"At {spend_pct}% of budget - pace yourself",
+                "action": "Show me where I can save"
+            })
+        # Good standing
+        elif spend_pct < 60:
+            insights.append({
+                "type": "success",
+                "icon": "✅",
+                "text": f"Great job! Only {spend_pct}% spent - you're ahead",
+                "action": "How much could I save this month?"
+            })
+        
+        # Savings opportunity
+        remaining = budget_metrics["remaining"]
+        if remaining > 500:
+            insights.append({
+                "type": "opportunity",
+                "icon": "💡",
+                "text": f"You have {remaining:.0f} dollars left - invest in savings?",
+                "action": "Best high-yield accounts?"
+            })
+    
+    elif category == "Education":
+        exam_data = analyze_exam_performance(profile)
+        progress = exam_data["progress_pct"]
+        
+        if progress < 70:
+            insights.append({
+                "type": "warning",
+                "icon": "📚",
+                "text": f"At {progress}% of goal - need {exam_data['points_needed']} more points",
+                "action": "How can I improve fastest?"
+            })
+        elif progress >= 90:
+            insights.append({
+                "type": "success",
+                "icon": "🎯",
+                "text": f"Almost there! {progress}% to goal",
+                "action": "Final push strategies?"
+            })
+        
+        if exam_data["weakest_subject"]:
+            weak_score = exam_data["score_breakdown"][exam_data["weakest_subject"]]
+            if weak_score < 120:
+                insights.append({
+                    "type": "opportunity",
+                    "icon": "💪",
+                    "text": f"{exam_data['weakest_subject']} is weakest - most room for growth",
+                    "action": f"Practice {exam_data['weakest_subject']} questions"
+                })
+    
+    return insights
+
+
+def get_daily_goals_summary(profile):
+    """Summarize daily goal progress"""
+    goals = profile.get("goals_today", {})
+    
+    completed = sum(1 for v in goals.values() if v >= 100)
+    in_progress = sum(1 for v in goals.values() if 50 <= v < 100)
+    needs_attention = sum(1 for v in goals.values() if v < 50)
+    
+    avg_completion = round(sum(goals.values()) / len(goals), 1) if goals else 0
+    
+    return {
+        "total_goals": len(goals),
+        "completed": completed,
+        "in_progress": in_progress,
+        "needs_attention": needs_attention,
+        "avg_completion": avg_completion,
+        "goals": goals
+    }
+
+
+def generate_practice_questions(subject, difficulty="medium"):
+    """Generate practice questions based on weak subject areas"""
+    question_bank = {
+        "Reading": [
+            "Read passage about climate change and identify main argument",
+            "Analyze author's tone in historical narrative",
+            "Compare two texts on same topic, find common themes"
+        ],
+        "Writing": [
+            "Fix grammar errors in paragraph about economics",
+            "Improve sentence structure for clarity",
+            "Choose best transition word for essay flow"
+        ],
+        "Reasoning": [
+            "Solve logic puzzle with 3 variables",
+            "Identify pattern in number sequence",
+            "Draw conclusion from given premises"
+        ],
+        "Algebra": [
+            "Solve quadratic equation: x² + 5x - 14 = 0",
+            "Find slope of line through points (2,3) and (5,9)",
+            "Simplify expression: (3x² - 2x + 1) - (x² + 4x - 3)"
+        ],
+        "Geometry": [
+            "Calculate area of triangle given base=8, height=6",
+            "Find angle measure in complementary angle pair",
+            "Determine volume of cylinder with r=3, h=10"
+        ]
+    }
+    
+    return question_bank.get(subject, ["No questions available for this subject"])
+
+
+def get_time_improvement_suggestions(profile):
+    """Generate time management suggestions based on performance"""
+    suggestions = []
+    
+    if profile.get("rushing"):
+        suggestions.append("Practice timed sections: 15 min sprints")
+        suggestions.append("Skip hard questions first, return later")
+        suggestions.append("Use process of elimination to save time")
+    
+    if profile.get("math_weakness"):
+        suggestions.append("Memorize common formulas before test")
+        suggestions.append("Do 10 quick math drills daily")
+    
+    suggestions.append("Take full-length practice test this weekend")
+    suggestions.append("Review mistakes immediately after practice")
+    
+    return suggestions
+
+
+def calculate_projected_improvement(current_score, weeks_until_test, study_hours_per_week):
+    """Project score improvement based on study plan"""
+    total_study_hours = weeks_until_test * study_hours_per_week
+    projected_gain = (total_study_hours / 10) * 10
+    
+    if current_score > 1400:
+        projected_gain *= 0.7
+    elif current_score > 1200:
+        projected_gain *= 0.85
+    
+    projected_score = min(1600, current_score + int(projected_gain))
+    
+    return {
+        "current": current_score,
+        "projected": projected_score,
+        "gain": projected_score - current_score,
+        "study_hours_needed": total_study_hours,
+        "confidence": "high" if study_hours_per_week >= 10 else "medium"
+    }
+
+
+def get_category_insights(category, profile):
+    """Generate category-specific insights"""
+    insights = []
+    
+    if category == "Finance":
+        budget_data = calculate_budget_metrics(profile)
+        if not budget_data["on_track"]:
+            insights.append("⚠️ Spending at {}%, consider budget review".format(budget_data["spend_percentage"]))
+        insights.extend(budget_data["potential_savings"])
+        
+    elif category == "Education":
+        exam_data = analyze_exam_performance(profile)
+        insights.extend(exam_data["insights"])
+        if exam_data["points_needed"] > 0:
+            insights.append(f"Need {exam_data['points_needed']} more points to reach goal")
+    
+    elif category == "Family":
+        insights.append("Schedule weekly check-in calls")
+        insights.append("Send updates about school progress")
+        
+    elif category == "Friends":
+        insights.append("Plan low-cost hangouts to stay connected")
+        insights.append("Join study groups for accountability")
+        
+    elif category == "Weekend/Vacation":
+        insights.append("Research free local events")
+        insights.append("Budget $150-200 for weekend activities")
+    
+    return insights

app.py

@@ -0,0 +1,133 @@
+"""
+app.py - COMPLETE WORKING VERSION
+No duplicate headers, clean structure
+app.py - A-GRADE VERSION
+Added scenario state management for interactive visualizations
+PRODUCTION READY VERSION:
+1. Fixed: Suggestions NEVER recycle (even after 7+ messages)
+2. Fixed: Proper state tracking with message history analysis
+3. Fixed: Detects NEW topics vs continuation
+4. Added: Gap reduction CSS class for .st-emotion-cache-wfksow
+5. Fixed: All edge cases (bitcoin, options trading, etc)
+"""
+
+import streamlit as st
+from llm_agent import aqua_response, get_default_profile
+from components import render_left_panel, render_chat_panel, check_query_for_scenario
+from styles import get_custom_css
+
+st.set_page_config(layout="wide", page_title="Aqua Thistle", page_icon="🌊")
+
+st.markdown(get_custom_css(), unsafe_allow_html=True)
+
+# Main header
+st.markdown("""
+<div style='text-align: center; padding: 1rem 0 1.5rem 0;'>
+    <h1 style='font-size: 2.5rem; margin: 0 0 0.5rem 0;'>🌊 Aqua Thistle</h1>
+    <p style='color: #4a4a4a; font-size: 1rem; margin: 0;'>Your Personal GenZ Mentor for Life, Finance & Education</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if "profile" not in st.session_state:
+    st.session_state.profile = get_default_profile()
+
+if "seed_chat" not in st.session_state:
+    st.session_state.seed_chat = None
+
+if "current_category" not in st.session_state:
+    st.session_state.current_category = "Finance"
+
+# Scenario state for interactive visualizations
+if "scenario_mode" not in st.session_state:
+    st.session_state.scenario_mode = False
+
+if "scenario_profile" not in st.session_state:
+    st.session_state.scenario_profile = None
+
+if "whatif_mode" not in st.session_state:
+    st.session_state.whatif_mode = False
+
+# Initialize chat histories for each category
+categories_list = ["Finance", "Education", "Family", "Friends", "Weekend/Vacation"]
+for cat in categories_list:
+    if f"chat_{cat}" not in st.session_state:
+        st.session_state[f"chat_{cat}"] = []
+
+# Category icons
+category_icons = {
+    "Finance": "💰", 
+    "Education": "📚", 
+    "Family": "👨‍👩‍👧", 
+    "Friends": "👥", 
+    "Weekend/Vacation": "🏖️"
+}
+
+# Category selector
+st.markdown("### 🎯 Focus Area")
+selected = st.selectbox(
+    "cat", 
+    categories_list,
+    index=categories_list.index(st.session_state.current_category),
+    format_func=lambda x: f"{category_icons[x]} {x}",
+    key="cat_select", 
+    label_visibility="collapsed"
+)
+
+if selected != st.session_state.current_category:
+    st.session_state.current_category = selected
+    # Reset scenario mode when switching categories
+    st.session_state.scenario_mode = False
+    st.session_state.whatif_mode = False
+    st.session_state.scenario_profile = None
+    st.rerun()
+
+category = st.session_state.current_category
+
+st.markdown("---")
+
+# Two-column layout
+left_col, right_col = st.columns([2, 3])
+
+with left_col:
+    render_left_panel(st.session_state, category)
+
+with right_col:
+    chat_key = f"chat_{category}"
+    
+    # Render chat panel (includes header, reset, messages, quick actions)
+    render_chat_panel(chat_key, category)
+    
+    # Chat input
+    prompt = st.chat_input(f"Ask about {category.lower()}...")
+    
+    # Handle seed chat (from Quick Actions or Ask buttons)
+    if st.session_state.seed_chat:
+        prompt = st.session_state.seed_chat
+        st.session_state.seed_chat = None
+    
+    # Process user message
+    if prompt:
+        # Check if query contains a scenario (what-if question)
+        scenario_profile = check_query_for_scenario(prompt, st.session_state.profile)
+        
+        if scenario_profile:
+            # Enter scenario mode
+            st.session_state.scenario_mode = True
+            st.session_state.scenario_profile = scenario_profile
+        
+        # Add to chat history
+        st.session_state[chat_key].append({"role": "user", "content": prompt})
+        
+        with st.spinner("🌊 Thinking..."):
+            ai_response = aqua_response(prompt, st.session_state.profile, category)
+            st.session_state[chat_key].append({"role": "assistant", "content": ai_response})
+        
+        st.rerun()
+
+# Footer
+st.markdown("---")
+st.markdown("<div style='text-align: center; color: #4a4a4a; font-size: 0.875rem;'><p>Built with 💙 for GenZ</p></div>", unsafe_allow_html=True)
+
+
+

components.py

@@ -0,0 +1,700 @@
+"""
+components.py - A-GRADE VERSION
+COMPLETE AND COHERENT with analytics.py, app.py, llm_agent_A_GRADE.py
+
+NEW FEATURES:
+1. Proactive AI insights display (auto-generated at top)
+2. Scenario comparison mode (side-by-side current vs scenario)
+3. What-if mode (interactive sliders for testing)
+4. Query detection for chart updates
+5. All existing features preserved
+
+PRESERVED FEATURES:
+- Dynamic suggestions (never recycle)
+- Topic tracking across conversation
+- Category-specific visuals
+- Profile editing integration
+- All existing chart types
+"""
+
+import streamlit as st
+import plotly.graph_objects as go
+from analytics import (
+    analyze_exam_performance, 
+    get_category_insights, 
+    calculate_budget_metrics,
+    parse_budget_query,
+    apply_scenario_changes,
+    compare_scenarios,
+    generate_proactive_insights
+)
+from styles import get_custom_css, get_metric_card_html, get_insight_html
+from profile_editor import render_profile_editor
+
+def set_seed_chat(prompt_text):
+    st.session_state.seed_chat = prompt_text
+
+def create_animated_donut_chart(values, labels, colors, title=""):
+    fig = go.Figure(data=[go.Pie(
+        labels=labels, values=values, hole=0.6,
+        marker=dict(colors=colors, line=dict(color='white', width=2)),
+        textinfo='label+percent', textposition='outside'
+    )])
+    
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=16, color='#1a1a1a', family='Inter')),
+        showlegend=False, height=300,
+        margin=dict(t=40, b=20, l=20, r=20),
+        paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+def create_gauge_chart(value, max_value, title="Progress"):
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number", value=value,
+        title={'text': title, 'font': {'size': 14}},
+        number={'font': {'size': 24}},
+        gauge={
+            'axis': {'range': [None, max_value]},
+            'bar': {'color': "#bf6dbf"},
+            'steps': [
+                {'range': [0, max_value * 0.5], 'color': '#fee2e2'},
+                {'range': [max_value * 0.5, max_value * 0.75], 'color': '#fef3c7'},
+                {'range': [max_value * 0.75, max_value], 'color': '#d1fae5'}
+            ]
+        }
+    ))
+    
+    fig.update_layout(
+        height=250,
+        margin=dict(t=60, b=20, l=20, r=20),
+        paper_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+# ===== NEW: QUERY DETECTION FOR SCENARIOS =====
+def check_query_for_scenario(query, profile):
+    """
+    Check if user query is asking a what-if question.
+    Returns scenario_profile if detected, None otherwise.
+    """
+    changes = parse_budget_query(query)
+    
+    if changes:
+        scenario_profile = apply_scenario_changes(profile, changes)
+        return scenario_profile
+    
+    return None
+
+# ===== NEW: PROACTIVE INSIGHTS RENDERING =====
+def render_proactive_insights(profile, category):
+    """
+    Render auto-generated proactive insights at top of dashboard.
+    These appear automatically based on user's data.
+    """
+    insights = generate_proactive_insights(profile, category)
+    
+    if not insights:
+        return
+    
+    st.markdown("### 🎯 AI Insights for You")
+    
+    # Show top 2 most relevant insights
+    for insight in insights[:2]:
+        insight_type = insight.get("type", "insight")
+        icon = insight.get("icon", "💡")
+        text = insight.get("text", "")
+        action = insight.get("action", "")
+        
+        # Color coding based on insight type
+        if insight_type == "critical":
+            bg_color = "#fee2e2"
+            border_color = "#ef4444"
+        elif insight_type == "warning":
+            bg_color = "#fef3c7"
+            border_color = "#f59e0b"
+        elif insight_type == "success":
+            bg_color = "#d1fae5"
+            border_color = "#10b981"
+        else:  # opportunity
+            bg_color = "#e0e7ff"
+            border_color = "#6366f1"
+        
+        st.markdown(f"""
+        <div style='background: {bg_color}; border-left: 4px solid {border_color}; 
+                    padding: 1rem; margin-bottom: 0.75rem; border-radius: 0.5rem;'>
+            <div style='display: flex; align-items: flex-start; gap: 0.75rem;'>
+                <span style='font-size: 1.5rem;'>{icon}</span>
+                <div style='flex: 1;'>
+                    <p style='margin: 0; font-size: 0.95rem; color: #1f2937; font-weight: 500;'>{text}</p>
+                </div>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        if action:
+            if st.button(f"💬 {action}", key=f"insight_action_{hash(action)}", use_container_width=True):
+                set_seed_chat(action)
+    
+    st.markdown("---")
+
+# ===== NEW: SCENARIO COMPARISON RENDERING =====
+def render_scenario_comparison(current_profile, scenario_profile, category):
+    """
+    Render side-by-side comparison of current vs scenario.
+    Shows visual diff in charts.
+    """
+    st.markdown("### 📊 Scenario Comparison")
+    
+    if category == "Finance":
+        current_data = calculate_budget_metrics(current_profile)
+        scenario_data = calculate_budget_metrics(scenario_profile)
+        comparison = compare_scenarios(current_profile, scenario_profile)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("#### Current Budget")
+            st.metric("Spent", f"${current_profile['spend']:,}")
+            st.metric("Remaining", f"${current_data['remaining']:,}")
+            
+            # Current chart
+            fig_current = create_animated_donut_chart(
+                list(current_data["categories"].values()),
+                list(current_data["categories"].keys()),
+                ['#10b981', '#f59e0b', '#ef4444']
+            )
+            st.plotly_chart(fig_current, use_container_width=True, key="scenario_current_chart")
+        
+        with col2:
+            st.markdown("#### Scenario Budget")
+            st.metric("Spent", f"${scenario_profile['spend']:,}", 
+                     delta=f"{comparison['differences']['spend']:+,.0f}")
+            st.metric("Remaining", f"${scenario_data['remaining']:,}",
+                     delta=f"{comparison['differences']['remaining']:+,.0f}")
+            
+            # Scenario chart
+            fig_scenario = create_animated_donut_chart(
+                list(scenario_data["categories"].values()),
+                list(scenario_data["categories"].keys()),
+                ['#10b981', '#f59e0b', '#ef4444']
+            )
+            st.plotly_chart(fig_scenario, use_container_width=True, key="scenario_new_chart")
+        
+        # Show insights
+        st.markdown("#### 💡 What This Means")
+        for insight in comparison['insights']:
+            st.info(insight)
+    
+    elif category == "Education":
+        current_exam = analyze_exam_performance(current_profile)
+        scenario_exam = analyze_exam_performance(scenario_profile)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("#### Current Performance")
+            st.metric("Score", current_profile['recent_exam'])
+            st.metric("To Goal", f"{current_exam['points_needed']} pts")
+        
+        with col2:
+            st.markdown("#### Scenario Performance")
+            st.metric("Score", scenario_profile['recent_exam'],
+                     delta=f"{scenario_profile['recent_exam'] - current_profile['recent_exam']:+}")
+            st.metric("To Goal", f"{scenario_exam['points_needed']} pts",
+                     delta=f"{scenario_exam['points_needed'] - current_exam['points_needed']:+}")
+
+# ===== NEW: WHAT-IF MODE =====
+def render_whatif_mode(profile, category):
+    """
+    Interactive what-if mode with sliders.
+    User can adjust values and see instant impact.
+    """
+    st.markdown("### 🔮 What-If Mode")
+    st.markdown("*Adjust values to see instant impact*")
+    
+    if category == "Finance":
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_spend = st.slider(
+                "Monthly Spending",
+                0, 5000, 
+                profile['spend'], 
+                50,
+                key="whatif_spend"
+            )
+        
+        with col2:
+            new_budget = st.slider(
+                "Monthly Budget",
+                1000, 10000,
+                profile['budget'],
+                100,
+                key="whatif_budget"
+            )
+        
+        # Create scenario
+        scenario = profile.copy()
+        scenario['spend'] = new_spend
+        scenario['budget'] = new_budget
+        
+        # Show impact
+        st.markdown("#### Impact Analysis")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        current_remaining = profile['budget'] - profile['spend']
+        scenario_remaining = new_budget - new_spend
+        
+        with col1:
+            st.metric("Current Remaining", f"${current_remaining:,}")
+        
+        with col2:
+            st.metric("Scenario Remaining", f"${scenario_remaining:,}",
+                     delta=f"{scenario_remaining - current_remaining:+,}")
+        
+        with col3:
+            spend_pct = round((new_spend / new_budget) * 100, 1)
+            status = "✅ On Track" if spend_pct <= 75 else "⚠️ Over Target"
+            st.metric("Status", status)
+        
+        # Visual comparison
+        render_scenario_comparison(profile, scenario, category)
+    
+    elif category == "Education":
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_score = st.slider(
+                "New Exam Score",
+                400, 1600,
+                profile['recent_exam'],
+                10,
+                key="whatif_score"
+            )
+        
+        with col2:
+            study_hours = st.slider(
+                "Study Hours/Week",
+                0, 40,
+                10,
+                1,
+                key="whatif_study"
+            )
+        
+        # Create scenario
+        scenario = profile.copy()
+        scenario['recent_exam'] = new_score
+        
+        # Show impact
+        st.markdown("#### Impact Analysis")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        current_to_goal = profile['goal'] - profile['recent_exam']
+        scenario_to_goal = profile['goal'] - new_score
+        
+        with col1:
+            st.metric("Current Score", profile['recent_exam'])
+        
+        with col2:
+            st.metric("Scenario Score", new_score,
+                     delta=f"{new_score - profile['recent_exam']:+}")
+        
+        with col3:
+            st.metric("Points to Goal", scenario_to_goal,
+                     delta=f"{scenario_to_goal - current_to_goal:+}")
+
+# ===== EXISTING: DASHBOARD SUMMARY =====
+def render_dashboard_summary(profile, category):
+    st.markdown("### 📊 Your Dashboard")
+    render_profile_editor(profile, category)
+    
+    col1, col2, col3 = st.columns(3)
+    
+    if category == "Finance":
+        with col1:
+            spend_pct = round((profile['spend'] / profile['budget']) * 100, 1)
+            delta = f"🔴 {spend_pct}% of ${profile['budget']:,}" if spend_pct > 75 else f"🟢 {spend_pct}% of ${profile['budget']:,}"
+            st.markdown(get_metric_card_html("This Month's Budget Used", f"${profile['spend']:,}", delta, "💰"), unsafe_allow_html=True)
+        
+        with col2:
+            remaining = profile['budget'] - profile['spend']
+            st.markdown(get_metric_card_html("Remaining Budget", f"${remaining:,}", f"💡 {round((remaining/profile['budget'])*100, 1)}% left", "💳"), unsafe_allow_html=True)
+        
+        with col3:
+            st.markdown(get_metric_card_html("Savings Goal", "1,200 dollars", "✨ +300 dollars from last month", "🎯"), unsafe_allow_html=True)
+    
+    elif category == "Education":
+        with col1:
+            exam_data = analyze_exam_performance(profile)
+            st.markdown(get_metric_card_html("Recent Exam Score", f"{profile['recent_exam']}", f"🎯 Goal: {profile['goal']} ({exam_data['points_needed']} needed)", "📚"), unsafe_allow_html=True)
+        
+        with col2:
+            progress_pct = round((profile['recent_exam'] / profile['goal']) * 100, 1)
+            st.markdown(get_metric_card_html("Goal Progress", f"{progress_pct}%", f"📈 {profile['recent_exam']}/{profile['goal']}", "🎯"), unsafe_allow_html=True)
+        
+        with col3:
+            st.markdown(get_metric_card_html("Study Time Today", "-12%", "⚠️ Below average", "⏰"), unsafe_allow_html=True)
+
+# ===== ENHANCED: LEFT PANEL WITH PROACTIVE INSIGHTS =====
+def render_left_panel(state, category):
+    profile = state.profile
+    
+    # NEW: Show proactive AI insights at top
+    render_proactive_insights(profile, category)
+    
+    render_dashboard_summary(profile, category)
+    
+    st.markdown("---")
+    
+    # Existing visuals
+    if category == "Education":
+        render_education_visuals(profile)
+    elif category == "Finance":
+        render_finance_visuals(profile)
+    
+    st.markdown("---")
+    
+    # NEW: What-If Mode button
+    if category in ["Finance", "Education"]:
+        with st.expander("🔮 Try What-If Mode", expanded=False):
+            render_whatif_mode(profile, category)
+    
+    st.markdown("---")
+    
+    # Existing smart insights (kept for compatibility)
+    st.markdown("### 💡 Smart Insights")
+    insights = get_category_insights(category, profile)
+    for i, insight in enumerate(insights[:3]):
+        card_type = "warning" if "⚠️" in insight else "insight"
+        st.markdown(get_insight_html(insight, card_type), unsafe_allow_html=True)
+        if st.button(f"Ask about this", key=f"insight_{category}_{i}", use_container_width=True):
+            set_seed_chat(f"Tell me more about: {insight}")
+
+# ===== EXISTING: EDUCATION VISUALS =====
+def render_education_visuals(profile):
+    exam_data = analyze_exam_performance(profile)
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### 📈 Score Breakdown")
+        fig = create_animated_donut_chart(
+            list(exam_data["score_breakdown"].values()),
+            list(exam_data["score_breakdown"].keys()),
+            ['#bf6dbf', '#5f5fba', '#8b5cf6', '#a78bfa', '#c4b5fd']
+        )
+        st.plotly_chart(fig, use_container_width=True, key="main_score_chart")
+    
+    with col2:
+        st.markdown("#### 🎯 Goal Progress")
+        fig = create_gauge_chart(profile['recent_exam'], profile['goal'],
+                                f"{profile['recent_exam']}/{profile['goal']}")
+        st.plotly_chart(fig, use_container_width=True, key="main_goal_gauge")
+
+# ===== EXISTING: FINANCE VISUALS =====
+def render_finance_visuals(profile):
+    budget_data = calculate_budget_metrics(profile)
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### 💸 Spending Breakdown")
+        fig = create_animated_donut_chart(
+            list(budget_data["categories"].values()),
+            list(budget_data["categories"].keys()),
+            ['#10b981', '#f59e0b', '#ef4444']
+        )
+        st.plotly_chart(fig, use_container_width=True, key="main_spending_chart")
+    
+    with col2:
+        st.markdown("#### 🎯 Budget Status")
+        fig = create_gauge_chart(profile['spend'], profile['budget'],
+                                f"${profile['spend']}/${profile['budget']}")
+        st.plotly_chart(fig, use_container_width=True, key="main_budget_gauge")
+
+# ===== EXISTING: TOPIC EXTRACTION (unchanged) =====
+def extract_topics_from_history(chat_history):
+    """Extract ALL topics AND subtopics ever discussed"""
+    all_user_text = " ".join([m['content'].lower() for m in chat_history if m['role'] == 'user'])
+    topics_discussed = set()
+    
+    # Finance topics
+    if any(w in all_user_text for w in ['save', 'savings', 'emergency', 'automate']):
+        topics_discussed.add('savings')
+    if any(w in all_user_text for w in ['invest', 'etf', 'stock', 'crypto', 'bitcoin', 'trading', 'options']):
+        topics_discussed.add('investing')
+    if any(w in all_user_text for w in ['budget', 'spend', 'expense', 'cost', 'cut', '50/30/20']):
+        topics_discussed.add('budgeting')
+    if any(w in all_user_text for w in ['debt', 'loan', 'credit', 'repay']):
+        topics_discussed.add('debt')
+    
+    # Finance subtopics (deeper tracking)
+    if any(w in all_user_text for w in ['etf', 'exchange traded']):
+        topics_discussed.add('etf_basics')
+    if any(w in all_user_text for w in ['index fund', 'index', 'mutual fund']):
+        topics_discussed.add('index_funds')
+    if any(w in all_user_text for w in ['bitcoin', 'crypto', 'cryptocurrency']):
+        topics_discussed.add('crypto')
+    if any(w in all_user_text for w in ['best etf', 'which etf', 'etf for']):
+        topics_discussed.add('etf_selection')
+    if any(w in all_user_text for w in ['long-term', 'long term', 'strategy']):
+        topics_discussed.add('long_term')
+    if any(w in all_user_text for w in ['dividend', 'yield', 'income']):
+        topics_discussed.add('dividends')
+    if any(w in all_user_text for w in ['rebalance', 'allocation', 'portfolio']):
+        topics_discussed.add('portfolio')
+    
+    # Savings subtopics
+    if any(w in all_user_text for w in ['high-yield', 'high yield', 'best savings']):
+        topics_discussed.add('high_yield')
+    if any(w in all_user_text for w in ['automate', 'automatic', 'auto-save']):
+        topics_discussed.add('automate_savings')
+    if any(w in all_user_text for w in ['emergency fund', 'emergency']):
+        topics_discussed.add('emergency_fund')
+    
+    # Budgeting subtopics
+    if any(w in all_user_text for w in ['50/30/20', 'budget rule']):
+        topics_discussed.add('budget_rules')
+    if any(w in all_user_text for w in ['track spending', 'budget app']):
+        topics_discussed.add('tracking_tools')
+    if any(w in all_user_text for w in ['cut expenses', 'reduce spending']):
+        topics_discussed.add('cutting_expenses')
+    
+    # Education topics
+    if any(w in all_user_text for w in ['study', 'exam', 'test', 'score', 'improve', 'focus']):
+        topics_discussed.add('studying')
+    if any(w in all_user_text for w in ['practice', 'question', 'weak', 'subject']):
+        topics_discussed.add('practice')
+    
+    return topics_discussed
+
+def detect_current_topic(user_message_text):
+    """Detect which topic the user is asking about RIGHT NOW"""
+    text = user_message_text.lower()
+    
+    # Finance
+    if any(w in text for w in ['save', 'savings', 'automate', 'emergency fund']):
+        return 'savings'
+    if any(w in text for w in ['invest', 'etf', 'stock', 'bitcoin', 'crypto', 'options', 'trading']):
+        return 'investing'
+    if any(w in text for w in ['budget', 'spend', 'expense', '50/30/20', 'cut', 'stick', 'track']):
+        return 'budgeting'
+    if any(w in text for w in ['debt', 'loan', 'credit', 'repay']):
+        return 'debt'
+    
+    # Education
+    if any(w in text for w in ['study', 'focus', 'rush', 'manage time']):
+        return 'studying'
+    if any(w in text for w in ['exam', 'test', 'score', 'weak', 'improve']):
+        return 'exams'
+    if any(w in text for w in ['practice', 'question', 'quiz']):
+        return 'practice'
+    
+    return None
+
+# ===== EXISTING: FINANCE SUGGESTIONS (unchanged) =====
+def get_suggestions_for_finance(chat_history, current_topic, topics_discussed):
+    """FINANCE SUGGESTIONS - Progressive deepening"""
+    if current_topic == 'savings':
+        if 'savings' not in topics_discussed:
+            return [
+                ("📈 High-yield accounts?", "What are the best high-yield savings accounts for Gen Z?"),
+                ("🎯 Automate savings", "How can I automate my savings?"),
+                ("💡 Cut biggest expenses", "What are my biggest expenses to cut?")
+            ]
+        else:
+            return [
+                ("💳 Which account best for me?", "Which high-yield savings account would be best for my situation?"),
+                ("🔄 Emergency fund sizing", "How much should I keep in an emergency fund?"),
+                ("📊 Track savings progress", "How do I track and measure my automated savings?")
+            ]
+    
+    elif current_topic == 'investing':
+        # Level 1: Complete beginner
+        if 'investing' not in topics_discussed:
+            return [
+                ("📊 Start investing small", "How do I start investing with little money?"),
+                ("🔍 ETFs vs stocks", "Should I invest in ETFs or individual stocks?"),
+                ("📈 Best beginner ETFs", "What are beginner-friendly investment tips for Gen Z?")
+            ]
+        # Level 2: Asked about ETFs/basics, now go deeper
+        elif 'etf_selection' not in topics_discussed and 'index_funds' not in topics_discussed:
+            return [
+                ("💎 Best ETFs for my age", "What are the best ETFs for my age and budget?"),
+                ("📈 Index funds?", "What's the difference between ETFs and index funds?"),
+                ("🔐 Safe investments", "What are the safest investment options for beginners?")
+            ]
+        # Level 3: Asked about specific ETFs/index funds, now strategy
+        elif 'long_term' not in topics_discussed and 'portfolio' not in topics_discussed:
+            return [
+                ("⏰ Long-term strategy", "What's a good long-term investment strategy?"),
+                ("📊 Portfolio allocation", "How should I allocate my investment portfolio?"),
+                ("💰 Dividend investing", "Should I focus on dividend-paying investments?")
+            ]
+        # Level 4: Advanced investor questions
+        else:
+            return [
+                ("🔄 Rebalancing", "When and how should I rebalance my portfolio?"),
+                ("🌍 International ETFs", "Should I invest in international ETFs?"),
+                ("📈 Growth vs value", "What's the difference between growth and value investing?")
+            ]
+    
+    elif current_topic == 'budgeting':
+        if 'budgeting' not in topics_discussed:
+            return [
+                ("✂️ Cut expenses smartly", "Where can I cut expenses without sacrificing quality?"),
+                ("📊 Track spending", "Best way to track my spending automatically?"),
+                ("🎯 Create monthly budget", "Help me create a realistic monthly budget")
+            ]
+        else:
+            return [
+                ("50/30/20 rule?", "Should I use the 50/30/20 budgeting rule?"),
+                ("💳 Best budget app", "What budget tracking app should I use?"),
+                ("🎯 Stick to budget", "How do I actually stick to my budget?")
+            ]
+    
+    elif current_topic == 'debt':
+        if 'debt' not in topics_discussed:
+            return [
+                ("💳 Pay off faster", "Best strategy to pay off debt faster?"),
+                ("🔍 Debt vs savings", "Should I focus on debt or savings first?"),
+                ("📉 Lower interest", "How to reduce credit card interest rates?")
+            ]
+        else:
+            return [
+                ("📊 Snowball vs avalanche", "Is snowball or avalanche better for me?"),
+                ("⏰ Payoff timeline", "How long would it take to pay off my debt?"),
+                ("🆘 Negotiate rates", "Can I negotiate lower interest rates?")
+            ]
+    
+    else:
+        return [
+            ("💰 Save more?", "How can I save more money this month?"),
+            ("📊 Break down spending", "Break down my spending and show where to cut costs"),
+            ("📈 Investment tips", "What are beginner-friendly investment tips for Gen Z?")
+        ]
+
+# ===== EXISTING: EDUCATION SUGGESTIONS (unchanged) =====
+def get_suggestions_for_education(chat_history, current_topic, topics_discussed):
+    """EDUCATION SUGGESTIONS - Progressive deepening"""
+    if current_topic == 'studying':
+        if 'studying' not in topics_discussed:
+            return [
+                ("⏰ Study schedule", "Help me create an effective study schedule"),
+                ("🎯 Stay focused", "Best techniques to stay focused while studying?"),
+                ("📝 Take notes better", "What's the most effective way to take notes?")
+            ]
+        else:
+            return [
+                ("🚀 Pomodoro technique", "How does the Pomodoro technique work for studying?"),
+                ("📍 Study environment", "How do I create a good study environment?"),
+                ("⚡ Study groups", "How can I make study groups effective?")
+            ]
+    
+    elif current_topic == 'exams':
+        if 'exams' not in topics_discussed:
+            return [
+                ("📊 Boost scores fast", "What's the fastest way to improve exam scores?"),
+                ("✏️ Test strategies", "Give me strategies for better test performance"),
+                ("🎯 Fix weak subjects", "How do I tackle my weakest subjects?")
+            ]
+        else:
+            return [
+                ("🧠 Active recall", "How does active recall help with exam prep?"),
+                ("📅 Study calendar", "How should I plan my study calendar for exams?"),
+                ("😰 Test anxiety", "How do I handle test anxiety?")
+            ]
+    
+    elif current_topic == 'practice':
+        if 'practice' not in topics_discussed:
+            return [
+                ("✏️ Practice questions", "Give me practice questions for my weakest subject"),
+                ("🎯 Target weak areas", "How do I focus practice on weak areas?"),
+                ("📊 Quiz myself", "What's the best way to quiz myself?")
+            ]
+        else:
+            return [
+                ("🔄 Spaced repetition", "How does spaced repetition work?"),
+                ("📈 Track progress", "How do I measure improvement from practice?"),
+                ("💡 Learn from mistakes", "How should I analyze my practice mistakes?")
+            ]
+    
+    else:
+        return [
+            ("📚 Analyze exam", "Analyze my last exam and tell me where to improve"),
+            ("✏️ Practice questions", "Give me practice questions for my weakest subject"),
+            ("🎯 Improve scores", "What's the fastest way to improve my exam scores?")
+        ]
+
+# ===== EXISTING: DYNAMIC SUGGESTIONS (unchanged) =====
+def get_dynamic_suggestions_v4(chat_history, category):
+    """PRODUCTION VERSION - Never recycles suggestions"""
+    if len(chat_history) <= 1:
+        if category == "Finance":
+            return [
+                ("💰 Save more?", "How can I save more money this month?"),
+                ("📊 Break down spending", "Break down my spending and show where to cut costs"),
+                ("📈 Investment tips", "What are beginner-friendly investment tips for Gen Z?")
+            ]
+        elif category == "Education":
+            return [
+                ("📚 Analyze exam", "Analyze my last exam and tell me where to improve"),
+                ("✏️ Practice questions", "Give me practice questions for my weakest subject"),
+                ("🎯 Improve scores", "What's the fastest way to improve my exam scores?")
+            ]
+    
+    topics_discussed = extract_topics_from_history(chat_history)
+    
+    latest_user_msg = ""
+    for msg in reversed(chat_history):
+        if msg['role'] == 'user':
+            latest_user_msg = msg['content']
+            break
+    
+    current_topic = detect_current_topic(latest_user_msg)
+    
+    if category == "Finance":
+        return get_suggestions_for_finance(chat_history, current_topic, topics_discussed)
+    elif category == "Education":
+        return get_suggestions_for_education(chat_history, current_topic, topics_discussed)
+    
+    return [("💭 Ask something", "What's on your mind?")]
+
+# ===== EXISTING: CHAT PANEL (unchanged) =====
+def render_chat_panel(chat_history_key, category):
+    """Chat panel with PRODUCTION-READY suggestion engine"""
+    icon_map = {"Finance": "💰", "Education": "📚", "Family": "👨👩👧", "Friends": "👥", "Weekend/Vacation": "🏖"}
+    category_icon = icon_map.get(category, "🎯")
+    
+    col1, col2 = st.columns([4, 1])
+    with col1:
+        st.markdown(f"### 💬 Chat with Aqua about {category_icon} {category}")
+    with col2:
+        if st.button("🔄 Reset", key=f"reset_chat_{category}", use_container_width=True, type="secondary"):
+            st.session_state[chat_history_key] = []
+            st.rerun()
+    
+    if not st.session_state[chat_history_key]:
+        welcome_msg = f"Hey! 👋 I'm Aqua, your {category.lower()} mentor. What's on your mind?"
+        st.session_state[chat_history_key].append({"role": "assistant", "content": welcome_msg})
+    
+    # Display all messages
+    for msg in st.session_state[chat_history_key]:
+        with st.chat_message(msg["role"], avatar="🌊" if msg["role"] == "assistant" else "👤"):
+            st.markdown(msg["content"])
+    
+    st.markdown("---")
+    st.markdown("### ⚡ Quick Actions")
+    
+    suggestions = get_dynamic_suggestions_v4(st.session_state[chat_history_key], category)
+    
+    if suggestions:
+        cols = st.columns(min(len(suggestions), 3))
+        for i, (display_text, full_prompt) in enumerate(suggestions):
+            col_idx = i % len(cols)
+            button_key = f"quick_{category}_{i}_{len(st.session_state[chat_history_key])}_prod"
+            if cols[col_idx].button(display_text, key=button_key, use_container_width=True):
+                set_seed_chat(full_prompt)

data.py

@@ -0,0 +1,23 @@
+# Provide core cards, viz categories, and mock data utilities
+
+CATEGORIES = [
+    "Finance", "Education", "Family", "Friends", "Weekend/Vacation"
+]
+
+def get_dashboard_cards(profile):
+    # Simulate dashboard cards data for given profile (expand as needed)
+    return [
+        {"title": "This Month's Budget", "progress": profile["spend"]/profile["budget"], "details": f"{profile['spend']}/{profile['budget']}"},
+        {"title": "12% less study time today", "details": "Stay focused! Important milestone for PM program."},
+        {"title": "My Goals For Today", "goals": profile["goals_today"]},
+        {"title": "Today's Tip", "details": "Registering for Selective Service may get you aid."},
+        {"title": "Savings Goal", "progress": 0.68, "details": "+$300 from last month"},
+    ]
+
+def get_category_data(category, profile):
+    # Simulate breakdowns for each category, return chart data
+    if category == "Finance":
+        return {"labels": ["Savings", "Food", "Leisure"], "values": [1000, 400, 176]}
+    elif category == "Education":
+        return {"labels": list(profile["last_scores"].keys()), "values": list(profile["last_scores"].values())}
+    return {"labels": [], "values": []}

llm_agent.py

@@ -0,0 +1,377 @@
+"""
+llm_agent.py
+
+FIXED VERSION:
+1. Mistral 7B for Finance (NOT specialized finance model - good for conversations)
+2. Phi-2 2.7B for Education (better than specialized - data quality > size)
+3. 7B max per model (no huge models that fail)
+4. Groq fallback with ONLY available models (mixtral deprecated, using llama)
+5. No falling back immediately - models are ACTUALLY available
+ENHANCEMENTS:
+1. Scenario-aware prompts for what-if queries
+2. Proactive insights integration
+3. Better formatting for comparisons
+4. Unchanged: Multi-LLM strategy (HF + Groq)
+5. Unchanged: All existing analytics integration
+"""
+
+from groq import Groq
+from analytics import (
+    analyze_exam_performance,
+    calculate_budget_metrics,
+    get_time_improvement_suggestions,
+    generate_practice_questions,
+    calculate_projected_improvement,
+    parse_budget_query,
+    apply_scenario_changes,
+    compare_scenarios,
+    generate_proactive_insights
+)
+import json
+import os
+from huggingface_hub import InferenceClient
+
+# HF Models - All 7B or smaller
+HF_MODELS = {
+    "Finance": "mistralai/Mistral-7B-Instruct-v0.1",  
+    "Education": "microsoft/phi-2",
+    "Family": "HuggingFaceH4/zephyr-7b-beta",
+    "Friends": "HuggingFaceH4/zephyr-7b-beta",
+    "Weekend/Vacation": "HuggingFaceH4/zephyr-7b-beta"
+}
+
+# Groq models - Available models only
+GROQ_MODELS = {
+    "Finance": "llama-3.1-8b-instant",
+    "Education": "llama-3.3-70b-versatile",
+    "Family": "llama-3.1-8b-instant",
+    "Friends": "llama-3.1-8b-instant",
+    "Weekend/Vacation": "llama-3.1-8b-instant"
+}
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "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")
+HF_API_KEY = os.getenv("HF_API_KEY", "hf_kuaUsin8tkP44NrlwmsUWGdyb3FYb8ziZyHAU4")
+
+GENZ_PERSONA = r"""You are Aqua, a GenZ AI mentor who's like that super helpful older friend who's been through it all.
+
+PERSONALITY TRAITS:
+- Warm, friendly, and supportive (but not fake or overly enthusiastic)
+- Direct and honest (no sugarcoating, but always constructive)
+- Uses casual language naturally (occasional "fr", "ngl", "lowkey" - but don't overdo it)
+- Encouraging but realistic about challenges
+- Uses emojis purposefully (1-2 per response max)
+- Breaks down complex stuff into digestible chunks
+
+COMMUNICATION STYLE:
+- Keep responses concise (2-4 sentences for simple questions, more for complex ones)
+- Lead with the most actionable insight
+- Use bullet points for steps or lists (but format naturally)
+- Reference specific data from the user's profile when relevant
+- Ask follow-up questions when you need more context
+- Celebrate wins genuinely
+
+CRITICAL: CURRENCY FORMATTING
+- NEVER use bare dollar signs like $750
+- ALWAYS write currency as: "750 dollars" or "USD 750"
+- Example: "You've spent 750 dollars out of 2000 dollars"
+
+WHAT TO AVOID:
+- Being overly formal or corporate
+- Using too many emojis or exclamation marks
+- Giving vague advice like "try your best"
+- Long walls of text without structure
+- Ignoring the user's actual situation/data
+
+YOUR GOAL:
+Help this GenZ user make smart decisions about their life, finances, and education. Be the mentor they wish they had."""
+
+
+def get_system_prompt(profile, category, tool_results="", scenario_data=None):
+    """Enhanced system prompt with scenario awareness"""
+    exam_status = f"Recent exam: {profile['recent_exam']}/{profile['goal']}"
+    budget_status = f"Spending: {profile['spend']} dollars/{profile['budget']} dollars"
+    
+    weak_areas = []
+    if profile.get('math_weakness'):
+        weak_areas.append("math")
+    if profile.get('rushing'):
+        weak_areas.append("time management")
+    
+    # Add scenario context if present
+    scenario_context = ""
+    if scenario_data:
+        scenario_context = f"""
+SCENARIO ANALYSIS:
+The user is asking a 'what-if' question. Here's the comparison:
+
+Current Situation:
+- Budget: {profile['budget']} dollars
+- Spent: {profile['spend']} dollars
+- Remaining: {profile['budget'] - profile['spend']} dollars
+
+Scenario Result:
+- Budget: {scenario_data['scenario']['budget']} dollars
+- Spent: {scenario_data['scenario']['spent']} dollars
+- Remaining: {scenario_data['scenario']['remaining']} dollars
+
+Key Differences:
+{chr(10).join(f"• {insight}" for insight in scenario_data['insights'])}
+
+IMPORTANT: Frame your response around this comparison. Be specific about the trade-offs.
+"""
+    
+    context = f"""
+{GENZ_PERSONA}
+
+CURRENT USER CONTEXT:
+Name: {profile.get('name', 'User')}
+Category Focus: {category}
+{exam_status if category == 'Education' else ''}
+{budget_status if category == 'Finance' else ''}
+{'Areas needing work: ' + ', '.join(weak_areas) if weak_areas else ''}
+Today's goals progress: {profile.get('goals_today', {})}
+
+{scenario_context}
+
+{tool_results}
+
+IMPORTANT:
+1. Reference specific numbers and data from the user's profile in your responses.
+2. ALWAYS format currency as "X dollars" or "USD X" - NEVER use bare dollar signs like $X
+3. If this is a scenario/what-if question, focus on the comparison and trade-offs.
+"""
+    
+    return context
+
+
+def should_use_analytics(query, category):
+    """Detect if analytics tools are needed"""
+    analysis_keywords = [
+        "analyze", "analysis", "break down", "breakdown", "how am i doing",
+        "performance", "progress", "score", "exam", "test", "spending",
+        "budget", "where", "what", "show me", "tell me about", "compare",
+        "what if", "if i", "suppose", "imagine"
+    ]
+    
+    return any(keyword in query.lower() for keyword in analysis_keywords)
+
+
+def get_tool_results(query, profile, category, scenario_profile=None):
+    """Get analytics results, with scenario comparison if applicable"""
+    results = ""
+    
+    # Check if this is a scenario query
+    if scenario_profile:
+        comparison = compare_scenarios(profile, scenario_profile)
+        
+        results += "\n\n📊 SCENARIO COMPARISON ANALYSIS\n\n"
+        results += "Current vs Scenario:\n"
+        results += f"• Spending: {profile['spend']} dollars → {scenario_profile['spend']} dollars\n"
+        results += f"• Change: {comparison['differences']['spend']:+.0f} dollars\n"
+        results += f"• Remaining: {comparison['current']['remaining']} dollars → {comparison['scenario']['remaining']} dollars\n"
+        results += f"• Change: {comparison['differences']['remaining']:+.0f} dollars\n\n"
+        
+        results += "Key Insights:\n"
+        for insight in comparison['insights']:
+            results += f"• {insight}\n"
+        results += "\n"
+        
+        return results
+    
+    # Regular analytics (existing code)
+    if category == "Education" and should_use_analytics(query, category):
+        exam_data = analyze_exam_performance(profile)
+        results += f"\n\n📚 EDUCATION ANALYSIS\n\n"
+        results += f"Total Score: {exam_data['total_score']}/{exam_data['goal_score']}\n"
+        results += f"Progress: {exam_data['progress_pct']}%\n"
+        results += f"Points Needed: {exam_data['points_needed']}\n"
+        results += f"Weakest Subject: {exam_data['weakest_subject']} ({exam_data['score_breakdown'][exam_data['weakest_subject']]} points)\n"
+        results += f"Strongest Subject: {exam_data['strongest_subject']} ({exam_data['score_breakdown'][exam_data['strongest_subject']]} points)\n"
+        results += f"\nScore Breakdown:\n"
+        for subject, score in exam_data['score_breakdown'].items():
+            results += f" - {subject}: {score} ({exam_data['score_percentages'][subject]}%)\n"
+        results += f"\nKey Insights:\n"
+        for insight in exam_data['insights']:
+            results += f" • {insight}\n"
+        results += f"\n"
+        
+        if any(word in query.lower() for word in ['improve', 'better', 'increase', 'boost']):
+            suggestions = get_time_improvement_suggestions(profile)
+            results += f"\n\n💡 IMPROVEMENT SUGGESTIONS\n\n"
+            for suggestion in suggestions:
+                results += f" • {suggestion}\n"
+            results += f"\n"
+        
+        if any(word in query.lower() for word in ['practice', 'questions', 'quiz', 'drill']):
+            practice_qs = generate_practice_questions(exam_data['weakest_subject'])
+            results += f"\n\n📝 PRACTICE QUESTIONS\n\n"
+            for i, q in enumerate(practice_qs[:3], 1):
+                results += f" {i}. {q}\n"
+            results += f"\n"
+    
+    elif category == "Finance" and should_use_analytics(query, category):
+        budget_data = calculate_budget_metrics(profile)
+        results += f"\n\n💰 FINANCE ANALYSIS\n\n"
+        results += f"Budget: {budget_data['budget']} dollars\n"
+        results += f"Spent: {budget_data['spent']} dollars ({budget_data['spend_percentage']}%)\n"
+        results += f"Remaining: {budget_data['remaining']} dollars\n"
+        results += f"Status: {'✅ On track' if budget_data['on_track'] else '⚠️ Over target'}\n"
+        results += f"\nSpending Breakdown:\n"
+        for cat_name, amount in budget_data['categories'].items():
+            pct = round((amount / budget_data['budget']) * 100, 1)
+            results += f" - {cat_name}: {amount} dollars ({pct}%)\n"
+        if budget_data['potential_savings']:
+            results += f"\nPotential Savings:\n"
+            for saving in budget_data['potential_savings']:
+                results += f" • {saving}\n"
+        results += f"\n"
+    
+    return results
+
+
+def aqua_response_hf(query, profile, category, scenario_profile=None):
+    """Try Hugging Face inference first"""
+    
+    try:
+        hf_client = InferenceClient(api_key=HF_API_KEY)
+        
+        model_name = HF_MODELS.get(category, "mistralai/Mistral-7B-Instruct-v0.1")
+        tool_results = get_tool_results(query, profile, category, scenario_profile)
+        
+        # Build scenario data if present
+        scenario_data = None
+        if scenario_profile:
+            scenario_data = compare_scenarios(profile, scenario_profile)
+        
+        system_message = get_system_prompt(profile, category, tool_results, scenario_data)
+        
+        full_prompt = f"{system_message}\n\nUser Query: {query}"
+        
+        response = hf_client.text_generation(
+            model=model_name,
+            prompt=full_prompt,
+            max_new_tokens=350,
+            temperature=0.75,
+            top_p=0.9
+        )
+        
+        return response.strip()
+    
+    except Exception as e:
+        print(f"HF Error: {str(e)[:100]}")
+        return None
+
+
+def aqua_response_groq(query, profile, category, scenario_profile=None):
+    """Fallback to Groq with available models only"""
+    
+    if not GROQ_API_KEY or GROQ_API_KEY == "gsk_xxx":
+        return "⚠️ Groq API Key Missing! Add it to your environment."
+    
+    client = Groq(api_key=GROQ_API_KEY)
+    
+    tool_results = get_tool_results(query, profile, category, scenario_profile)
+    
+    # Build scenario data if present
+    scenario_data = None
+    if scenario_profile:
+        scenario_data = compare_scenarios(profile, scenario_profile)
+    
+    system_message = get_system_prompt(profile, category, tool_results, scenario_data)
+    
+    model = GROQ_MODELS.get(category, "llama-3.3-70b-versatile")
+    
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": query}
+    ]
+    
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=messages,
+            model=model,
+            temperature=0.75,
+            max_tokens=350,
+            top_p=0.9,
+            stop=None
+        )
+        
+        response_content = chat_completion.choices[0].message.content
+        response_content = response_content.replace('$', '\\$')
+        return response_content.strip()
+    
+    except Exception as e:
+        error_msg = str(e)[:100]
+        print(f"Groq Error: {error_msg}")
+        return f"😬 Something went wrong: {error_msg}... Try again?"
+
+
+def aqua_response(query, profile, category, scenario_profile=None):
+    """
+    Main response function with scenario awareness:
+    1. Try HF models first (area-specific, <= 7B)
+    2. Fallback to Groq (area-specific, available models)
+    3. Return error if both fail
+    
+    NEW: Accepts optional scenario_profile for what-if queries
+    """
+    
+    # Try HF first
+    print(f"[DEBUG] Using HF model for {category}: {HF_MODELS.get(category)}")
+    hf_response = aqua_response_hf(query, profile, category, scenario_profile)
+    
+    if hf_response:
+        return hf_response
+    
+    # If HF fails, use Groq with same focus-area model
+    print(f"[DEBUG] HF failed, falling back to Groq: {GROQ_MODELS.get(category)}")
+    groq_response = aqua_response_groq(query, profile, category, scenario_profile)
+    
+    return groq_response
+
+
+def get_contextual_welcome_message(category, profile):
+    """Generate proactive welcome with insights"""
+    # Get proactive insights
+    insights = generate_proactive_insights(profile, category)
+    
+    base_messages = {
+        "Finance": f"Hey! 💰 I see you're at {profile['spend']} dollars/{profile['budget']} dollars this month.",
+        "Education": f"Hey! 📚 Last score was {profile['recent_exam']} - you need {profile['goal'] - profile['recent_exam']} more points to hit your goal.",
+        "Family": f"Hey! 👨👩👧 Family stuff can be tricky to balance. I'm here to help you stay connected while crushing your own goals.",
+        "Friends": f"Hey! 👥 Balancing friends and responsibilities is an art. Let's figure out how to stay social without breaking the bank.",
+        "Weekend/Vacation": f"Hey! 🏖️ Everyone needs a break. Let's plan something fun that won't wreck your budget."
+    }
+    
+    base = base_messages.get(category, "Hey! 👋 I'm Aqua, your personal mentor. What's on your mind?")
+    
+    # Add top insight if critical
+    if insights and insights[0].get('type') == 'critical':
+        base += f" {insights[0]['icon']} {insights[0]['text']}"
+    
+    return base
+
+
+def get_default_profile():
+    return {
+        "name": "Suzy",
+        "recent_exam": 1200,
+        "goal": 1600,
+        "math_weakness": True,
+        "rushing": True,
+        "budget": 2000,
+        "spend": 1576,
+        "goals_today": {
+            "Calories": 85,
+            "Money": 75,
+            "Steps": 54
+        },
+        "last_scores": {
+            "Reading": 240,
+            "Writing": 220,
+            "Reasoning": 140,
+            "Algebra": 100,
+            "Geometry": 100
+        },
+    }
+

profile_editor.py

@@ -0,0 +1,309 @@
+"""
+profile_editor.py
+Profile editing component for Aqua Thistle
+Allows users to update their profile data in real-time
+"""
+
+import streamlit as st
+
+def render_profile_editor(profile, category):
+    """
+    Render category-specific profile editor
+    Allows users to update their data in real-time
+    """
+    with st.expander("✏️ Edit Your Profile", expanded=False):
+        st.markdown("Update your info below - changes apply instantly")
+        
+        # Finance fields
+        if category == "Finance":
+            st.markdown("##### 💰 Financial Data")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                new_budget = st.number_input(
+                    "Monthly Budget ($)",
+                    min_value=500,
+                    max_value=10000,
+                    value=profile['budget'],
+                    step=100,
+                    key="edit_budget",
+                    help="Your total monthly budget"
+                )
+                if new_budget != profile['budget']:
+                    profile['budget'] = new_budget
+            
+            with col2:
+                new_spend = st.number_input(
+                    "Current Spending ($)",
+                    min_value=0,
+                    max_value=20000,  # High ceiling to allow any value
+                    value=profile['spend'],
+                    step=50,
+                    key="edit_spend",
+                    help="How much you've spent this month"
+                )
+                if new_spend != profile['spend']:
+                    profile['spend'] = new_spend
+            
+            # Warning if over budget
+            if profile['spend'] > profile['budget']:
+                over_amount = profile['spend'] - profile['budget']
+                st.warning(f"⚠️ You're ${over_amount} over budget! Consider adjusting your spending or budget.")
+        
+        # Education fields
+        elif category == "Education":
+            st.markdown("##### 📚 Academic Data")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                new_exam_score = st.number_input(
+                    "Recent Exam Score",
+                    min_value=400,
+                    max_value=1600,
+                    value=profile['recent_exam'],
+                    step=10,
+                    key="edit_exam",
+                    help="Your most recent test score"
+                )
+                if new_exam_score != profile['recent_exam']:
+                    profile['recent_exam'] = new_exam_score
+            
+            with col2:
+                new_goal = st.number_input(
+                    "Target Score",
+                    min_value=400,
+                    max_value=1600,
+                    value=profile['goal'],
+                    step=50,
+                    key="edit_goal",
+                    help="Your goal score"
+                )
+                if new_goal != profile['goal']:
+                    profile['goal'] = new_goal
+            
+            st.markdown("##### 📊 Subject Scores")
+            cols = st.columns(5)
+            
+            subjects = ["Reading", "Writing", "Reasoning", "Algebra", "Geometry"]
+            for i, subject in enumerate(subjects):
+                with cols[i]:
+                    new_score = st.number_input(
+                        subject,
+                        min_value=0,
+                        max_value=400,
+                        value=profile['last_scores'].get(subject, 100),
+                        step=10,
+                        key=f"edit_score_{subject}",
+                        help=f"{subject} score"
+                    )
+                    if new_score != profile['last_scores'].get(subject, 100):
+                        profile['last_scores'][subject] = new_score
+            
+            # Checkboxes for weaknesses
+            st.markdown("##### ⚠️ Areas Needing Work")
+            col1, col2 = st.columns(2)
+            with col1:
+                math_weak = st.checkbox(
+                    "Math weakness",
+                    value=profile.get('math_weakness', False),
+                    key="edit_math_weak"
+                )
+                profile['math_weakness'] = math_weak
+            
+            with col2:
+                rushing = st.checkbox(
+                    "Rushing on tests",
+                    value=profile.get('rushing', False),
+                    key="edit_rushing"
+                )
+                profile['rushing'] = rushing
+            
+            # Feedback
+            if profile['recent_exam'] >= profile['goal']:
+                st.success(f"🎉 You've reached your goal! Consider setting a higher target.")
+            
+            # Show sum of subject scores for reference
+            subject_total = sum(profile['last_scores'].values())
+            if abs(subject_total - profile['recent_exam']) > 50:
+                st.info(f"ℹ️ Subject scores total: {subject_total} (Recent exam: {profile['recent_exam']})")
+        
+        # Family fields
+        elif category == "Family":
+            st.markdown("##### 👨‍👩‍👧 Family Tracking")
+            col1, col2 = st.columns(2)
+            
+            # Initialize family metrics if not present
+            if 'family_checkins' not in profile:
+                profile['family_checkins'] = 2
+            if 'family_checkins_goal' not in profile:
+                profile['family_checkins_goal'] = 3
+            if 'last_contact_days' not in profile:
+                profile['last_contact_days'] = 3
+            if 'family_time_hours' not in profile:
+                profile['family_time_hours'] = 4.5
+            
+            with col1:
+                checkin_goal = st.number_input(
+                    "Weekly Check-ins Goal",
+                    min_value=1,
+                    max_value=10,
+                    value=profile['family_checkins_goal'],
+                    step=1,
+                    key="edit_checkin_goal"
+                )
+                profile['family_checkins_goal'] = checkin_goal
+                
+                checkins = st.number_input(
+                    "Weekly Check-ins Completed",
+                    min_value=0,
+                    max_value=20,  # High ceiling to allow exceeding goal
+                    value=profile['family_checkins'],
+                    step=1,
+                    key="edit_checkins"
+                )
+                profile['family_checkins'] = checkins
+            
+            with col2:
+                last_contact = st.number_input(
+                    "Days Since Last Contact",
+                    min_value=0,
+                    max_value=365,
+                    value=profile['last_contact_days'],
+                    step=1,
+                    key="edit_last_contact"
+                )
+                profile['last_contact_days'] = last_contact
+                
+                family_time = st.number_input(
+                    "Family Time (hrs/week)",
+                    min_value=0.0,
+                    max_value=40.0,
+                    value=profile['family_time_hours'],
+                    step=0.5,
+                    key="edit_family_time"
+                )
+                profile['family_time_hours'] = family_time
+            
+            # Positive feedback if over goal
+            if profile['family_checkins'] > profile['family_checkins_goal']:
+                extra = profile['family_checkins'] - profile['family_checkins_goal']
+                st.success(f"🎉 You did {extra} extra check-in(s) this week!")
+        
+        # Friends fields
+        elif category == "Friends":
+            st.markdown("##### 👥 Social Tracking")
+            
+            if 'social_budget' not in profile:
+                profile['social_budget'] = 150
+            if 'social_spent' not in profile:
+                profile['social_spent'] = 75
+            if 'hangouts_count' not in profile:
+                profile['hangouts_count'] = 4
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                social_budget = st.number_input(
+                    "Social Budget ($)",
+                    min_value=0,
+                    max_value=1000,
+                    value=profile['social_budget'],
+                    step=10,
+                    key="edit_social_budget"
+                )
+                profile['social_budget'] = social_budget
+                
+                social_spent = st.number_input(
+                    "Social Spending ($)",
+                    min_value=0,
+                    max_value=5000,  # High ceiling
+                    value=profile['social_spent'],
+                    step=5,
+                    key="edit_social_spent"
+                )
+                profile['social_spent'] = social_spent
+            
+            with col2:
+                hangouts = st.number_input(
+                    "Hangouts This Month",
+                    min_value=0,
+                    max_value=30,
+                    value=profile['hangouts_count'],
+                    step=1,
+                    key="edit_hangouts"
+                )
+                profile['hangouts_count'] = hangouts
+            
+            # Warning if over social budget
+            if profile['social_spent'] > profile['social_budget']:
+                over_amount = profile['social_spent'] - profile['social_budget']
+                st.warning(f"⚠️ You're ${over_amount} over your social budget!")
+        
+        # Weekend/Vacation fields
+        elif category == "Weekend/Vacation":
+            st.markdown("##### ✈️ Vacation Planning")
+            
+            if 'vacation_fund' not in profile:
+                profile['vacation_fund'] = 450
+            if 'vacation_goal' not in profile:
+                profile['vacation_goal'] = 1000
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                vac_fund = st.number_input(
+                    "Vacation Fund ($)",
+                    min_value=0,
+                    max_value=5000,
+                    value=profile['vacation_fund'],
+                    step=50,
+                    key="edit_vac_fund"
+                )
+                profile['vacation_fund'] = vac_fund
+            
+            with col2:
+                vac_goal = st.number_input(
+                    "Vacation Goal ($)",
+                    min_value=500,
+                    max_value=10000,
+                    value=profile['vacation_goal'],
+                    step=100,
+                    key="edit_vac_goal"
+                )
+                profile['vacation_goal'] = vac_goal
+        
+        # Global daily goals (shown in all categories)
+        st.markdown("---")
+        st.markdown("##### 🎯 Today's Goals Progress (%)")
+        cols = st.columns(3)
+        
+        goal_types = ["Calories", "Money", "Steps"]
+        for i, goal_type in enumerate(goal_types):
+            with cols[i]:
+                new_progress = st.slider(
+                    goal_type,
+                    0, 100,
+                    profile['goals_today'].get(goal_type, 50),
+                    5,
+                    key=f"edit_goal_{goal_type}"
+                )
+                profile['goals_today'][goal_type] = new_progress
+        
+        # Contextual success message
+        has_warnings = False
+        if category == "Finance" and profile['spend'] > profile['budget']:
+            has_warnings = True
+        if category == "Friends" and profile['social_spent'] > profile['social_budget']:
+            has_warnings = True
+        
+        if has_warnings:
+            st.info("💡 Changes saved! Check warnings above.")
+        else:
+            st.success("✅ All changes saved - looking good!")
+        
+        # Reset button
+        if st.button("🔄 Reset to Defaults", type="secondary", use_container_width=True):
+            # Reset to default profile
+            from llm_agent import get_default_profile
+            default = get_default_profile()
+            for key, value in default.items():
+                profile[key] = value
+            st.rerun()

styles.py

@@ -0,0 +1,214 @@
+"""
+styles.py - UPDATED
+Clean black/white design with Thistle/Aqua accents for the name AQUA THISTLE
+Improved chat container styling
+UPDATED WITH CSS GAP FIX:
+- Reduces .st-emotion-cache-wfksow gap (spacing between chart/buttons)
+- Cleans up Quick Actions section layout
+- Removes excess spacing
+NEW FEATURES:
+1. Proactive AI insights display (auto-generated at top)
+2. Scenario comparison mode (side-by-side current vs scenario)
+3. What-if mode (interactive sliders for testing)
+4. Query detection for chart updates
+5. All existing features preserved
+
+PRESERVED FEATURES:
+- Dynamic suggestions (never recycle)
+- Topic tracking across conversation
+- Category-specific visuals
+- Profile editing integration
+- All existing chart types
+"""
+
+def get_custom_css():
+    """Modern black/white with purple/blue accents + gap fixes"""
+    return """
+    <style>
+    /* Better: Use CSS attribute selector to target flex containers */
+   /* UNIVERSAL: Target ANY div with gap: 1rem (regardless of class name) */
+    div[style*="gap: 1rem"],
+    [class*="st-emotion-cache"][style*="gap"],
+    [class*="st-emotion"][style*="flex"] {
+        gap: 0.5rem !important;
+    }
+    
+    /* Better: Use CSS attribute selector to target flex containers */
+    [style*="display: flex"][style*="gap: 1rem"] {
+        gap: 0.5rem !important;
+    }
+    
+    /* Best: Override Streamlit's default container gaps */
+    [class*="st-emotion-cache"] {
+        gap: 0.5rem !important;
+    }
+    
+    /* Override inline styles for flex containers */
+    [style*="display: flex"] {
+        gap: 0.5rem !important;
+    }
+    
+    /* Reduce column container gaps */
+    [class*="column"] {
+        gap: 0.5rem !important;
+    }
+    
+    /* Button styling */
+    button {
+        font-size: 0.9rem;
+        padding: 0.5rem 1rem;
+        border-radius: 0.5rem;
+        border: 1px solid #e5e7eb;
+        background-color: #f9fafb;
+        color: #1f2937;
+        font-weight: 500;
+        transition: all 0.2s ease;
+    }
+    
+    button:hover {
+        background-color: #f3f4f6;
+        border-color: #d1d5db;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    
+    button:active {
+        background-color: #e5e7eb;
+    }
+    
+    /* Chat messages */
+    .stChatMessage {
+        padding: 1rem;
+        margin-bottom: 0.5rem;
+    }
+    
+    /* Divider spacing */
+    hr {
+        margin-top: 1rem;
+        margin-bottom: 1rem;
+    }
+    
+    /* Metric cards */
+    .metric-card {
+        border-radius: 0.75rem;
+        padding: 1.5rem;
+        background-color: #f9fafb;
+        border: 1px solid #e5e7eb;
+        margin-bottom: 0.5rem;
+    }
+    
+    /* Insight cards */
+    .insight-card {
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin-bottom: 0.5rem;
+        border-left: 4px solid #bf6dbf;
+        background-color: #faf9fc;
+    }
+    
+    .insight-card.warning {
+        border-left-color: #ef4444;
+        background-color: #fef2f2;
+    }
+    
+    /* Dashboard title */
+    h3 {
+        color: #1f2937;
+        font-weight: 600;
+        margin-bottom: 1rem;
+    }
+    
+    /* Main heading */
+    h1, h2 {
+        color: #0f172a;
+        font-weight: 700;
+    }
+    
+    /* Text styling */
+    p, span {
+        color: #4b5563;
+        line-height: 1.6;
+    }
+    
+    /* Links */
+    a {
+        color: #bf6dbf;
+        text-decoration: none;
+    }
+    
+    a:hover {
+        text-decoration: underline;
+    }
+    
+    /* Streamlit defaults override */
+    .stMarkdown {
+        color: #1f2937;
+    }
+    </style>
+    """
+
+
+def get_metric_card_html(title, value, delta=None, icon="📊"):
+    """Metric card with clean styling"""
+    delta_html = ""
+    if delta:
+        if "+" in str(delta) or "✅" in str(delta) or "🟢" in str(delta):
+            delta_color = "#10b981"
+        elif "⚠️" in str(delta) or "🔴" in str(delta):
+            delta_color = "#ef4444"
+        else:
+            delta_color = "#4a4a4a"
+        delta_html = f'<div style="font-size: 0.875rem; color: {delta_color}; margin-top: 0.25rem;">{delta}</div>'
+    
+    return f'''
+    <div class="metric-card">
+        <div style="display: flex; align-items: center; gap: 0.75rem; margin-bottom: 0.5rem;">
+            <span style="font-size: 1.5rem;">{icon}</span>
+            <span style="font-size: 0.875rem; color: #6b7280; font-weight: 500;">{title}</span>
+        </div>
+        <div style="font-size: 1.75rem; font-weight: 700; color: #1f2937; margin-bottom: 0.25rem;">{value}</div>
+        {delta_html}
+    </div>
+    '''
+
+
+def get_insight_html(insight_text, card_type="insight"):
+    """Insight card styling"""
+    icon = "💡" if card_type == "insight" else "⚠️"
+    card_class = f"insight-card {card_type}"
+    
+    return f'''
+    <div class="{card_class}">
+        <div style="display: flex; align-items: flex-start; gap: 0.75rem;">
+            <span style="font-size: 1.25rem;">{icon}</span>
+            <div style="flex: 1;">
+                <p style="margin: 0; font-size: 0.9rem; color: #374151;">{insight_text}</p>
+            </div>
+        </div>
+    </div>
+    '''
+
+
+def get_dashboard_header_css():
+    """Additional CSS for dashboard header"""
+    return """
+    <style>
+    .dashboard-header {
+        padding: 1.5rem;
+        background: linear-gradient(135deg, #bf6dbf 0%, #5f5fba 100%);
+        border-radius: 1rem;
+        color: white;
+        margin-bottom: 2rem;
+    }
+    
+    .dashboard-header h1 {
+        margin: 0;
+        color: white;
+        font-size: 2rem;
+    }
+    
+    .dashboard-header p {
+        margin: 0.5rem 0 0 0;
+        opacity: 0.9;
+    }
+    </style>
+    """