addes more section , improvments , scalability

backend/app/config.py

@@ -31,9 +31,9 @@ class Settings(BaseSettings):
 
     # ── App ──────────────────────────────────────────────────────────────
     app_name: str = "QuantHedge"
-    app_version: str = "1.0.0"
+    app_version: str = "2.0.0"
     debug: bool = False
-    cors_origins: str = '["*"]'
+    cors_origins: str = '["http://localhost:5173"]'
 
     @property
     def cors_origin_list(self) -> List[str]:
@@ -43,7 +43,7 @@ class Settings(BaseSettings):
             return ["http://localhost:5173"]
 
     # ── Database ─────────────────────────────────────────────────────────
-    database_url: str = "postgresql+asyncpg://postgres:Jashdoshi7%24@localhost:5432/hedge"
+    database_url: str = "sqlite+aiosqlite:///./quanthedge.db"
 
     # ── Redis ────────────────────────────────────────────────────────────
     redis_url: str = "redis://localhost:6379/0"
@@ -62,6 +62,10 @@ class Settings(BaseSettings):
     news_api_key: str = ""
     groq_api_key: str = ""
 
+    # ── Quantitative Constants ───────────────────────────────────────────
+    risk_free_rate: float = 0.04  # 4% — single source of truth
+    trading_days_per_year: int = 252
+
 
 @lru_cache()
 def get_settings() -> Settings:

backend/app/database.py

@@ -55,8 +55,12 @@ else:
     if _needs_ssl:
         import ssl as _ssl
         _ssl_ctx = _ssl.create_default_context()
-        _ssl_ctx.check_hostname = False
-        _ssl_ctx.verify_mode = _ssl.CERT_NONE
+        # Use proper certificate verification in production
+        # Set QH_SSL_VERIFY=0 env var to disable for self-signed certs
+        import os
+        if os.environ.get("QH_SSL_VERIFY", "1") == "0":
+            _ssl_ctx.check_hostname = False
+            _ssl_ctx.verify_mode = _ssl.CERT_NONE
         _connect_args["ssl"] = _ssl_ctx
 
 engine = create_async_engine(

backend/app/main.py

@@ -114,7 +114,7 @@ def create_app() -> FastAPI:
     )
 
     # Mount routers
-    from app.routers import auth, backtests, calendar, data, holdings, marketplace, ml, portfolios, quant, research, sentiment, strategies
+    from app.routers import auth, backtests, calendar, copilot, data, holdings, marketplace, ml, portfolios, quant, research, sentiment, strategies
 
     app.include_router(auth.router, prefix="/api")
     app.include_router(data.router, prefix="/api")
@@ -128,6 +128,7 @@ def create_app() -> FastAPI:
     app.include_router(holdings.router)
     app.include_router(sentiment.router)
     app.include_router(calendar.router)
+    app.include_router(copilot.router)
 
 
     # Health check

backend/app/routers/copilot.py

@@ -0,0 +1,55 @@
+"""
+HedgeAIRouter.
+
+Natural language chat endpoint for the QuantHedge Copilot.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.dependencies import get_current_user
+from app.models.user import User
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/copilot", tags=["HedgeAI"])
+
+
+class CopilotMessage(BaseModel):
+    message: str = Field(..., min_length=1, max_length=2000, description="User's natural language query")
+
+
+@router.post("/chat")
+async def copilot_chat(
+    data: CopilotMessage,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """
+    Chat with the QuantHedge HedgeAI.
+
+    Understands natural language queries about portfolio risk, hedging,
+    stress testing, sentiment, and more. Routes to appropriate engines
+    and returns conversational responses with suggested actions.
+    """
+    from app.services.ai_research.copilot import chat
+    from app.services.holdings.engine import compute_portfolio_summary
+
+    # Get portfolio context for the copilot
+    try:
+        portfolio_context = await compute_portfolio_summary(db, user.id)
+    except Exception:
+        portfolio_context = None
+
+    try:
+        result = await chat(data.message, portfolio_context)
+        return result
+    except Exception as e:
+        logger.error("Copilot error: %s", e)
+        raise HTTPException(status_code=500, detail="Copilot processing failed")

backend/app/routers/holdings.py

@@ -2,7 +2,9 @@
 Holdings Router.
 
 CRUD for user holdings plus portfolio summary with live P&L,
-and stress test simulation endpoints.
+stress test simulation, Monte Carlo VaR, P&L attribution,
+behavioral bias detection, crisis replay, portfolio DNA,
+health score, and rolling metrics endpoints.
 """
 
 from __future__ import annotations
@@ -23,7 +25,7 @@ from app.services.holdings.engine import (
     delete_holding,
     compute_portfolio_summary,
 )
-from app.services.risk.stress_test import run_stress_test, run_all_scenarios
+from app.services.risk.stress_test import run_stress_test, run_all_scenarios, compute_real_betas
 
 router = APIRouter(prefix="/api/holdings", tags=["Holdings"])
 
@@ -60,7 +62,17 @@ class StressTestRequest(BaseModel):
     custom_shock: Optional[float] = None
 
 
-# ── Endpoints ────────────────────────────────────────────────────────────
+class CrisisReplayRequest(BaseModel):
+    crisis_id: str = Field("covid_2020", description="Crisis ID to replay")
+
+
+class MonteCarloRequest(BaseModel):
+    horizon_days: int = Field(60, ge=5, le=252)
+    n_simulations: int = Field(10000, ge=100, le=50000)
+    regime_conditioned: bool = False
+
+
+# ── CRUD Endpoints ───────────────────────────────────────────────────────
 @router.get("/")
 async def list_holdings(
     db: AsyncSession = Depends(get_db),
@@ -139,19 +151,27 @@ async def portfolio_summary(
     return await compute_portfolio_summary(db, user.id)
 
 
+# ── Stress Test ──────────────────────────────────────────────────────────
 @router.post("/stress-test")
 async def stress_test(
     data: StressTestRequest,
     db: AsyncSession = Depends(get_db),
     user: User = Depends(get_current_user),
 ):
-    """Run a stress test on the user's portfolio."""
+    """Run a stress test on the user's portfolio (with real computed betas)."""
     summary = await compute_portfolio_summary(db, user.id)
     holdings = summary.get("holdings", [])
     if not holdings:
         raise HTTPException(status_code=400, detail="No holdings to test")
 
-    result = run_stress_test(holdings, scenario_id=data.scenario_id, custom_shock=data.custom_shock)
+    # Compute real betas for accurate stress testing
+    tickers = [h["ticker"] for h in holdings]
+    computed_betas = await compute_real_betas(tickers)
+
+    result = run_stress_test(
+        holdings, scenario_id=data.scenario_id,
+        custom_shock=data.custom_shock, computed_betas=computed_betas
+    )
     if "error" in result:
         raise HTTPException(status_code=400, detail=result["error"])
     return result
@@ -167,9 +187,13 @@ async def all_stress_tests(
     holdings = summary.get("holdings", [])
     if not holdings:
         return {"scenarios": []}
-    return {"scenarios": run_all_scenarios(holdings)}
 
+    tickers = [h["ticker"] for h in holdings]
+    computed_betas = await compute_real_betas(tickers)
+    return {"scenarios": run_all_scenarios(holdings, computed_betas=computed_betas)}
 
+
+# ── Hedge Recommendations ────────────────────────────────────────────────
 @router.get("/hedge-recommendations")
 async def hedge_recommendations(
     db: AsyncSession = Depends(get_db),
@@ -186,21 +210,23 @@ async def hedge_recommendations(
     return generate_hedge_recommendations(holdings, total_value)
 
 
+# ── Options Hedge (with Greeks) ──────────────────────────────────────────
 @router.get("/options-hedge")
 async def options_hedge(
     db: AsyncSession = Depends(get_db),
     user: User = Depends(get_current_user),
 ):
-    """Calculate options hedge strategies for portfolio holdings."""
-    from app.services.risk.options_calculator import calculate_options_hedge
+    """Calculate options hedge strategies with full Greeks."""
+    from app.services.risk.options_calculator import calculate_options_hedge_async
 
     summary = await compute_portfolio_summary(db, user.id)
     holdings = summary.get("holdings", [])
     if not holdings:
         return {"strategies": []}
-    return calculate_options_hedge(holdings)
+    return await calculate_options_hedge_async(holdings)
 
 
+# ── Rebalance ────────────────────────────────────────────────────────────
 @router.get("/rebalance")
 async def rebalance(
     db: AsyncSession = Depends(get_db),
@@ -217,6 +243,7 @@ async def rebalance(
     return compute_rebalance(holdings, total_value)
 
 
+# ── Correlation ──────────────────────────────────────────────────────────
 @router.get("/correlation")
 async def correlation_matrix(
     db: AsyncSession = Depends(get_db),
@@ -232,3 +259,124 @@ async def correlation_matrix(
         return {"matrix": [], "tickers": tickers, "pairs": [], "risk_flags": []}
     return await compute_correlation_matrix(tickers)
 
+
+# ── Monte Carlo VaR ─────────────────────────────────────────────────────
+@router.post("/monte-carlo")
+async def monte_carlo_var(
+    data: MonteCarloRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Run Monte Carlo VaR simulation on portfolio."""
+    from app.services.risk.monte_carlo import run_monte_carlo
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    if not holdings:
+        return {"error": "No holdings for simulation"}
+    return await run_monte_carlo(
+        holdings,
+        horizon_days=data.horizon_days,
+        n_simulations=data.n_simulations,
+        regime_conditioned=data.regime_conditioned,
+    )
+
+
+# ── Portfolio Health Score ───────────────────────────────────────────────
+@router.get("/health-score")
+async def health_score(
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Compute comprehensive portfolio health score."""
+    from app.services.analytics.health_score import compute_health_score
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    return await compute_health_score(holdings, total_value)
+
+
+# ── Behavioral Bias Detector ────────────────────────────────────────────
+@router.get("/bias-analysis")
+async def bias_analysis(
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Detect behavioral biases in portfolio composition."""
+    from app.services.analytics.bias_detector import detect_biases
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    return await detect_biases(holdings, total_value)
+
+
+# ── Crisis Replay ────────────────────────────────────────────────────────
+@router.post("/crisis-replay")
+async def crisis_replay(
+    data: CrisisReplayRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Replay a historical crisis against user portfolio."""
+    from app.services.risk.crisis_replay import replay_crisis
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    if not holdings:
+        return {"error": "No holdings for crisis replay"}
+    return await replay_crisis(holdings, total_value, data.crisis_id)
+
+
+@router.get("/crisis-replay/all")
+async def all_crisis_replays(
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Replay all crises and return summary comparison."""
+    from app.services.risk.crisis_replay import replay_all_crises
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    if not holdings:
+        return {"crises": [], "available": []}
+    return await replay_all_crises(holdings, total_value)
+
+
+# ── Portfolio DNA ────────────────────────────────────────────────────────
+@router.get("/portfolio-dna")
+async def portfolio_dna(
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Compute portfolio DNA fingerprint with famous portfolio comparisons."""
+    from app.services.analytics.portfolio_dna import compute_portfolio_dna
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    return await compute_portfolio_dna(holdings, total_value)
+
+
+# ── P&L Attribution ──────────────────────────────────────────────────────
+@router.get("/attribution")
+async def pl_attribution(
+    method: str = "brinson",
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Compute P&L attribution (Brinson or factor-based)."""
+    from app.services.analytics.attribution import brinson_attribution, factor_attribution
+
+    summary = await compute_portfolio_summary(db, user.id)
+    holdings = summary.get("holdings", [])
+    total_value = summary.get("total_value", 0)
+    if not holdings:
+        return {"error": "No holdings for attribution"}
+
+    if method == "factor":
+        return await factor_attribution(holdings, total_value)
+    return await brinson_attribution(holdings, total_value)

backend/app/services/ai_research/copilot.py

@@ -0,0 +1,226 @@
+"""
+Natural Language Hedging Copilot.
+
+Chat-like interface that accepts natural language queries and routes them
+to the appropriate QuantHedge engines:
+
+- "How would my portfolio do in a recession?" → Stress Test
+- "What's my biggest risk?" → Risk Analysis
+- "Should I hedge NVDA?" → Options Calculator
+- "Analyze market sentiment for AAPL" → Sentiment Engine
+- "Predict TSLA returns" → XGBoost Predictor
+- "What factors am I exposed to?" → Factor Model
+
+Uses Groq LLM for intent classification and response generation.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+from app.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+_settings = get_settings()
+
+
+SYSTEM_PROMPT = """You are QuantHedge Copilot, an AI financial analyst assistant.
+You help users understand their portfolio risk, analyze markets, and make better investment decisions.
+
+When the user asks a question, you should:
+1. Classify their intent into one of these categories:
+   - stress_test: portfolio stress testing or crisis scenarios
+   - risk_analysis: risk metrics, VaR, volatility analysis
+   - options_hedge: options pricing, Greeks, hedge strategies
+   - sentiment: market sentiment or news analysis
+   - prediction: stock return prediction or forecasting
+   - factors: factor analysis or exposure
+   - portfolio_health: portfolio health score or overall assessment
+   - bias_detection: behavioral bias analysis
+   - crisis_replay: historical crisis simulation
+   - general: general financial question or advice
+
+2. Extract any relevant tickers, scenarios, or parameters.
+
+Respond ONLY with a JSON object in this format:
+{
+  "intent": "<category>",
+  "tickers": ["TICKER1", "TICKER2"],
+  "parameters": {"key": "value"},
+  "direct_answer": "<your helpful response to the user>"
+}
+
+Be conversational and helpful in direct_answer. Use financial terminology appropriately.
+"""
+
+
+async def chat(
+    message: str,
+    portfolio_context: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Process a natural language query from the user.
+
+    Args:
+        message: User's natural language input
+        portfolio_context: Optional current portfolio summary for context
+
+    Returns:
+        Response with intent classification, routed data, and conversational reply.
+    """
+    if not _settings.groq_api_key:
+        return _fallback_response(message, portfolio_context)
+
+    context_text = ""
+    if portfolio_context:
+        holdings = portfolio_context.get("holdings", [])
+        if holdings:
+            tickers_str = ", ".join(h.get("ticker", "") for h in holdings[:10])
+            total_val = portfolio_context.get("total_value", 0)
+            total_pnl = portfolio_context.get("total_pnl", 0)
+            context_text = f"\n\nUser's current portfolio: {tickers_str} (Total: ${total_val:,.0f}, P&L: ${total_pnl:,.0f})"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {_settings.groq_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": "llama-3.3-70b-versatile",
+                    "messages": [
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": message + context_text},
+                    ],
+                    "temperature": 0.3,
+                    "max_tokens": 1000,
+                },
+                timeout=aiohttp.ClientTimeout(total=20),
+            ) as resp:
+                if resp.status != 200:
+                    return _fallback_response(message, portfolio_context)
+                data = await resp.json()
+                content = data["choices"][0]["message"]["content"]
+
+                # Parse JSON from response
+                start = content.find("{")
+                end = content.rfind("}") + 1
+                if start >= 0 and end > start:
+                    parsed = json.loads(content[start:end])
+                    return {
+                        "intent": parsed.get("intent", "general"),
+                        "tickers": parsed.get("tickers", []),
+                        "parameters": parsed.get("parameters", {}),
+                        "response": parsed.get("direct_answer", content),
+                        "actions": _get_suggested_actions(parsed.get("intent", "general"), parsed.get("tickers", [])),
+                    }
+                else:
+                    return {
+                        "intent": "general",
+                        "tickers": [],
+                        "parameters": {},
+                        "response": content,
+                        "actions": [],
+                    }
+    except Exception as e:
+        logger.warning("Copilot LLM call failed: %s", e)
+        return _fallback_response(message, portfolio_context)
+
+
+def _fallback_response(
+    message: str,
+    portfolio_context: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Keyword-based fallback when LLM is unavailable."""
+    msg_lower = message.lower()
+
+    intent = "general"
+    tickers = []
+
+    if any(w in msg_lower for w in ("stress", "crash", "recession", "scenario")):
+        intent = "stress_test"
+    elif any(w in msg_lower for w in ("risk", "var", "volatility", "drawdown")):
+        intent = "risk_analysis"
+    elif any(w in msg_lower for w in ("option", "put", "call", "hedge", "greek")):
+        intent = "options_hedge"
+    elif any(w in msg_lower for w in ("sentiment", "news", "mood")):
+        intent = "sentiment"
+    elif any(w in msg_lower for w in ("predict", "forecast", "return", "ml")):
+        intent = "prediction"
+    elif any(w in msg_lower for w in ("factor", "exposure", "momentum", "value")):
+        intent = "factors"
+    elif any(w in msg_lower for w in ("health", "score", "grade")):
+        intent = "portfolio_health"
+    elif any(w in msg_lower for w in ("bias", "behavioral", "disposition")):
+        intent = "bias_detection"
+    elif any(w in msg_lower for w in ("crisis", "replay", "historical", "covid", "2008")):
+        intent = "crisis_replay"
+
+    # Extract tickers (uppercase 1-5 letter words)
+    import re
+    potential_tickers = re.findall(r'\b[A-Z]{1,5}\b', message)
+    tickers = [t for t in potential_tickers if t not in {"I", "A", "THE", "AND", "FOR", "HOW", "MY", "IS", "TO", "IN", "DO", "ME"}]
+
+    responses = {
+        "stress_test": "I can run stress tests on your portfolio. Try the Stress Test tab to see how your holdings would perform under various scenarios like a market crash or rate hike.",
+        "risk_analysis": "Let me help analyze your portfolio risk. Check the Holdings page for comprehensive risk metrics including VaR, volatility, and drawdown analysis.",
+        "options_hedge": "I can help with options hedging strategies. The Options Hedge section shows protective puts, covered calls, and collar strategies with full Greeks.",
+        "sentiment": "I can analyze market sentiment for any ticker. Head to the Sentiment page for AI-powered news analysis.",
+        "prediction": "Our XGBoost model can predict short-term return direction. Use the Markets page to get ML predictions for any ticker.",
+        "factors": "Factor analysis breaks down your exposure to systematic risk factors. Check the Factor Analysis page for detailed factor exposures.",
+        "portfolio_health": "Your Portfolio Health Score gives a comprehensive 0-100 grade across 7 dimensions. Check the Health page for details.",
+        "bias_detection": "The Behavioral Bias Detector analyzes your trading patterns for cognitive biases. Check the Bias page for your scorecard.",
+        "crisis_replay": "Historical Crisis Replay shows how your portfolio would have fared during past crises like COVID, 2008, and the Dot-Com bust.",
+        "general": "I'm here to help with your portfolio analysis. Try asking about risk, hedging, sentiment, or stress testing!",
+    }
+
+    return {
+        "intent": intent,
+        "tickers": tickers,
+        "parameters": {},
+        "response": responses.get(intent, responses["general"]),
+        "actions": _get_suggested_actions(intent, tickers),
+    }
+
+
+def _get_suggested_actions(intent: str, tickers: list) -> list:
+    """Generate suggested follow-up actions based on intent."""
+    actions_map = {
+        "stress_test": [
+            {"label": "Run All Stress Tests", "route": "/holdings", "tab": "stress"},
+            {"label": "View Crisis Replay", "route": "/crisis-replay"},
+        ],
+        "risk_analysis": [
+            {"label": "View Risk Metrics", "route": "/holdings", "tab": "risk"},
+            {"label": "Monte Carlo VaR", "route": "/holdings", "tab": "montecarlo"},
+        ],
+        "options_hedge": [
+            {"label": "View Options Strategies", "route": "/holdings", "tab": "options"},
+        ],
+        "sentiment": [
+            {"label": "View Sentiment", "route": "/sentiment"},
+        ],
+        "prediction": [
+            {"label": "View ML Predictions", "route": "/market"},
+        ],
+        "factors": [
+            {"label": "Factor Analysis", "route": "/factors"},
+        ],
+        "portfolio_health": [
+            {"label": "View Health Score", "route": "/portfolio-health"},
+        ],
+        "bias_detection": [
+            {"label": "View Bias Report", "route": "/bias-detector"},
+        ],
+        "crisis_replay": [
+            {"label": "Crisis Replay", "route": "/crisis-replay"},
+        ],
+    }
+    return actions_map.get(intent, [])

backend/app/services/analytics/attribution.py

@@ -0,0 +1,230 @@
+"""
+P&L Attribution Engine.
+
+Two attribution methodologies:
+1. Brinson Attribution — allocation effect + selection effect vs benchmark
+2. Factor-Based Attribution — decompose returns into factor contributions
+
+Provides waterfall chart data for visualizing P&L breakdown.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from app.config import get_settings
+from app.services.data_ingestion.yahoo import yahoo_adapter
+
+logger = logging.getLogger(__name__)
+
+_settings = get_settings()
+TRADING_DAYS = _settings.trading_days_per_year
+
+
+async def brinson_attribution(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+    benchmark: str = "SPY",
+    period: str = "1y",
+) -> Dict[str, Any]:
+    """
+    Brinson-Fachler attribution: decompose portfolio P&L into
+    allocation effect, selection effect, and interaction effect.
+    """
+    if not holdings or total_value <= 0:
+        return {"error": "No holdings for attribution"}
+
+    # Group holdings by sector/asset_class
+    sector_map: Dict[str, List[Dict]] = {}
+    for h in holdings:
+        sector = h.get("asset_class", h.get("sector", "equity"))
+        if sector not in sector_map:
+            sector_map[sector] = []
+        sector_map[sector].append(h)
+
+    # Compute benchmark returns
+    bench_df = await yahoo_adapter.get_price_dataframe(benchmark, period=period)
+    if bench_df.empty:
+        return {"error": "Could not fetch benchmark data"}
+    bench_returns = bench_df["Close"].pct_change().dropna()
+    bench_total_return = float((bench_df["Close"].iloc[-1] / bench_df["Close"].iloc[0]) - 1)
+
+    # Compute per-sector portfolio weights and returns
+    sectors = []
+    total_port_return = 0.0
+
+    for sector, sector_holdings in sector_map.items():
+        sector_value = sum(h.get("market_value", 0) for h in sector_holdings)
+        port_weight = sector_value / total_value
+        sector_pnl = sum(h.get("pnl", 0) for h in sector_holdings)
+        sector_cost = sum(h.get("cost_basis", h.get("avg_price", 0) * h.get("quantity", 0)) for h in sector_holdings)
+        sector_return = (sector_pnl / sector_cost) if sector_cost > 0 else 0
+
+        # Approximate benchmark weight (equal for simplicity)
+        bench_weight = 1.0 / max(len(sector_map), 1)
+
+        # Brinson decomposition
+        allocation_effect = (port_weight - bench_weight) * bench_total_return
+        selection_effect = bench_weight * (sector_return - bench_total_return)
+        interaction_effect = (port_weight - bench_weight) * (sector_return - bench_total_return)
+        total_effect = allocation_effect + selection_effect + interaction_effect
+
+        total_port_return += port_weight * sector_return
+
+        sectors.append({
+            "sector": sector,
+            "portfolio_weight": round(port_weight * 100, 2),
+            "benchmark_weight": round(bench_weight * 100, 2),
+            "portfolio_return": round(sector_return * 100, 2),
+            "benchmark_return": round(bench_total_return * 100, 2),
+            "allocation_effect": round(allocation_effect * 100, 4),
+            "selection_effect": round(selection_effect * 100, 4),
+            "interaction_effect": round(interaction_effect * 100, 4),
+            "total_effect": round(total_effect * 100, 4),
+            "pnl": round(sector_pnl, 2),
+        })
+
+    # Sort by total effect
+    sectors.sort(key=lambda x: x["total_effect"], reverse=True)
+
+    total_alpha = total_port_return - bench_total_return
+
+    # Waterfall chart data
+    waterfall = [{"label": "Benchmark", "value": round(bench_total_return * 100, 2), "type": "start"}]
+    for s in sectors:
+        waterfall.append({
+            "label": f"{s['sector']} (Alloc)",
+            "value": s["allocation_effect"],
+            "type": "positive" if s["allocation_effect"] >= 0 else "negative",
+        })
+        waterfall.append({
+            "label": f"{s['sector']} (Select)",
+            "value": s["selection_effect"],
+            "type": "positive" if s["selection_effect"] >= 0 else "negative",
+        })
+    waterfall.append({"label": "Portfolio Return", "value": round(total_port_return * 100, 2), "type": "total"})
+
+    return {
+        "method": "brinson",
+        "benchmark": benchmark,
+        "benchmark_return": round(bench_total_return * 100, 2),
+        "portfolio_return": round(total_port_return * 100, 2),
+        "alpha": round(total_alpha * 100, 2),
+        "sectors": sectors,
+        "waterfall": waterfall,
+    }
+
+
+async def factor_attribution(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+    period: str = "1y",
+) -> Dict[str, Any]:
+    """
+    Factor-based attribution: decompose returns into contributions from
+    systematic factors (market, size, value, momentum, volatility).
+    """
+    if not holdings or total_value <= 0:
+        return {"error": "No holdings for factor attribution"}
+
+    tickers = list(set(h.get("ticker", "") for h in holdings if h.get("market_value", 0) > 0))
+
+    # Fetch returns
+    returns_data = {}
+    for ticker in tickers:
+        try:
+            df = await yahoo_adapter.get_price_dataframe(ticker, period=period)
+            if not df.empty and len(df) > 20:
+                returns_data[ticker] = df["Close"].pct_change().dropna()
+        except Exception:
+            continue
+
+    if not returns_data:
+        return {"error": "Could not fetch return data"}
+
+    # Align
+    aligned = pd.DataFrame(returns_data).dropna()
+    if aligned.empty:
+        return {"error": "Insufficient overlapping data"}
+
+    # Compute portfolio returns
+    weights = np.array([
+        sum(h.get("market_value", 0) for h in holdings if h.get("ticker") == t) / total_value
+        for t in aligned.columns
+    ])
+    port_returns = aligned.values @ weights
+
+    # Fetch factor proxies
+    factor_tickers = {
+        "market": "SPY",
+        "size": "IWM",
+        "value": "IVE",
+        "momentum": "MTUM",
+        "low_vol": "USMV",
+    }
+
+    factor_returns: Dict[str, pd.Series] = {}
+    for fname, fticker in factor_tickers.items():
+        try:
+            df = await yahoo_adapter.get_price_dataframe(fticker, period=period)
+            if not df.empty and len(df) > 20:
+                factor_returns[fname] = df["Close"].pct_change().dropna()
+        except Exception:
+            pass
+
+    if not factor_returns:
+        return {"error": "Could not fetch factor data"}
+
+    # Simple OLS regression for factor loadings
+    factor_df = pd.DataFrame(factor_returns).dropna()
+    min_len = min(len(port_returns), len(factor_df))
+    if min_len < 30:
+        return {"error": "Insufficient data for factor attribution"}
+
+    y = port_returns[:min_len]
+    X = factor_df.iloc[:min_len].values
+
+    # Add intercept
+    X_with_intercept = np.column_stack([np.ones(min_len), X])
+
+    try:
+        # Least squares
+        betas, _, _, _ = np.linalg.lstsq(X_with_intercept, y, rcond=None)
+        alpha_daily = betas[0]
+        factor_betas = betas[1:]
+    except Exception:
+        return {"error": "Regression failed"}
+
+    # Attribution
+    factor_names = list(factor_df.columns)
+    contributions = []
+    total_explained = 0.0
+
+    for i, fname in enumerate(factor_names):
+        avg_factor_ret = float(factor_df[fname].mean() * TRADING_DAYS)
+        contribution = float(factor_betas[i] * avg_factor_ret * 100)
+        total_explained += contribution
+        contributions.append({
+            "factor": fname,
+            "beta": round(float(factor_betas[i]), 4),
+            "factor_return": round(avg_factor_ret * 100, 2),
+            "contribution": round(contribution, 4),
+        })
+
+    alpha_contribution = round(float(alpha_daily * TRADING_DAYS * 100), 4)
+    total_return = round(float(np.mean(y) * TRADING_DAYS * 100), 2)
+
+    contributions.sort(key=lambda x: abs(x["contribution"]), reverse=True)
+
+    return {
+        "method": "factor_based",
+        "total_return": total_return,
+        "alpha": alpha_contribution,
+        "factor_contributions": contributions,
+        "total_explained": round(total_explained, 4),
+        "residual": round(total_return - total_explained - alpha_contribution, 4),
+    }

backend/app/services/analytics/bias_detector.py

@@ -0,0 +1,242 @@
+"""
+Behavioral Bias Detector.
+
+Analyzes user portfolio and trading patterns to detect common
+cognitive biases that harm investment performance:
+
+- Disposition Effect — selling winners too early, holding losers too long
+- Overconcentration — insufficient diversification
+- Recency Bias — chasing recent performance
+- Home Country Bias — over-exposure to domestic markets
+- Anchoring — fixating on purchase price instead of fundamentals
+- Loss Aversion — asymmetric sensitivity to losses vs gains
+
+Returns a Behavioral Scorecard with letter grades (A–F) and coaching tips.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def _grade(score: float) -> str:
+    if score >= 90: return "A"
+    if score >= 80: return "B"
+    if score >= 70: return "C"
+    if score >= 60: return "D"
+    return "F"
+
+
+def _severity(score: float) -> str:
+    if score >= 80: return "low"
+    if score >= 60: return "moderate"
+    if score >= 40: return "high"
+    return "critical"
+
+
+async def detect_biases(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+) -> Dict[str, Any]:
+    """
+    Detect behavioral biases from portfolio holdings.
+
+    Returns per-bias analysis with grades and coaching tips.
+    """
+    if not holdings or total_value <= 0:
+        return {"score": 0, "grade": "F", "biases": [], "tips": ["Add holdings to analyze behavioral biases."]}
+
+    biases = []
+    tips = []
+
+    # ── 1. Disposition Effect ────────────────────────────────────────────
+    # Detect: are losers being held longer than winners?
+    winners = [h for h in holdings if h.get("pnl", 0) > 0]
+    losers = [h for h in holdings if h.get("pnl", 0) < 0]
+
+    if winners and losers:
+        avg_winner_pnl_pct = np.mean([abs(h.get("pnl_pct", 0)) for h in winners])
+        avg_loser_pnl_pct = np.mean([abs(h.get("pnl_pct", 0)) for h in losers])
+
+        # Disposition effect: losers have larger unrealized losses than winners have gains
+        # (holding on to losers, selling winners early)
+        if avg_loser_pnl_pct > avg_winner_pnl_pct * 1.5:
+            disp_score = max(20, 80 - (avg_loser_pnl_pct - avg_winner_pnl_pct) * 2)
+        else:
+            disp_score = min(100, 80 + (avg_winner_pnl_pct - avg_loser_pnl_pct))
+
+        loser_value = sum(abs(h.get("pnl", 0)) for h in losers)
+        winner_value = sum(h.get("pnl", 0) for h in winners)
+    else:
+        disp_score = 85
+        loser_value = 0
+        winner_value = sum(h.get("pnl", 0) for h in winners) if winners else 0
+
+    biases.append({
+        "name": "Disposition Effect",
+        "description": "Tendency to sell winning positions too quickly while holding losers too long",
+        "score": round(disp_score, 1),
+        "grade": _grade(disp_score),
+        "severity": _severity(disp_score),
+        "detail": f"{len(winners)} winners (avg +{np.mean([h.get('pnl_pct', 0) for h in winners]):.1f}%) vs {len(losers)} losers (avg {np.mean([h.get('pnl_pct', 0) for h in losers]):.1f}%)" if winners and losers else "Insufficient data",
+        "icon": "📉",
+    })
+    if disp_score < 60:
+        tips.append("📉 **Disposition Effect detected.** Consider reviewing your losing positions objectively — would you buy them today at current prices? If not, consider exiting.")
+
+    # ── 2. Overconcentration ─────────────────────────────────────────────
+    weights = [h.get("weight", 0) for h in holdings]
+    sorted_w = sorted(weights, reverse=True)
+    top1 = sorted_w[0] if sorted_w else 0
+    top3 = sum(sorted_w[:3]) if len(sorted_w) >= 3 else sum(sorted_w)
+
+    # HHI-based scoring
+    w_arr = np.array(weights) / 100 if weights else np.array([1])
+    hhi = float(np.sum(w_arr ** 2))
+
+    if top1 > 30:
+        conc_score = max(20, 60 - (top1 - 30) * 2)
+    elif top3 > 60:
+        conc_score = max(40, 70 - (top3 - 60) * 1.5)
+    elif len(holdings) < 5:
+        conc_score = max(50, 70 - (5 - len(holdings)) * 10)
+    else:
+        conc_score = min(100, 75 + len(holdings) * 1.5)
+
+    biases.append({
+        "name": "Overconcentration",
+        "description": "Insufficient diversification across positions and sectors",
+        "score": round(conc_score, 1),
+        "grade": _grade(conc_score),
+        "severity": _severity(conc_score),
+        "detail": f"Top holding: {top1:.1f}%, Top 3: {top3:.1f}%, HHI: {hhi:.3f}, {len(holdings)} positions",
+        "icon": "🎯",
+    })
+    if conc_score < 60:
+        tips.append(f"🎯 **Overconcentration detected.** Your top position is {top1:.0f}% of portfolio. Target < 15% per position for better risk management.")
+
+    # ── 3. Recency Bias ──────────────────────────────────────────────────
+    # Look at whether recent purchases are momentum-driven
+    recent_winners = [h for h in holdings if h.get("pnl_pct", 0) > 10]
+    recent_losers = [h for h in holdings if h.get("pnl_pct", 0) < -10]
+
+    # Heuristic: if most of portfolio has high positive P&L, user may be chasing
+    positive_weight = sum(h.get("weight", 0) for h in holdings if h.get("pnl_pct", 0) > 15)
+    if positive_weight > 60:
+        recency_score = max(30, 80 - positive_weight * 0.5)
+    elif positive_weight > 40:
+        recency_score = 70
+    else:
+        recency_score = 85
+
+    biases.append({
+        "name": "Recency Bias",
+        "description": "Overweighting recent market performance when making investment decisions",
+        "score": round(recency_score, 1),
+        "grade": _grade(recency_score),
+        "severity": _severity(recency_score),
+        "detail": f"{positive_weight:.0f}% portfolio weight in strongly gaining positions",
+        "icon": "⏰",
+    })
+    if recency_score < 60:
+        tips.append("⏰ **Recency Bias detected.** You may be chasing recent winners. Consider mean-reversion and value opportunities.")
+
+    # ── 4. Home Country Bias ─────────────────────────────────────────────
+    # Detect US-heavy vs international exposure
+    us_tickers = sum(1 for h in holdings if not any(
+        suffix in h.get("ticker", "") for suffix in [".NS", ".HK", ".T", ".L", ".DE", ".PA"]
+    ))
+    intl_tickers = len(holdings) - us_tickers
+    us_pct = (us_tickers / max(len(holdings), 1)) * 100
+
+    if us_pct > 90:
+        home_score = 40
+    elif us_pct > 80:
+        home_score = 55
+    elif us_pct > 70:
+        home_score = 70
+    elif us_pct > 50:
+        home_score = 85
+    else:
+        home_score = 90
+
+    biases.append({
+        "name": "Home Country Bias",
+        "description": "Over-exposure to domestic market at the expense of global diversification",
+        "score": round(home_score, 1),
+        "grade": _grade(home_score),
+        "severity": _severity(home_score),
+        "detail": f"{us_pct:.0f}% US tickers vs {100-us_pct:.0f}% international ({intl_tickers} foreign positions)",
+        "icon": "🌍",
+    })
+    if home_score < 60:
+        tips.append("🌍 **Home Country Bias detected.** Your portfolio is heavily US-focused. Consider adding international exposure (Europe, Asia, EM).")
+
+    # ── 5. Anchoring Bias ────────────────────────────────────────────────
+    # Detect: are holdings with large losses being kept because of the buy price?
+    deep_losers = [h for h in holdings if h.get("pnl_pct", 0) < -20]
+    anchoring_indicators = len(deep_losers)
+
+    if anchoring_indicators >= 3:
+        anchor_score = 35
+    elif anchoring_indicators >= 2:
+        anchor_score = 50
+    elif anchoring_indicators >= 1:
+        anchor_score = 65
+    else:
+        anchor_score = 90
+
+    biases.append({
+        "name": "Anchoring",
+        "description": "Fixating on purchase price rather than current fundamentals and forward outlook",
+        "score": round(anchor_score, 1),
+        "grade": _grade(anchor_score),
+        "severity": _severity(anchor_score),
+        "detail": f"{anchoring_indicators} positions with >20% loss still being held",
+        "icon": "⚓",
+    })
+    if anchor_score < 60:
+        deep_ticker_list = ", ".join(h.get("ticker", "?") for h in deep_losers[:3])
+        tips.append(f"⚓ **Anchoring detected** on {deep_ticker_list}. Evaluate each on current fundamentals, not your average cost.")
+
+    # ── 6. Loss Aversion ─────────────────────────────────────────────────
+    # Asymmetric P&L: much more aggregate loss unrealized than gain
+    total_unrealized_gain = sum(h.get("pnl", 0) for h in winners) if winners else 0
+    total_unrealized_loss = sum(abs(h.get("pnl", 0)) for h in losers) if losers else 0
+
+    if total_unrealized_loss > total_unrealized_gain * 2:
+        la_score = max(25, 70 - (total_unrealized_loss / max(total_unrealized_gain, 1) - 1) * 15)
+    elif total_unrealized_loss > total_unrealized_gain:
+        la_score = 65
+    else:
+        la_score = 85
+
+    biases.append({
+        "name": "Loss Aversion",
+        "description": "Asymmetric sensitivity — feeling losses ~2x more than equivalent gains",
+        "score": round(la_score, 1),
+        "grade": _grade(la_score),
+        "severity": _severity(la_score),
+        "detail": f"Unrealized gains: ${total_unrealized_gain:,.0f} vs losses: ${total_unrealized_loss:,.0f}",
+        "icon": "😰",
+    })
+    if la_score < 60:
+        tips.append("😰 **Loss Aversion pattern detected.** Your unrealized losses significantly outweigh gains. Consider a systematic stop-loss discipline.")
+
+    # ── Overall Behavioral Score ─────────────────────────────────────────
+    overall = round(np.mean([b["score"] for b in biases]), 1)
+
+    return {
+        "score": overall,
+        "grade": _grade(overall),
+        "biases": biases,
+        "tips": tips if tips else ["✅ No significant behavioral biases detected. Keep maintaining your disciplined approach!"],
+        "position_count": len(holdings),
+        "winners": len(winners),
+        "losers": len(losers),
+    }

backend/app/services/analytics/health_score.py

@@ -0,0 +1,258 @@
+"""
+Portfolio Health Score Engine.
+
+Computes a composite 0–100 portfolio health score from 7 weighted dimensions:
+- Diversification (20%) — HHI + correlation clustering
+- Risk-Adjusted Returns (20%) — Sharpe ratio quality
+- Drawdown Risk (15%) — Max drawdown and recovery
+- Concentration Risk (15%) — Top-N position weight
+- Volatility Health (10%) — Rolling vol stability
+- Hedge Coverage (10%) — Protective positions and hedges
+- Liquidity Score (10%) — Volume and spread quality
+
+Returns letter grades (A+ to F) with per-component drill-down and coaching tips.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from app.config import get_settings
+from app.services.data_ingestion.yahoo import yahoo_adapter
+
+logger = logging.getLogger(__name__)
+
+_settings = get_settings()
+RISK_FREE_RATE = _settings.risk_free_rate
+TRADING_DAYS = _settings.trading_days_per_year
+
+# ── Grading ──────────────────────────────────────────────────────────────
+
+def _grade(score: float) -> str:
+    if score >= 95: return "A+"
+    if score >= 90: return "A"
+    if score >= 85: return "A-"
+    if score >= 80: return "B+"
+    if score >= 75: return "B"
+    if score >= 70: return "B-"
+    if score >= 65: return "C+"
+    if score >= 60: return "C"
+    if score >= 55: return "C-"
+    if score >= 50: return "D+"
+    if score >= 45: return "D"
+    if score >= 40: return "D-"
+    return "F"
+
+
+def _grade_color(grade: str) -> str:
+    if grade.startswith("A"): return "#00c853"
+    if grade.startswith("B"): return "#2196f3"
+    if grade.startswith("C"): return "#ff9800"
+    if grade.startswith("D"): return "#f44336"
+    return "#b71c1c"
+
+
+async def compute_health_score(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+) -> Dict[str, Any]:
+    """
+    Compute comprehensive portfolio health score.
+
+    Returns per-component scores, overall score, grade, and coaching tips.
+    """
+    if not holdings or total_value <= 0:
+        return {"score": 0, "grade": "F", "components": [], "tips": ["Add holdings to get a health score."]}
+
+    # Fetch returns for volatility/Sharpe
+    tickers = list(set(h.get("ticker", "") for h in holdings if h.get("market_value", 0) > 0))
+    weights = []
+    returns_data = {}
+
+    for h in holdings:
+        weights.append(h.get("market_value", 0) / total_value)
+
+    for ticker in tickers:
+        try:
+            df = await yahoo_adapter.get_price_dataframe(ticker, period="1y")
+            if not df.empty and len(df) > 20:
+                returns_data[ticker] = df["Close"].pct_change().dropna()
+        except Exception:
+            continue
+
+    components = []
+    tips = []
+
+    # ── 1. Diversification Score (20%) ───────────────────────────────────
+    mkt_values = [h.get("market_value", 0) for h in holdings if h.get("market_value", 0) > 0]
+    if mkt_values:
+        w = np.array(mkt_values) / sum(mkt_values)
+        hhi = float(np.sum(w ** 2))
+        # HHI = 1 means single stock, HHI = 1/N means perfect diversification
+        n = len(w)
+        optimal_hhi = 1 / n if n > 0 else 1
+        # Score: 100 at optimal HHI, 0 at HHI=1
+        div_score = max(0, min(100, (1 - hhi) / (1 - optimal_hhi) * 100)) if n > 1 else 20
+
+        # Sector concentration
+        sectors = set(h.get("asset_class", "equity") for h in holdings)
+        sector_bonus = min(len(sectors) * 10, 30)
+        div_score = min(100, div_score * 0.7 + sector_bonus)
+    else:
+        div_score = 0
+
+    components.append({
+        "name": "Diversification",
+        "score": round(div_score, 1),
+        "weight": 20,
+        "grade": _grade(div_score),
+        "detail": f"HHI: {hhi:.3f}, {len(mkt_values)} positions, {len(set(h.get('asset_class', 'equity') for h in holdings))} asset classes",
+    })
+    if div_score < 60:
+        tips.append("📊 Add positions across more sectors and asset classes to improve diversification.")
+
+    # ── 2. Risk-Adjusted Returns (20%) ───────────────────────────────────
+    if returns_data and len(returns_data) > 0:
+        # Compute portfolio returns
+        aligned_returns = pd.DataFrame(returns_data).dropna()
+        if not aligned_returns.empty:
+            holding_weights = np.array([
+                sum(h.get("market_value", 0) for h in holdings if h.get("ticker") == t) / total_value
+                for t in aligned_returns.columns
+            ])
+            port_returns = aligned_returns.values @ holding_weights
+            ann_return = float(np.mean(port_returns) * TRADING_DAYS)
+            ann_vol = float(np.std(port_returns, ddof=1) * np.sqrt(TRADING_DAYS))
+            sharpe = (ann_return - RISK_FREE_RATE) / ann_vol if ann_vol > 0 else 0
+
+            # Sharpe > 2 = 100, Sharpe 0 = 40, Sharpe < -1 = 0
+            rar_score = max(0, min(100, 40 + sharpe * 30))
+        else:
+            rar_score = 50
+            sharpe = 0
+    else:
+        rar_score = 50
+        sharpe = 0
+
+    components.append({
+        "name": "Risk-Adjusted Returns",
+        "score": round(rar_score, 1),
+        "weight": 20,
+        "grade": _grade(rar_score),
+        "detail": f"Sharpe: {sharpe:.2f}",
+    })
+    if rar_score < 60:
+        tips.append("📈 Consider rebalancing toward higher Sharpe ratio positions to improve risk-adjusted returns.")
+
+    # ── 3. Drawdown Risk (15%) ───────────────────────────────────────────
+    if returns_data and 'port_returns' in dir():
+        cum = np.cumprod(1 + port_returns)
+        peak = np.maximum.accumulate(cum)
+        dd = (cum - peak) / peak
+        max_dd = float(np.min(dd)) if len(dd) > 0 else 0
+        # Max DD better than -5% = 100, -20% = 50, -40% = 0
+        dd_score = max(0, min(100, 100 + max_dd * 250))
+    else:
+        dd_score = 60
+        max_dd = 0
+
+    components.append({
+        "name": "Drawdown Risk",
+        "score": round(dd_score, 1),
+        "weight": 15,
+        "grade": _grade(dd_score),
+        "detail": f"Max Drawdown: {max_dd*100:.1f}%",
+    })
+    if dd_score < 50:
+        tips.append("🛡️ Large drawdown risk detected. Consider adding hedges or reducing volatile positions.")
+
+    # ── 4. Concentration Risk (15%) ──────────────────────────────────────
+    sorted_weights = sorted([h.get("weight", 0) for h in holdings], reverse=True)
+    top1 = sorted_weights[0] if sorted_weights else 0
+    top3 = sum(sorted_weights[:3]) if len(sorted_weights) >= 3 else sum(sorted_weights)
+
+    # Top 1 < 20% and Top 3 < 50% = 100
+    conc_score = max(0, min(100, 100 - max(0, top1 - 15) * 3 - max(0, top3 - 40) * 2))
+
+    components.append({
+        "name": "Concentration Risk",
+        "score": round(conc_score, 1),
+        "weight": 15,
+        "grade": _grade(conc_score),
+        "detail": f"Top holding: {top1:.1f}%, Top 3: {top3:.1f}%",
+    })
+    if conc_score < 60:
+        tips.append(f"⚖️ Top position is {top1:.0f}% of portfolio. Consider trimming to below 15%.")
+
+    # ── 5. Volatility Health (10%) ───────────────────────────────────────
+    if 'ann_vol' in dir() and ann_vol > 0:
+        # Vol < 10% = 100, Vol 20% = 70, Vol > 40% = 20
+        vol_score = max(0, min(100, 120 - ann_vol * 250))
+    else:
+        vol_score = 60
+        ann_vol = 0
+
+    components.append({
+        "name": "Volatility",
+        "score": round(vol_score, 1),
+        "weight": 10,
+        "grade": _grade(vol_score),
+        "detail": f"Annualized Vol: {ann_vol*100:.1f}%",
+    })
+
+    # ── 6. Hedge Coverage (10%) ──────────────────────────────────────────
+    short_positions = sum(1 for h in holdings if h.get("position_type") == "short")
+    etf_positions = sum(1 for h in holdings if h.get("asset_class") in ("etf", "fixed_income", "commodity"))
+    hedge_ratio = (short_positions + etf_positions) / max(len(holdings), 1) * 100
+
+    # Ideal: 10–30% hedge coverage
+    if 10 <= hedge_ratio <= 30:
+        hedge_score = 90
+    elif hedge_ratio > 30:
+        hedge_score = 70  # Over-hedged
+    elif hedge_ratio > 0:
+        hedge_score = 50 + hedge_ratio * 4
+    else:
+        hedge_score = 30
+
+    components.append({
+        "name": "Hedge Coverage",
+        "score": round(hedge_score, 1),
+        "weight": 10,
+        "grade": _grade(hedge_score),
+        "detail": f"{short_positions} hedges, {etf_positions} diversifiers ({hedge_ratio:.0f}% coverage)",
+    })
+    if hedge_score < 60:
+        tips.append("🔒 Consider adding hedging positions (inverse ETFs, bonds, or protective puts).")
+
+    # ── 7. Liquidity Score (10%) ─────────────────────────────────────────
+    # Based on number of positions and asset class mix
+    liquid_assets = sum(1 for h in holdings if h.get("asset_class") in ("equity", "etf"))
+    illiquid_assets = sum(1 for h in holdings if h.get("asset_class") in ("crypto", "commodity", "option"))
+    liquidity_score = min(100, (liquid_assets / max(len(holdings), 1)) * 100 + 10)
+
+    components.append({
+        "name": "Liquidity",
+        "score": round(liquidity_score, 1),
+        "weight": 10,
+        "grade": _grade(liquidity_score),
+        "detail": f"{liquid_assets} liquid, {illiquid_assets} illiquid positions",
+    })
+
+    # ── Overall Score ────────────────────────────────────────────────────
+    overall = sum(c["score"] * c["weight"] / 100 for c in components)
+    overall = round(overall, 1)
+
+    return {
+        "score": overall,
+        "grade": _grade(overall),
+        "grade_color": _grade_color(_grade(overall)),
+        "components": components,
+        "tips": tips if tips else ["✅ Your portfolio health looks great! Keep monitoring regularly."],
+        "position_count": len(holdings),
+        "total_value": round(total_value, 2),
+    }

backend/app/services/analytics/portfolio_dna.py

@@ -0,0 +1,246 @@
+"""
+Portfolio DNA Fingerprint Engine.
+
+Computes a 6-dimension portfolio fingerprint and compares against
+famous portfolios of legendary investors:
+
+Dimensions:
+1. Momentum — trend-following tendency
+2. Value — valuation discipline
+3. Volatility — risk tolerance
+4. Regime Sensitivity — macro beta
+5. Concentration — conviction level
+6. Hedge Coverage — defensive posture
+
+Famous benchmarks:
+- Warren Buffett — deep value, concentrated, low turnover
+- Ray Dalio — risk parity, all-weather, maximum diversification
+- Cathie Wood — high momentum growth, concentrated, volatile
+- Renaissance Technologies — market-neutral, low vol, maximum hedge
+- Bridgewater Pure Alpha — macro, balanced, regime-aware
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from app.config import get_settings
+from app.services.data_ingestion.yahoo import yahoo_adapter
+
+logger = logging.getLogger(__name__)
+
+_settings = get_settings()
+TRADING_DAYS = _settings.trading_days_per_year
+
+
+# ── Famous Portfolio DNA Profiles (0-100 per dimension) ──────────────────
+
+FAMOUS_PORTFOLIOS = {
+    "buffett": {
+        "name": "Warren Buffett",
+        "description": "Value investing with deep moats, concentrated bets",
+        "style": "Deep Value + Quality",
+        "dna": {
+            "momentum": 30,
+            "value": 95,
+            "volatility": 35,
+            "regime_sensitivity": 40,
+            "concentration": 80,
+            "hedge_coverage": 15,
+        },
+    },
+    "dalio": {
+        "name": "Ray Dalio",
+        "description": "All-Weather risk parity, maximum diversification",
+        "style": "Risk Parity + Macro",
+        "dna": {
+            "momentum": 50,
+            "value": 60,
+            "volatility": 20,
+            "regime_sensitivity": 70,
+            "concentration": 15,
+            "hedge_coverage": 85,
+        },
+    },
+    "wood": {
+        "name": "Cathie Wood (ARK)",
+        "description": "Disruptive innovation, high conviction growth",
+        "style": "Growth Momentum",
+        "dna": {
+            "momentum": 90,
+            "value": 10,
+            "volatility": 85,
+            "regime_sensitivity": 75,
+            "concentration": 70,
+            "hedge_coverage": 5,
+        },
+    },
+    "renaissance": {
+        "name": "Renaissance Technologies",
+        "description": "Quantitative market-neutral, Medallion Fund",
+        "style": "Quantitative Market-Neutral",
+        "dna": {
+            "momentum": 60,
+            "value": 50,
+            "volatility": 10,
+            "regime_sensitivity": 15,
+            "concentration": 5,
+            "hedge_coverage": 95,
+        },
+    },
+    "bridgewater": {
+        "name": "Bridgewater Pure Alpha",
+        "description": "Macro alpha from global diversification",
+        "style": "Global Macro",
+        "dna": {
+            "momentum": 55,
+            "value": 55,
+            "volatility": 40,
+            "regime_sensitivity": 90,
+            "concentration": 20,
+            "hedge_coverage": 70,
+        },
+    },
+}
+
+
+def _cosine_similarity(a: List[float], b: List[float]) -> float:
+    """Compute cosine similarity between two vectors."""
+    a_arr = np.array(a, dtype=float)
+    b_arr = np.array(b, dtype=float)
+    dot = np.dot(a_arr, b_arr)
+    norm_a = np.linalg.norm(a_arr)
+    norm_b = np.linalg.norm(b_arr)
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return float(dot / (norm_a * norm_b))
+
+
+async def compute_portfolio_dna(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+) -> Dict[str, Any]:
+    """
+    Compute the 6-dimension DNA fingerprint for user's portfolio.
+
+    Returns DNA profile, famous portfolio similarities, and closest match.
+    """
+    if not holdings or total_value <= 0:
+        return {"error": "No valid holdings for DNA analysis"}
+
+    n = len(holdings)
+    tickers = list(set(h.get("ticker", "") for h in holdings if h.get("market_value", 0) > 0))
+
+    # Fetch returns for momentum/vol computation
+    returns_data = {}
+    for ticker in tickers:
+        try:
+            df = await yahoo_adapter.get_price_dataframe(ticker, period="1y")
+            if not df.empty and len(df) > 20:
+                returns_data[ticker] = df["Close"].pct_change().dropna()
+        except Exception:
+            continue
+
+    # ── 1. Momentum Score ────────────────────────────────────────────────
+    momentum_scores = []
+    for h in holdings:
+        pnl_pct = h.get("pnl_pct", 0)
+        momentum_scores.append(abs(pnl_pct) if pnl_pct > 0 else 0)
+
+    avg_momentum = np.mean(momentum_scores) if momentum_scores else 0
+    # Scale: 0% = 0 score, 50% = 90 score
+    momentum = min(100, avg_momentum * 1.8)
+
+    # ── 2. Value Score ──────────���────────────────────────────────────────
+    # Heuristic: positions bought below current price (positive P&L from appreciation)
+    value_positions = sum(1 for h in holdings if h.get("pnl_pct", 0) < 5)  # held despite small/neg gains
+    value = min(100, (value_positions / max(n, 1)) * 100)
+
+    # ── 3. Volatility Score ──────────────────────────────────────────────
+    if returns_data:
+        aligned = pd.DataFrame(returns_data).dropna()
+        if not aligned.empty:
+            weights = np.array([
+                sum(h.get("market_value", 0) for h in holdings if h.get("ticker") == t)
+                for t in aligned.columns
+            ])
+            weights = weights / max(weights.sum(), 1)
+            port_returns = aligned.values @ weights
+            vol = float(np.std(port_returns, ddof=1) * np.sqrt(TRADING_DAYS))
+            # Scale: 5% vol = 10, 15% = 40, 30% = 80, 50% = 100
+            volatility = min(100, vol * 100 * 2)
+        else:
+            volatility = 50
+    else:
+        volatility = 50
+
+    # ── 4. Regime Sensitivity ────────────────────────────────────────────
+    # Beta-weighted exposure to market
+    short_count = sum(1 for h in holdings if h.get("position_type") == "short")
+    defensive = sum(1 for h in holdings if h.get("asset_class") in ("fixed_income", "commodity"))
+    regime_exp = (1 - (short_count + defensive) / max(n, 1)) * 80
+    regime_sensitivity = min(100, regime_exp)
+
+    # ── 5. Concentration Score ───────────────────────────────────────────
+    weights_lst = sorted([h.get("weight", 0) for h in holdings], reverse=True)
+    top3_weight = sum(weights_lst[:3])
+    # Top 3 = 100% => concentration = 100, Top 3 = 30% => 30
+    concentration = min(100, top3_weight)
+
+    # ── 6. Hedge Coverage ────────────────────────────────────────────────
+    hedges = sum(1 for h in holdings if h.get("position_type") == "short" or
+                 h.get("asset_class") in ("fixed_income", "commodity", "forex"))
+    hedge_coverage = min(100, (hedges / max(n, 1)) * 100 * 3)
+
+    # ── Build DNA Profile ────────────────────────────────────────────────
+    dna = {
+        "momentum": round(momentum, 1),
+        "value": round(value, 1),
+        "volatility": round(volatility, 1),
+        "regime_sensitivity": round(regime_sensitivity, 1),
+        "concentration": round(concentration, 1),
+        "hedge_coverage": round(hedge_coverage, 1),
+    }
+
+    # ── Compare with Famous Portfolios ───────────────────────────────────
+    user_vector = [dna[k] for k in sorted(dna.keys())]
+    comparisons = []
+
+    for fp_id, fp in FAMOUS_PORTFOLIOS.items():
+        fp_vector = [fp["dna"][k] for k in sorted(fp["dna"].keys())]
+        similarity = _cosine_similarity(user_vector, fp_vector) * 100
+        comparisons.append({
+            "id": fp_id,
+            "name": fp["name"],
+            "description": fp["description"],
+            "style": fp["style"],
+            "similarity": round(similarity, 1),
+            "dna": fp["dna"],
+        })
+
+    comparisons.sort(key=lambda x: x["similarity"], reverse=True)
+    closest = comparisons[0] if comparisons else None
+
+    # Determine user's investing style
+    dominant = max(dna, key=dna.get)  # type: ignore
+    style_map = {
+        "momentum": "Growth/Momentum Investor",
+        "value": "Value Investor",
+        "volatility": "Aggressive/Speculative",
+        "regime_sensitivity": "Macro-Sensitive",
+        "concentration": "High-Conviction",
+        "hedge_coverage": "Risk-Managed/Balanced",
+    }
+
+    return {
+        "dna": dna,
+        "style": style_map.get(dominant, "Balanced"),
+        "dominant_trait": dominant,
+        "closest_match": closest,
+        "comparisons": comparisons,
+        "position_count": n,
+    }

backend/app/services/backtest/engine.py

@@ -19,11 +19,16 @@ from typing import Any, Dict, List, Optional
 import numpy as np
 import pandas as pd
 
+from app.config import get_settings
 from app.services.data_ingestion.yahoo import yahoo_adapter
 from app.services.feature_engineering.pipeline import feature_pipeline
 
 logger = logging.getLogger(__name__)
 
+_settings = get_settings()
+RISK_FREE_RATE = _settings.risk_free_rate
+TRADING_DAYS = _settings.trading_days_per_year
+
 
 class BacktestEngine:
     """Event-driven portfolio backtester."""
@@ -263,11 +268,13 @@ class BacktestEngine:
         # Monthly returns
         monthly_returns = self._compute_monthly_returns(equity_curve)
 
-        # Drawdown series
+        # Drawdown series — O(n) running peak
+        running_peak = 0.0
         for point in equity_curve:
-            idx = equity_curve.index(point)
-            peak = max(p["portfolio_value"] for p in equity_curve[: idx + 1])
-            point["drawdown"] = round((point["portfolio_value"] - peak) / peak, 6) if peak > 0 else 0
+            running_peak = max(running_peak, point["portfolio_value"])
+            point["drawdown"] = round(
+                (point["portfolio_value"] - running_peak) / running_peak, 6
+            ) if running_peak > 0 else 0
 
         return {
             "status": "completed",
@@ -371,17 +378,17 @@ class BacktestEngine:
         returns = np.array(daily_returns)
         final = equity_values[-1]
         n_days = len(returns)
-        n_years = n_days / 252
+        n_years = n_days / TRADING_DAYS
 
         total_return = (final / initial_capital - 1)
         ann_return = (1 + total_return) ** (1 / n_years) - 1 if n_years > 0 else 0
-        ann_vol = float(np.std(returns, ddof=1) * np.sqrt(252)) if len(returns) > 1 else 0
-        sharpe = (ann_return - 0.04) / ann_vol if ann_vol > 0 else 0
+        ann_vol = float(np.std(returns, ddof=1) * np.sqrt(TRADING_DAYS)) if len(returns) > 1 else 0
+        sharpe = (ann_return - RISK_FREE_RATE) / ann_vol if ann_vol > 0 else 0
 
         # Sortino
         downside = returns[returns < 0]
-        down_dev = float(np.std(downside, ddof=1) * np.sqrt(252)) if len(downside) > 1 else ann_vol
-        sortino = (ann_return - 0.04) / down_dev if down_dev > 0 else 0
+        down_dev = float(np.std(downside, ddof=1) * np.sqrt(TRADING_DAYS)) if len(downside) > 1 else ann_vol
+        sortino = (ann_return - RISK_FREE_RATE) / down_dev if down_dev > 0 else 0
 
         # Max drawdown
         cum = np.cumprod(1 + returns)
@@ -429,7 +436,7 @@ class BacktestEngine:
                 cov_rb = np.cov(r, b)[0, 1]
                 var_b = np.var(b, ddof=1)
                 beta = cov_rb / var_b if var_b > 0 else 1.0
-                alpha = ann_return - beta * float(np.mean(b) * 252)
+                alpha = ann_return - beta * float(np.mean(b) * TRADING_DAYS)
                 metrics["beta"] = round(float(beta), 4)
                 metrics["alpha"] = round(float(alpha), 4)
 

backend/app/services/portfolio/engine.py

@@ -3,12 +3,13 @@ Portfolio Construction Engine.
 
 Supports multiple portfolio optimization methods:
 - Equal Weight
-- Risk Parity (inverse volatility)
+- Inverse Volatility (simplified risk parity)
 - Mean-Variance Optimization (Markowitz)
 - Minimum Variance
 - Maximum Sharpe Ratio
 
-Includes sector exposure constraints and position limits.
+Includes Ledoit-Wolf covariance shrinkage, sector exposure constraints,
+and position limits.
 """
 
 from __future__ import annotations
@@ -20,10 +21,27 @@ import numpy as np
 import pandas as pd
 from scipy.optimize import minimize
 
+from app.config import get_settings
 from app.services.data_ingestion.yahoo import yahoo_adapter
 
 logger = logging.getLogger(__name__)
 
+_settings = get_settings()
+RISK_FREE_RATE = _settings.risk_free_rate
+TRADING_DAYS = _settings.trading_days_per_year
+
+
+def _shrink_covariance(returns_df: pd.DataFrame) -> pd.DataFrame:
+    """Apply Ledoit-Wolf shrinkage to the sample covariance matrix."""
+    try:
+        from sklearn.covariance import LedoitWolf
+        lw = LedoitWolf().fit(returns_df.values)
+        cov_shrunk = lw.covariance_ * TRADING_DAYS  # annualize
+        return pd.DataFrame(cov_shrunk, index=returns_df.columns, columns=returns_df.columns)
+    except Exception:
+        # Fallback to sample covariance
+        return returns_df.cov() * TRADING_DAYS
+
 
 class PortfolioEngine:
     """Portfolio construction and optimization engine."""
@@ -33,7 +51,7 @@ class PortfolioEngine:
         tickers: List[str],
         method: str = "mean_variance",
         period: str = "2y",
-        risk_free_rate: float = 0.04,
+        risk_free_rate: float = RISK_FREE_RATE,
         constraints: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         """
@@ -65,17 +83,18 @@ class PortfolioEngine:
                 "method": "equal_weight",
             }
 
-        # 2. Compute expected returns and covariance
-        mean_returns = returns_df.mean() * 252  # Annualized
-        cov_matrix = returns_df.cov() * 252  # Annualized
+        # 2. Compute expected returns and covariance (with Ledoit-Wolf shrinkage)
+        mean_returns = returns_df.mean() * TRADING_DAYS  # Annualized
+        cov_matrix = _shrink_covariance(returns_df)
 
         # 3. Optimize
         max_weight = (constraints or {}).get("max_weight", 0.4)
 
-        if method == "equal_weight":
+        # Support both old name "risk_parity" and new name "inverse_volatility"
+        if method in ("risk_parity", "inverse_volatility"):
+            weights = self._inverse_volatility(returns_df, tickers)
+        elif method == "equal_weight":
             weights = self._equal_weight(tickers)
-        elif method == "risk_parity":
-            weights = self._risk_parity(returns_df, tickers)
         elif method == "min_variance":
             weights = self._min_variance(mean_returns, cov_matrix, tickers, max_weight)
         elif method == "max_sharpe":
@@ -126,9 +145,9 @@ class PortfolioEngine:
         return {t: w for t in tickers}
 
     @staticmethod
-    def _risk_parity(returns_df: pd.DataFrame, tickers: List[str]) -> Dict[str, float]:
-        """Inverse volatility (simplified risk parity)."""
-        vols = returns_df.std() * np.sqrt(252)
+    def _inverse_volatility(returns_df: pd.DataFrame, tickers: List[str]) -> Dict[str, float]:
+        """Inverse volatility weighting (simplified risk parity)."""
+        vols = returns_df.std() * np.sqrt(TRADING_DAYS)
         inv_vols = 1.0 / vols.replace(0, np.nan)
         inv_vols = inv_vols.fillna(0)
         total = inv_vols.sum()
@@ -137,6 +156,9 @@ class PortfolioEngine:
         weights = inv_vols / total
         return {t: float(weights.get(t, 0)) for t in tickers}
 
+    # Keep old name as alias for backward compatibility
+    _risk_parity = _inverse_volatility
+
     @staticmethod
     def _min_variance(
         mean_returns: pd.Series,
@@ -226,9 +248,9 @@ class PortfolioEngine:
         bench_df = await yahoo_adapter.get_price_dataframe(benchmark, period=period)
         bench_returns = bench_df["Close"].pct_change().dropna().values if not bench_df.empty else None
 
-        mean_ret = float(np.mean(portfolio_returns) * 252)
-        vol = float(np.std(portfolio_returns) * np.sqrt(252))
-        sharpe = mean_ret / vol if vol > 0 else 0.0
+        mean_ret = float(np.mean(portfolio_returns) * TRADING_DAYS)
+        vol = float(np.std(portfolio_returns, ddof=1) * np.sqrt(TRADING_DAYS))
+        sharpe = (mean_ret - RISK_FREE_RATE) / vol if vol > 0 else 0.0
 
         # Drawdown
         cum_returns = np.cumprod(1 + portfolio_returns)
@@ -251,9 +273,9 @@ class PortfolioEngine:
                 pr = portfolio_returns[:min_len]
                 br = bench_returns[:min_len]
                 cov_pb = np.cov(pr, br)[0, 1]
-                var_b = np.var(br)
+                var_b = np.var(br, ddof=1)
                 beta = cov_pb / var_b if var_b > 0 else 1.0
-                alpha = mean_ret - beta * float(np.mean(br) * 252)
+                alpha = mean_ret - beta * float(np.mean(br) * TRADING_DAYS)
                 analytics["beta"] = round(float(beta), 4)
                 analytics["alpha"] = round(float(alpha), 4)
 

backend/app/services/risk/crisis_replay.py

@@ -0,0 +1,267 @@
+"""
+Historical Crisis Replay Engine.
+
+Replays actual daily sector ETF returns from 6 major crises against user holdings:
+- COVID-19 Crash (Feb–Mar 2020)
+- 2022 Rate Hike Crash (Jan–Jun 2022)
+- Dot-Com Burst (Mar–Oct 2000)
+- 2008 Financial Crisis (Sep–Nov 2008)
+- Flash Crash (May 6, 2010)
+- China/Greece Selloff (Aug 2015)
+
+For each crisis, fetches actual daily returns from sector ETFs and maps
+user holdings to sectors to simulate day-by-day equity curve impact.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from app.services.data_ingestion.yahoo import yahoo_adapter
+
+logger = logging.getLogger(__name__)
+
+
+# ── Crisis Definitions ───────────────────────────────────────────────────
+
+CRISES = {
+    "covid_2020": {
+        "name": "COVID-19 Crash",
+        "description": "Pandemic-driven global market collapse — fastest bear market in history",
+        "start": "2020-02-19",
+        "end": "2020-03-23",
+        "peak_decline": -33.9,
+        "recovery_date": "2020-08-18",
+    },
+    "rate_hike_2022": {
+        "name": "2022 Rate Hike Crash",
+        "description": "Fed aggressive tightening — tech-led growth selloff",
+        "start": "2022-01-03",
+        "end": "2022-06-16",
+        "peak_decline": -23.6,
+        "recovery_date": "2024-01-19",
+    },
+    "dotcom_2000": {
+        "name": "Dot-Com Burst",
+        "description": "Technology bubble burst — NASDAQ lost 78% peak to trough",
+        "start": "2000-03-10",
+        "end": "2000-10-09",
+        "peak_decline": -39.3,
+        "recovery_date": None,
+    },
+    "gfc_2008": {
+        "name": "2008 Financial Crisis",
+        "description": "Subprime mortgage collapse — global financial system nearly failed",
+        "start": "2008-09-15",
+        "end": "2008-11-20",
+        "peak_decline": -46.1,
+        "recovery_date": "2013-03-14",
+    },
+    "flash_crash_2010": {
+        "name": "2010 Flash Crash",
+        "description": "Algorithmic trading cascade — Dow Jones dropped 1000 points in minutes",
+        "start": "2010-05-06",
+        "end": "2010-05-25",
+        "peak_decline": -12.4,
+        "recovery_date": "2010-06-21",
+    },
+    "china_2015": {
+        "name": "China/Greece Selloff 2015",
+        "description": "Chinese stock market crash + Greek debt crisis contagion",
+        "start": "2015-08-18",
+        "end": "2015-08-25",
+        "peak_decline": -11.2,
+        "recovery_date": "2015-11-03",
+    },
+}
+
+# Sector ETF mapping for replay
+SECTOR_ETFS = {
+    "Technology": "XLK",
+    "Financial": "XLF",
+    "Healthcare": "XLV",
+    "Consumer Discretionary": "XLY",
+    "Consumer Staples": "XLP",
+    "Energy": "XLE",
+    "Industrials": "XLI",
+    "Materials": "XLB",
+    "Real Estate": "XLRE",
+    "Utilities": "XLU",
+    "Communication Services": "XLC",
+    "equity": "SPY",  # default
+    "etf": "SPY",
+    "crypto": "SPY",  # approximate
+    "default": "SPY",
+}
+
+
+async def replay_crisis(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+    crisis_id: str,
+) -> Dict[str, Any]:
+    """
+    Replay a historical crisis against user holdings.
+
+    Fetches actual daily returns from the crisis period for each sector,
+    maps user holdings to sectors, and simulates the day-by-day impact.
+    """
+    if crisis_id not in CRISES:
+        return {"error": f"Unknown crisis: {crisis_id}. Available: {list(CRISES.keys())}"}
+
+    if not holdings or total_value <= 0:
+        return {"error": "No valid holdings for crisis replay"}
+
+    crisis = CRISES[crisis_id]
+
+    # Map holdings to sectors and determine sector ETFs
+    sector_weights: Dict[str, float] = {}
+    for h in holdings:
+        sector = h.get("sector", h.get("asset_class", "equity"))
+        w = h.get("market_value", 0) / total_value
+        sector_weights[sector] = sector_weights.get(sector, 0) + w
+
+    # Fetch actual crisis period returns for each needed sector ETF
+    sector_etf_returns: Dict[str, pd.Series] = {}
+    needed_etfs = set()
+
+    for sector in sector_weights:
+        etf = SECTOR_ETFS.get(sector, SECTOR_ETFS["default"])
+        needed_etfs.add(etf)
+
+    for etf in needed_etfs:
+        try:
+            period = "max" if crisis["start"] < "2015-01-01" else "10y"
+            df = await yahoo_adapter.get_price_dataframe(etf, period=period)
+            if df.empty:
+                continue
+            df.index = pd.to_datetime(df.index)
+            mask = (df.index >= crisis["start"]) & (df.index <= crisis["end"])
+            crisis_data = df.loc[mask, "Close"]
+            if not crisis_data.empty:
+                sector_etf_returns[etf] = crisis_data.pct_change().dropna()
+        except Exception as e:
+            logger.warning("Failed to fetch %s for crisis replay: %s", etf, e)
+
+    # Fallback: use SPY if we couldn't get sector-specific data
+    spy_returns = sector_etf_returns.get("SPY")
+    if spy_returns is None or spy_returns.empty:
+        # Try fetching SPY directly
+        try:
+            df = await yahoo_adapter.get_price_dataframe("SPY", period="max")
+            df.index = pd.to_datetime(df.index)
+            mask = (df.index >= crisis["start"]) & (df.index <= crisis["end"])
+            spy_data = df.loc[mask, "Close"]
+            if not spy_data.empty:
+                spy_returns = spy_data.pct_change().dropna()
+                sector_etf_returns["SPY"] = spy_returns
+        except Exception:
+            pass
+
+    if not sector_etf_returns:
+        return {"error": "Could not fetch crisis period data"}
+
+    # Build daily portfolio returns
+    # For each trading day in the crisis, compute weighted portfolio return
+    # from sector ETF returns
+    all_dates = set()
+    for returns_series in sector_etf_returns.values():
+        all_dates.update(returns_series.index.tolist())
+    dates_sorted = sorted(all_dates)
+
+    equity_curve = []
+    portfolio_val = total_value
+    cumulative_return = 1.0
+
+    for dt in dates_sorted:
+        daily_return = 0.0
+        for sector, weight in sector_weights.items():
+            etf = SECTOR_ETFS.get(sector, "SPY")
+            returns_series = sector_etf_returns.get(etf)
+            if returns_series is not None and dt in returns_series.index:
+                daily_return += weight * float(returns_series.loc[dt])
+            elif spy_returns is not None and dt in spy_returns.index:
+                daily_return += weight * float(spy_returns.loc[dt])
+
+        cumulative_return *= (1 + daily_return)
+        portfolio_val = total_value * cumulative_return
+
+        equity_curve.append({
+            "date": dt.strftime("%Y-%m-%d"),
+            "portfolio_value": round(portfolio_val, 2),
+            "daily_return": round(daily_return * 100, 2),
+            "cumulative_return": round((cumulative_return - 1) * 100, 2),
+        })
+
+    total_pnl = portfolio_val - total_value
+    total_pnl_pct = (cumulative_return - 1) * 100
+    min_value = min(p["portfolio_value"] for p in equity_curve) if equity_curve else total_value
+    max_drawdown = ((min_value - total_value) / total_value) * 100
+
+    # Per-holding impact (using final cumulative return per sector)
+    holding_impacts = []
+    for h in holdings:
+        sector = h.get("sector", h.get("asset_class", "equity"))
+        etf = SECTOR_ETFS.get(sector, "SPY")
+        # Overall sector return during crisis
+        returns_series = sector_etf_returns.get(etf)
+        if returns_series is not None and len(returns_series) > 0:
+            sector_total_return = float((1 + returns_series).prod() - 1)
+        elif spy_returns is not None:
+            sector_total_return = float((1 + spy_returns).prod() - 1)
+        else:
+            sector_total_return = 0
+
+        mv = h.get("market_value", 0)
+        impact = mv * sector_total_return
+
+        holding_impacts.append({
+            "ticker": h.get("ticker", ""),
+            "sector": sector,
+            "market_value": round(mv, 2),
+            "sector_return": round(sector_total_return * 100, 2),
+            "impact": round(impact, 2),
+        })
+
+    holding_impacts.sort(key=lambda x: x["impact"])
+
+    return {
+        "crisis": crisis,
+        "portfolio_value": round(total_value, 2),
+        "final_value": round(portfolio_val, 2),
+        "total_pnl": round(total_pnl, 2),
+        "total_pnl_pct": round(total_pnl_pct, 2),
+        "max_drawdown_pct": round(max_drawdown, 2),
+        "trading_days": len(equity_curve),
+        "equity_curve": equity_curve,
+        "holding_impacts": holding_impacts,
+    }
+
+
+async def replay_all_crises(
+    holdings: List[Dict[str, Any]],
+    total_value: float,
+) -> Dict[str, Any]:
+    """Replay all crises and return summary comparison."""
+    results = []
+    for crisis_id in CRISES:
+        try:
+            result = await replay_crisis(holdings, total_value, crisis_id)
+            if "error" not in result:
+                results.append({
+                    "crisis_id": crisis_id,
+                    "name": CRISES[crisis_id]["name"],
+                    "total_pnl": result["total_pnl"],
+                    "total_pnl_pct": result["total_pnl_pct"],
+                    "max_drawdown_pct": result["max_drawdown_pct"],
+                    "trading_days": result["trading_days"],
+                })
+        except Exception as e:
+            logger.warning("Crisis replay failed for %s: %s", crisis_id, e)
+
+    results.sort(key=lambda x: x["total_pnl"])
+    return {"crises": results, "available": list(CRISES.keys())}

backend/app/services/risk/monte_carlo.py

@@ -0,0 +1,169 @@
+"""
+Monte Carlo VaR Engine.
+
+Runs Cholesky-decomposed correlated multi-asset simulations:
+- 10,000 path default
+- Fan chart percentiles (5th/25th/50th/75th/95th)
+- Regime-conditioned simulation using HMM states
+- Value-at-Risk (VaR) and Conditional VaR (CVaR) at multiple confidence levels
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+from app.config import get_settings
+from app.services.data_ingestion.yahoo import yahoo_adapter
+
+logger = logging.getLogger(__name__)
+
+_settings = get_settings()
+TRADING_DAYS = _settings.trading_days_per_year
+
+
+async def run_monte_carlo(
+    holdings: List[Dict[str, Any]],
+    horizon_days: int = 60,
+    n_simulations: int = 10000,
+    regime_conditioned: bool = False,
+) -> Dict[str, Any]:
+    """
+    Run Monte Carlo simulation for portfolio holdings.
+
+    Args:
+        holdings: List of holding dicts with ticker, market_value
+        horizon_days: Simulation horizon in trading days
+        n_simulations: Number of paths to simulate
+        regime_conditioned: Apply HMM regime conditioning
+
+    Returns:
+        Fan chart data, VaR, CVaR, and simulation statistics.
+    """
+    tickers = list(set(h.get("ticker", "") for h in holdings if h.get("market_value", 0) > 0))
+    weights_map = {}
+    total_value = sum(h.get("market_value", 0) for h in holdings)
+
+    if total_value <= 0 or not tickers:
+        return {"error": "No valid holdings for simulation"}
+
+    for h in holdings:
+        t = h.get("ticker", "")
+        w = h.get("market_value", 0) / total_value
+        weights_map[t] = weights_map.get(t, 0) + w
+
+    # 1. Fetch historical returns (1 year)
+    returns_data = {}
+    for ticker in tickers:
+        try:
+            df = await yahoo_adapter.get_price_dataframe(ticker, period="1y")
+            if not df.empty and len(df) > 30:
+                returns_data[ticker] = df["Close"].pct_change().dropna()
+        except Exception:
+            continue
+
+    if len(returns_data) < 1:
+        return {"error": "Insufficient price data for simulation"}
+
+    # Build aligned returns matrix
+    returns_df = pd.DataFrame(returns_data).dropna()
+    if returns_df.empty or len(returns_df) < 30:
+        return {"error": "Insufficient overlapping data"}
+
+    used_tickers = list(returns_df.columns)
+    weights = np.array([weights_map.get(t, 0) for t in used_tickers])
+    weights = weights / weights.sum()  # normalize
+
+    # 2. Estimate parameters
+    mu = returns_df.mean().values  # daily mean returns
+    cov = returns_df.cov().values  # daily covariance
+
+    # Regime conditioning: adjust mu/cov based on current regime
+    if regime_conditioned:
+        try:
+            from app.services.ml.hmm_regime import detect_regime
+            regime_data = await detect_regime("SPY", period="2y", history_days=60)
+            current_regime = regime_data.get("current_regime", "normal")
+
+            if current_regime == "bear":
+                mu = mu * 0.5  # Reduce expected returns
+                cov = cov * 1.8  # Increase volatility
+            elif current_regime == "high_volatility":
+                cov = cov * 2.2
+            elif current_regime == "bull":
+                mu = mu * 1.2
+                cov = cov * 0.8
+        except Exception:
+            pass  # Use unconditional parameters
+
+    # 3. Cholesky decomposition for correlated random draws
+    try:
+        L = np.linalg.cholesky(cov)
+    except np.linalg.LinAlgError:
+        # Add small regularization if covariance isn't positive semi-definite
+        cov += np.eye(len(used_tickers)) * 1e-8
+        L = np.linalg.cholesky(cov)
+
+    # 4. Simulate paths
+    np.random.seed(42)  # reproducibility
+    portfolio_paths = np.zeros((n_simulations, horizon_days + 1))
+    portfolio_paths[:, 0] = total_value
+
+    for sim in range(n_simulations):
+        cumulative_return = 1.0
+        for day in range(horizon_days):
+            z = np.random.standard_normal(len(used_tickers))
+            correlated_returns = mu + L @ z
+            # Portfolio return = weighted sum of asset returns
+            port_return = np.dot(weights, correlated_returns)
+            cumulative_return *= (1 + port_return)
+            portfolio_paths[sim, day + 1] = total_value * cumulative_return
+
+    # 5. Compute statistics
+    final_values = portfolio_paths[:, -1]
+    pnl = final_values - total_value
+    pnl_pct = pnl / total_value
+
+    # Fan chart percentiles
+    percentiles = [5, 25, 50, 75, 95]
+    fan_chart = {}
+    for p in percentiles:
+        fan_chart[f"p{p}"] = [
+            round(float(np.percentile(portfolio_paths[:, d], p)), 2)
+            for d in range(horizon_days + 1)
+        ]
+
+    # VaR and CVaR at multiple confidence levels
+    var_levels = {}
+    for conf in [0.90, 0.95, 0.99]:
+        q = np.percentile(pnl, (1 - conf) * 100)
+        cvar = float(np.mean(pnl[pnl <= q]))
+        var_levels[f"{int(conf*100)}%"] = {
+            "var": round(float(-q), 2),
+            "var_pct": round(float(-q / total_value * 100), 2),
+            "cvar": round(float(-cvar), 2),
+            "cvar_pct": round(float(-cvar / total_value * 100), 2),
+        }
+
+    return {
+        "portfolio_value": round(total_value, 2),
+        "horizon_days": horizon_days,
+        "n_simulations": n_simulations,
+        "regime_conditioned": regime_conditioned,
+        "fan_chart": fan_chart,
+        "days": list(range(horizon_days + 1)),
+        "var": var_levels,
+        "statistics": {
+            "mean_final_value": round(float(np.mean(final_values)), 2),
+            "median_final_value": round(float(np.median(final_values)), 2),
+            "std_final_value": round(float(np.std(final_values)), 2),
+            "mean_pnl": round(float(np.mean(pnl)), 2),
+            "mean_pnl_pct": round(float(np.mean(pnl_pct) * 100), 2),
+            "prob_loss": round(float(np.mean(pnl < 0) * 100), 2),
+            "worst_case": round(float(np.min(final_values)), 2),
+            "best_case": round(float(np.max(final_values)), 2),
+        },
+    }

backend/app/services/risk/options_calculator.py

@@ -1,9 +1,12 @@
 """
 Options Hedge Calculator.
 
-Black-Scholes pricing for protective puts, collars, and covered calls.
+Black-Scholes pricing with full Greeks (Delta, Gamma, Theta, Vega, Rho)
+for protective puts, collars, and covered calls.
 Given any position, recommends optimal strike prices and calculates
 the cost of hedge as a percentage of position value.
+
+Supports implied volatility back-solving via Newton's method.
 """
 
 from __future__ import annotations
@@ -12,20 +15,117 @@ import math
 import logging
 from typing import Any, Dict, List, Optional
 
+from app.config import get_settings
+
 logger = logging.getLogger(__name__)
 
+_settings = get_settings()
+RISK_FREE_RATE = _settings.risk_free_rate
+TRADING_DAYS = _settings.trading_days_per_year
+
 
 def _norm_cdf(x: float) -> float:
     """Standard normal cumulative distribution function."""
     return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
 
 
+def _norm_pdf(x: float) -> float:
+    """Standard normal probability density function."""
+    return math.exp(-0.5 * x * x) / math.sqrt(2.0 * math.pi)
+
+
+def _bs_d1_d2(S: float, K: float, T: float, r: float, sigma: float):
+    """Compute Black-Scholes d1 and d2."""
+    d1 = (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * math.sqrt(T))
+    d2 = d1 - sigma * math.sqrt(T)
+    return d1, d2
+
+
+# ── Greeks ───────────────────────────────────────────────────────────────
+
+def compute_greeks(
+    S: float, K: float, T: float, r: float, sigma: float, option_type: str = "call"
+) -> Dict[str, float]:
+    """
+    Compute all Black-Scholes Greeks for a European option.
+
+    Returns: delta, gamma, theta, vega, rho
+    """
+    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
+        return {"delta": 0, "gamma": 0, "theta": 0, "vega": 0, "rho": 0}
+
+    d1, d2 = _bs_d1_d2(S, K, T, r, sigma)
+    sqrt_T = math.sqrt(T)
+
+    # Gamma and Vega are the same for calls and puts
+    gamma = _norm_pdf(d1) / (S * sigma * sqrt_T)
+    vega = S * _norm_pdf(d1) * sqrt_T / 100  # per 1% vol move
+
+    if option_type == "call":
+        delta = _norm_cdf(d1)
+        theta = (
+            -S * _norm_pdf(d1) * sigma / (2 * sqrt_T)
+            - r * K * math.exp(-r * T) * _norm_cdf(d2)
+        ) / TRADING_DAYS  # daily theta
+        rho = K * T * math.exp(-r * T) * _norm_cdf(d2) / 100  # per 1% rate move
+    else:  # put
+        delta = _norm_cdf(d1) - 1
+        theta = (
+            -S * _norm_pdf(d1) * sigma / (2 * sqrt_T)
+            + r * K * math.exp(-r * T) * _norm_cdf(-d2)
+        ) / TRADING_DAYS
+        rho = -K * T * math.exp(-r * T) * _norm_cdf(-d2) / 100
+
+    return {
+        "delta": round(delta, 4),
+        "gamma": round(gamma, 6),
+        "theta": round(theta, 4),
+        "vega": round(vega, 4),
+        "rho": round(rho, 4),
+    }
+
+
+# ── Implied Volatility (Newton's Method) ─────────────────────────────────
+
+def implied_volatility(
+    market_price: float, S: float, K: float, T: float, r: float,
+    option_type: str = "call", max_iter: int = 100, tol: float = 1e-6
+) -> float:
+    """
+    Back-solve implied volatility from market option price using Newton's method.
+    Returns annualized IV as decimal.
+    """
+    if market_price <= 0 or T <= 0 or S <= 0 or K <= 0:
+        return 0.0
+
+    sigma = 0.25  # initial guess
+    for _ in range(max_iter):
+        if option_type == "call":
+            price = black_scholes_call(S, K, T, r, sigma)
+        else:
+            price = black_scholes_put(S, K, T, r, sigma)
+
+        diff = price - market_price
+        if abs(diff) < tol:
+            return sigma
+
+        # Vega for Newton step
+        d1, _ = _bs_d1_d2(S, K, T, r, sigma)
+        vega = S * _norm_pdf(d1) * math.sqrt(T)
+        if vega < 1e-12:
+            break
+
+        sigma -= diff / vega
+        sigma = max(0.001, min(sigma, 5.0))  # clamp
+
+    return sigma
+
+
 def black_scholes_put(S: float, K: float, T: float, r: float, sigma: float) -> float:
     """Price a European put option using Black-Scholes."""
     if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
         return 0.0
-    d1 = (math.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * math.sqrt(T))
-    d2 = d1 - sigma * math.sqrt(T)
+    d1, d2 = _bs_d1_d2(S, K, T, r, sigma)
     return K * math.exp(-r * T) * _norm_cdf(-d2) - S * _norm_cdf(-d1)
 
 
@@ -33,42 +133,172 @@ def black_scholes_call(S: float, K: float, T: float, r: float, sigma: float) ->
     """Price a European call option using Black-Scholes."""
     if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
         return 0.0
-    d1 = (math.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * math.sqrt(T))
-    d2 = d1 - sigma * math.sqrt(T)
+    d1, d2 = _bs_d1_d2(S, K, T, r, sigma)
     return S * _norm_cdf(d1) - K * math.exp(-r * T) * _norm_cdf(d2)
 
 
+async def _estimate_volatility_async(ticker: str) -> float:
+    """Estimate annualized volatility for a ticker using recent data (async)."""
+    try:
+        from app.services.data_ingestion.yahoo import yahoo_adapter
+        df = await yahoo_adapter.get_price_dataframe(ticker, period="3mo")
+        if df.empty or len(df) < 10:
+            return 0.25  # default 25%
+        returns = df["Close"].pct_change().dropna()
+        return float(returns.std() * math.sqrt(TRADING_DAYS))
+    except Exception:
+        return 0.25
+
+
 def _estimate_volatility(ticker: str) -> float:
-    """Estimate annualized volatility for a ticker using recent data."""
+    """Estimate annualized volatility synchronously (fallback)."""
     try:
         from app.services.data_ingestion.yahoo import _sync_fetch_history
         data = _sync_fetch_history(ticker, period="3mo", interval="1d")
         if data.empty or len(data) < 10:
-            return 0.25  # default 25%
+            return 0.25
         returns = data["Close"].pct_change().dropna()
-        return float(returns.std() * math.sqrt(252))
+        return float(returns.std() * math.sqrt(TRADING_DAYS))
     except Exception:
         return 0.25
 
 
-def calculate_options_hedge(
+async def calculate_options_hedge_async(
     holdings: List[Dict[str, Any]],
-    risk_free_rate: float = 0.05,
+    risk_free_rate: float = RISK_FREE_RATE,
     time_horizons: Optional[List[float]] = None,
 ) -> Dict[str, Any]:
     """
-    Calculate options hedge strategies for each holding.
+    Calculate options hedge strategies for each holding (async version).
 
-    Returns protective put, collar, and covered call analyses per position.
+    Returns protective put, collar, covered call analyses with full Greeks.
     """
     if time_horizons is None:
-        time_horizons = [30 / 365, 90 / 365, 180 / 365]  # 1mo, 3mo, 6mo
+        time_horizons = [30 / 365, 90 / 365, 180 / 365]
 
     strategies = []
 
     for h in holdings:
         if h.get("position_type") == "short":
-            continue  # skip short positions for put protection
+            continue
+
+        ticker = h.get("ticker", "")
+        current_price = h.get("current_price", 0)
+        quantity = h.get("quantity", 0)
+        market_value = h.get("market_value", current_price * quantity)
+
+        if current_price <= 0 or quantity <= 0:
+            continue
+
+        sigma = await _estimate_volatility_async(ticker)
+
+        # Strike levels
+        put_strikes = [
+            {"label": "5% OTM", "strike": round(current_price * 0.95, 2), "protection": "95%"},
+            {"label": "ATM", "strike": round(current_price, 2), "protection": "100%"},
+            {"label": "5% ITM", "strike": round(current_price * 1.05, 2), "protection": "105%"},
+        ]
+
+        call_strikes = [
+            {"label": "5% OTM", "strike": round(current_price * 1.05, 2)},
+            {"label": "10% OTM", "strike": round(current_price * 1.10, 2)},
+            {"label": "15% OTM", "strike": round(current_price * 1.15, 2)},
+        ]
+
+        position_strategies = []
+
+        for T in time_horizons:
+            days = int(T * 365)
+
+            # Protective puts with Greeks
+            puts = []
+            for ps in put_strikes:
+                price = black_scholes_put(current_price, ps["strike"], T, risk_free_rate, sigma)
+                total_cost = price * quantity
+                cost_pct = (total_cost / market_value * 100) if market_value > 0 else 0
+                greeks = compute_greeks(current_price, ps["strike"], T, risk_free_rate, sigma, "put")
+                puts.append({
+                    **ps,
+                    "premium": round(price, 2),
+                    "total_cost": round(total_cost, 2),
+                    "cost_pct": round(cost_pct, 2),
+                    "greeks": greeks,
+                })
+
+            # Covered calls with Greeks
+            calls = []
+            for cs in call_strikes:
+                price = black_scholes_call(current_price, cs["strike"], T, risk_free_rate, sigma)
+                total_income = price * quantity
+                income_pct = (total_income / market_value * 100) if market_value > 0 else 0
+                greeks = compute_greeks(current_price, cs["strike"], T, risk_free_rate, sigma, "call")
+                calls.append({
+                    **cs,
+                    "premium": round(price, 2),
+                    "total_income": round(total_income, 2),
+                    "income_pct": round(income_pct, 2),
+                    "greeks": greeks,
+                })
+
+            # Collar
+            atm_put_cost = black_scholes_put(current_price, current_price, T, risk_free_rate, sigma)
+            otm_call_income = black_scholes_call(current_price, current_price * 1.10, T, risk_free_rate, sigma)
+            collar_net = (atm_put_cost - otm_call_income) * quantity
+            collar_pct = (collar_net / market_value * 100) if market_value > 0 else 0
+
+            # Net Greeks for collar
+            put_greeks = compute_greeks(current_price, current_price, T, risk_free_rate, sigma, "put")
+            call_greeks = compute_greeks(current_price, current_price * 1.10, T, risk_free_rate, sigma, "call")
+            collar_greeks = {
+                "net_delta": round(put_greeks["delta"] - call_greeks["delta"], 4),
+                "net_gamma": round(put_greeks["gamma"] - call_greeks["gamma"], 6),
+                "net_theta": round(put_greeks["theta"] - call_greeks["theta"], 4),
+                "net_vega": round(put_greeks["vega"] - call_greeks["vega"], 4),
+            }
+
+            position_strategies.append({
+                "expiry_days": days,
+                "expiry_T": round(T, 4),
+                "protective_puts": puts,
+                "covered_calls": calls,
+                "collar": {
+                    "put_strike": round(current_price, 2),
+                    "call_strike": round(current_price * 1.10, 2),
+                    "net_cost": round(collar_net, 2),
+                    "net_cost_pct": round(collar_pct, 2),
+                    "description": f"Buy {current_price:.0f} put + Sell {current_price*1.10:.0f} call",
+                    "greeks": collar_greeks,
+                },
+            })
+
+        strategies.append({
+            "ticker": ticker,
+            "current_price": current_price,
+            "quantity": quantity,
+            "market_value": round(market_value, 2),
+            "volatility": round(sigma * 100, 1),
+            "strategies": position_strategies,
+        })
+
+    return {"strategies": strategies, "risk_free_rate": risk_free_rate}
+
+
+def calculate_options_hedge(
+    holdings: List[Dict[str, Any]],
+    risk_free_rate: float = RISK_FREE_RATE,
+    time_horizons: Optional[List[float]] = None,
+) -> Dict[str, Any]:
+    """
+    Calculate options hedge strategies (sync version — backward compatible).
+    """
+    if time_horizons is None:
+        time_horizons = [30 / 365, 90 / 365, 180 / 365]
+
+    strategies = []
+
+    for h in holdings:
+        if h.get("position_type") == "short":
+            continue
 
         ticker = h.get("ticker", "")
         current_price = h.get("current_price", 0)
@@ -80,14 +310,12 @@ def calculate_options_hedge(
 
         sigma = _estimate_volatility(ticker)
 
-        # Strike levels: 5% OTM, ATM, 5% ITM for puts
         put_strikes = [
             {"label": "5% OTM", "strike": round(current_price * 0.95, 2), "protection": "95%"},
             {"label": "ATM", "strike": round(current_price, 2), "protection": "100%"},
             {"label": "5% ITM", "strike": round(current_price * 1.05, 2), "protection": "105%"},
         ]
 
-        # Call strikes for covered calls / collar cap
         call_strikes = [
             {"label": "5% OTM", "strike": round(current_price * 1.05, 2)},
             {"label": "10% OTM", "strike": round(current_price * 1.10, 2)},
@@ -99,33 +327,34 @@ def calculate_options_hedge(
         for T in time_horizons:
             days = int(T * 365)
 
-            # Protective puts at different strikes
             puts = []
             for ps in put_strikes:
                 price = black_scholes_put(current_price, ps["strike"], T, risk_free_rate, sigma)
                 total_cost = price * quantity
                 cost_pct = (total_cost / market_value * 100) if market_value > 0 else 0
+                greeks = compute_greeks(current_price, ps["strike"], T, risk_free_rate, sigma, "put")
                 puts.append({
                     **ps,
                     "premium": round(price, 2),
                     "total_cost": round(total_cost, 2),
                     "cost_pct": round(cost_pct, 2),
+                    "greeks": greeks,
                 })
 
-            # Covered calls
             calls = []
             for cs in call_strikes:
                 price = black_scholes_call(current_price, cs["strike"], T, risk_free_rate, sigma)
                 total_income = price * quantity
                 income_pct = (total_income / market_value * 100) if market_value > 0 else 0
+                greeks = compute_greeks(current_price, cs["strike"], T, risk_free_rate, sigma, "call")
                 calls.append({
                     **cs,
                     "premium": round(price, 2),
                     "total_income": round(total_income, 2),
                     "income_pct": round(income_pct, 2),
+                    "greeks": greeks,
                 })
 
-            # Collar: buy ATM put + sell 10% OTM call
             atm_put_cost = black_scholes_put(current_price, current_price, T, risk_free_rate, sigma)
             otm_call_income = black_scholes_call(current_price, current_price * 1.10, T, risk_free_rate, sigma)
             collar_net = (atm_put_cost - otm_call_income) * quantity

backend/app/services/risk/stress_test.py

@@ -3,7 +3,7 @@ Stress Test Engine.
 
 Simulates portfolio impact under various macro scenarios:
 market crashes, rate hikes, sector rotations, currency moves, and custom shocks.
-Uses beta-adjusted impact for each holding.
+Uses computed rolling beta from price data (with sector beta as fallback).
 """
 
 from __future__ import annotations
@@ -79,7 +79,7 @@ SCENARIOS = {
     },
 }
 
-# Rough beta estimates by sector (used when we don't have real beta data)
+# Fallback sector betas (used when < 60 days of data exists)
 SECTOR_BETAS = {
     "Technology": 1.25,
     "Financial": 1.15,
@@ -97,10 +97,55 @@ SECTOR_BETAS = {
 }
 
 
+async def compute_real_betas(
+    tickers: List[str],
+    benchmark: str = "SPY",
+    period: str = "1y",
+) -> Dict[str, float]:
+    """
+    Compute real rolling beta per ticker from actual return covariance.
+    Falls back to sector beta when insufficient data.
+    """
+    from app.services.data_ingestion.yahoo import yahoo_adapter
+    import pandas as pd
+
+    betas: Dict[str, float] = {}
+
+    try:
+        bench_df = await yahoo_adapter.get_price_dataframe(benchmark, period=period)
+        if bench_df.empty:
+            return betas
+        bench_returns = bench_df["Close"].pct_change().dropna()
+
+        for ticker in tickers:
+            try:
+                df = await yahoo_adapter.get_price_dataframe(ticker, period=period)
+                if df.empty or len(df) < 60:
+                    continue
+                stock_returns = df["Close"].pct_change().dropna()
+
+                # Align dates
+                aligned = pd.DataFrame({"stock": stock_returns, "bench": bench_returns}).dropna()
+                if len(aligned) < 30:
+                    continue
+
+                cov = np.cov(aligned["stock"].values, aligned["bench"].values)
+                var_bench = np.var(aligned["bench"].values, ddof=1)
+                if var_bench > 0:
+                    betas[ticker] = round(float(cov[0, 1] / var_bench), 4)
+            except Exception:
+                continue
+    except Exception as e:
+        logger.warning("Beta computation failed: %s", e)
+
+    return betas
+
+
 def run_stress_test(
     holdings: List[Dict[str, Any]],
     scenario_id: str | None = None,
     custom_shock: float | None = None,
+    computed_betas: Dict[str, float] | None = None,
 ) -> Dict[str, Any]:
     """
     Run a stress test on portfolio holdings.
@@ -109,6 +154,7 @@ def run_stress_test(
         holdings: List of holding dicts with market_value, asset_class, etc.
         scenario_id: ID of a predefined scenario
         custom_shock: Custom market shock as decimal (e.g., -0.15 for -15%)
+        computed_betas: Pre-computed real betas per ticker (from compute_real_betas)
 
     Returns:
         Dict with per-holding impact and portfolio-level summary.
@@ -127,6 +173,7 @@ def run_stress_test(
 
     market_shock = scenario["market_shock"]
     sector_shocks = scenario.get("sector_shocks", {})
+    computed_betas = computed_betas or {}
 
     total_before = sum(h.get("market_value", 0) for h in holdings)
     impacts = []
@@ -138,7 +185,15 @@ def run_stress_test(
 
         asset_class = h.get("asset_class", "equity")
         sector = h.get("sector", "default")
-        beta = SECTOR_BETAS.get(sector, SECTOR_BETAS.get(asset_class, 1.0))
+        ticker = h.get("ticker", "")
+
+        # Use computed beta if available, fall back to sector beta
+        if ticker in computed_betas:
+            beta = computed_betas[ticker]
+            beta_source = "computed"
+        else:
+            beta = SECTOR_BETAS.get(sector, SECTOR_BETAS.get(asset_class, 1.0))
+            beta_source = "sector_estimate"
 
         # Check for sector-specific shock override
         if sector in sector_shocks:
@@ -164,9 +219,11 @@ def run_stress_test(
         new_value = mv + impact_value
 
         impacts.append({
-            "ticker": h.get("ticker"),
-            "name": h.get("name", h.get("ticker")),
+            "ticker": ticker,
+            "name": h.get("name", ticker),
             "current_value": round(mv, 2),
+            "beta": round(beta, 4),
+            "beta_source": beta_source,
             "shock_pct": round(shock * 100, 2),
             "impact_value": round(impact_value, 2),
             "new_value": round(new_value, 2),
@@ -199,11 +256,14 @@ def run_stress_test(
     }
 
 
-def run_all_scenarios(holdings: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def run_all_scenarios(
+    holdings: List[Dict[str, Any]],
+    computed_betas: Dict[str, float] | None = None,
+) -> List[Dict[str, Any]]:
     """Run all predefined scenarios and return summaries."""
     results = []
     for sid in SCENARIOS:
-        result = run_stress_test(holdings, scenario_id=sid)
+        result = run_stress_test(holdings, scenario_id=sid, computed_betas=computed_betas)
         results.append({
             "scenario_id": sid,
             "name": result["scenario"]["name"],

backend/app/services/sentiment/engine.py

@@ -2,11 +2,12 @@
 Sentiment Analysis Engine.
 
 Provides sentiment analysis from multiple sources:
-- News headlines (via RSS feeds from Yahoo Finance, Finviz)
-- Social media sentiment scoring
-- Composite sentiment aggregation per ticker
+- News headlines (via RSS feeds from Yahoo Finance, Google News)
+- Rule-based keyword scoring for fast fallback
+- LLM-based sentiment classification via Groq for nuanced analysis
 
-Uses TextBlob for NLP sentiment classification.
+Uses financial keyword matching as primary method with optional
+LLM upgrade for more accurate sentiment classification.
 """
 
 from __future__ import annotations
@@ -66,7 +67,64 @@ def _classify(score: float) -> str:
     return "neutral"
 
 
-async def fetch_news_sentiment(ticker: str) -> Dict[str, Any]:
+# ── LLM-based Sentiment (Groq) ──────────────────────────────────────────
+
+async def _score_headlines_llm(headlines: List[str]) -> List[Dict[str, Any]]:
+    """
+    Score headlines using Groq LLM for nuanced financial sentiment.
+    Falls back to rule-based scoring on failure.
+    """
+    from app.config import get_settings
+    settings = get_settings()
+
+    if not settings.groq_api_key:
+        return []
+
+    try:
+        headlines_text = "\n".join(f"{i+1}. {h}" for i, h in enumerate(headlines[:20]))
+        prompt = f"""Analyze each financial news headline and classify its sentiment.
+Return ONLY a JSON array of objects with "index" (1-based), "sentiment" ("bullish"/"bearish"/"neutral"), and "score" (-1.0 to 1.0).
+
+Headlines:
+{headlines_text}
+
+JSON response:"""
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.groq_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": "llama-3.3-70b-versatile",
+                    "messages": [{"role": "user", "content": prompt}],
+                    "temperature": 0.1,
+                    "max_tokens": 1000,
+                },
+                timeout=aiohttp.ClientTimeout(total=15),
+            ) as resp:
+                if resp.status != 200:
+                    return []
+                data = await resp.json()
+                content = data["choices"][0]["message"]["content"]
+
+                # Extract JSON from response
+                import json
+                # Try to find JSON array in the response
+                start = content.find("[")
+                end = content.rfind("]") + 1
+                if start >= 0 and end > start:
+                    results = json.loads(content[start:end])
+                    return results
+    except Exception as e:
+        logger.warning("LLM sentiment failed: %s", e)
+
+    return []
+
+
+async def fetch_news_sentiment(ticker: str, use_llm: bool = True) -> Dict[str, Any]:
     """Fetch and analyze news headlines for a ticker."""
     cache_key = f"sentiment:news:{ticker}"
     cached = await cache_get(cache_key)
@@ -94,28 +152,50 @@ async def fetch_news_sentiment(ticker: str) -> Dict[str, Any]:
                             continue
 
                         title = title_el.text.strip()
-                        score = _score_headline(title)
+                        rule_score = _score_headline(title)
 
                         headlines.append({
                             "title": title,
                             "source": source,
-                            "score": score,
-                            "sentiment": _classify(score),
+                            "score": rule_score,
+                            "sentiment": _classify(rule_score),
+                            "method": "rule_based",
                             "published": pub_date_el.text if pub_date_el is not None else None,
                             "url": link_el.text if link_el is not None else None,
                         })
             except Exception as e:
                 logger.warning("Failed to fetch %s news for %s: %s", source, ticker, e)
 
+    # Try LLM-based scoring for better accuracy
+    llm_results = []
+    if use_llm and headlines:
+        try:
+            llm_results = await _score_headlines_llm([h["title"] for h in headlines[:20]])
+        except Exception:
+            pass
+
+    # Merge LLM results into headlines
+    if llm_results:
+        for lr in llm_results:
+            idx = lr.get("index", 0) - 1
+            if 0 <= idx < len(headlines):
+                headlines[idx]["ai_score"] = lr.get("score", headlines[idx]["score"])
+                headlines[idx]["ai_sentiment"] = lr.get("sentiment", headlines[idx]["sentiment"])
+                headlines[idx]["method"] = "ai_enhanced"
+                # Use AI score as primary if available
+                headlines[idx]["score"] = lr.get("score", headlines[idx]["score"])
+                headlines[idx]["sentiment"] = lr.get("sentiment", headlines[idx]["sentiment"])
+
     # Compute aggregate scores
     if headlines:
         avg_score = round(sum(h["score"] for h in headlines) / len(headlines), 3)
         bullish_count = sum(1 for h in headlines if h["sentiment"] == "bullish")
         bearish_count = sum(1 for h in headlines if h["sentiment"] == "bearish")
         neutral_count = sum(1 for h in headlines if h["sentiment"] == "neutral")
+        ai_enhanced = sum(1 for h in headlines if h.get("method") == "ai_enhanced")
     else:
         avg_score = 0.0
-        bullish_count = bearish_count = neutral_count = 0
+        bullish_count = bearish_count = neutral_count = ai_enhanced = 0
 
     result = {
         "ticker": ticker,
@@ -125,6 +205,7 @@ async def fetch_news_sentiment(ticker: str) -> Dict[str, Any]:
         "bullish": bullish_count,
         "bearish": bearish_count,
         "neutral": neutral_count,
+        "ai_enhanced_count": ai_enhanced,
         "headlines": headlines[:20],  # Latest 20
         "timestamp": datetime.utcnow().isoformat(),
     }

frontend/src/App.tsx

@@ -15,6 +15,11 @@ import ResearchInsights from './pages/ResearchInsights';
 import HoldingsTracker from './pages/HoldingsTracker';
 import Sentiment from './pages/Sentiment';
 import EconomicCalendar from './pages/EconomicCalendar';
+import PortfolioHealth from './pages/PortfolioHealth';
+import BiasDetector from './pages/BiasDetector';
+import CrisisReplay from './pages/CrisisReplay';
+import PortfolioDNA from './pages/PortfolioDNA';
+import Copilot from './pages/Copilot';
 import './index.css';
 
 function ProtectedRoute({ children }: { children: React.ReactNode }) {
@@ -76,6 +81,22 @@ export default function App() {
         <Route path="/calendar" element={
           <ProtectedRoute><AppLayout><EconomicCalendar /></AppLayout></ProtectedRoute>
         } />
+        {/* ── New Analytics & AI Pages ──────────────────────────────────── */}
+        <Route path="/portfolio-health" element={
+          <ProtectedRoute><AppLayout><PortfolioHealth /></AppLayout></ProtectedRoute>
+        } />
+        <Route path="/bias-detector" element={
+          <ProtectedRoute><AppLayout><BiasDetector /></AppLayout></ProtectedRoute>
+        } />
+        <Route path="/crisis-replay" element={
+          <ProtectedRoute><AppLayout><CrisisReplay /></AppLayout></ProtectedRoute>
+        } />
+        <Route path="/portfolio-dna" element={
+          <ProtectedRoute><AppLayout><PortfolioDNA /></AppLayout></ProtectedRoute>
+        } />
+        <Route path="/copilot" element={
+          <ProtectedRoute><AppLayout><Copilot /></AppLayout></ProtectedRoute>
+        } />
       </Routes>
     </BrowserRouter>
   );

frontend/src/api/client.ts

@@ -138,6 +138,17 @@ export const holdingsAPI = {
   optionsHedge: () => api.get('/holdings/options-hedge'),
   rebalance: () => api.get('/holdings/rebalance'),
   correlation: () => api.get('/holdings/correlation'),
+  // ── New v2 endpoints ──────────────────────────────────────────────────
+  monteCarlo: (data?: { horizon_days?: number; n_simulations?: number; regime_conditioned?: boolean }) =>
+    api.post('/holdings/monte-carlo', data || {}),
+  healthScore: () => api.get('/holdings/health-score'),
+  biasAnalysis: () => api.get('/holdings/bias-analysis'),
+  crisisReplay: (crisis_id: string) =>
+    api.post('/holdings/crisis-replay', { crisis_id }),
+  allCrisisReplays: () => api.get('/holdings/crisis-replay/all'),
+  portfolioDNA: () => api.get('/holdings/portfolio-dna'),
+  attribution: (method: string = 'brinson') =>
+    api.get(`/holdings/attribution?method=${method}`),
 };
 
 // ── Sentiment ────────────────────────────────────────────────────────────
@@ -163,4 +174,9 @@ export const mlAPI = {
   clearCache: () => api.post('/ml/clear-cache'),
 };
 
+// ── HedgeAI───────────────────────────────────────────────────────────
+export const copilotAPI = {
+  chat: (message: string) => api.post('/copilot/chat', { message }),
+};
+
 export default api;

frontend/src/components/Sidebar.tsx

@@ -41,41 +41,51 @@ export default function Sidebar({ onExpandChange }: SidebarProps) {
   const toggleTheme = () => setIsDark(prev => !prev);
 
   const themeIcon = isDark ? (
-    <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z" clipRule="evenodd"/></svg>
+    <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z" clipRule="evenodd" /></svg>
   ) : (
-    <svg viewBox="0 0 20 20" fill="currentColor"><path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z"/></svg>
+    <svg viewBox="0 0 20 20" fill="currentColor"><path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" /></svg>
   );
 
   const allLinks = [
     {
       section: 'Overview',
       items: [
-        { to: '/dashboard', label: 'Dashboard', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M10.707 2.293a1 1 0 00-1.414 0l-7 7a1 1 0 001.414 1.414L4 10.414V17a1 1 0 001 1h2a1 1 0 001-1v-2a1 1 0 011-1h2a1 1 0 011 1v2a1 1 0 001 1h2a1 1 0 001-1v-6.586l.293.293a1 1 0 001.414-1.414l-7-7z"/></svg> },
-        { to: '/holdings', label: 'Holdings', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M4 4a2 2 0 00-2 2v4a2 2 0 002 2V6h10a2 2 0 00-2-2H4zm2 6a2 2 0 012-2h8a2 2 0 012 2v4a2 2 0 01-2 2H8a2 2 0 01-2-2v-4zm6 4a2 2 0 100-4 2 2 0 000 4z" clipRule="evenodd"/></svg> },
+        { to: '/dashboard', label: 'Dashboard', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M10.707 2.293a1 1 0 00-1.414 0l-7 7a1 1 0 001.414 1.414L4 10.414V17a1 1 0 001 1h2a1 1 0 001-1v-2a1 1 0 011-1h2a1 1 0 011 1v2a1 1 0 001 1h2a1 1 0 001-1v-6.586l.293.293a1 1 0 001.414-1.414l-7-7z" /></svg> },
+        { to: '/holdings', label: 'Holdings', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M4 4a2 2 0 00-2 2v4a2 2 0 002 2V6h10a2 2 0 00-2-2H4zm2 6a2 2 0 012-2h8a2 2 0 012 2v4a2 2 0 01-2 2H8a2 2 0 01-2-2v-4zm6 4a2 2 0 100-4 2 2 0 000 4z" clipRule="evenodd" /></svg> },
       ]
     },
     {
       section: 'Research',
       items: [
-        { to: '/market', label: 'Markets', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M12 7a1 1 0 110-2h5a1 1 0 011 1v5a1 1 0 11-2 0V8.414l-4.293 4.293a1 1 0 01-1.414 0L8 10.414l-4.293 4.293a1 1 0 01-1.414-1.414l5-5a1 1 0 011.414 0L11 10.586 14.586 7H12z" clipRule="evenodd"/></svg> },
-        { to: '/factors', label: 'Factor Analysis', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M2 11a1 1 0 011-1h2a1 1 0 011 1v5a1 1 0 01-1 1H3a1 1 0 01-1-1v-5zm6-4a1 1 0 011-1h2a1 1 0 011 1v9a1 1 0 01-1 1H9a1 1 0 01-1-1V7zm6-3a1 1 0 011-1h2a1 1 0 011 1v12a1 1 0 01-1 1h-2a1 1 0 01-1-1V4z"/></svg> },
-        { to: '/sentiment', label: 'Sentiment', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M18 10c0 3.866-3.582 7-8 7a8.841 8.841 0 01-4.083-.98L2 17l1.338-3.123C2.493 12.767 2 11.434 2 10c0-3.866 3.582-7 8-7s8 3.134 8 7zM7 9H5v2h2V9zm8 0h-2v2h2V9zM9 9h2v2H9V9z" clipRule="evenodd"/></svg> },
-        { to: '/research', label: 'Research', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M4 4a2 2 0 012-2h4.586A2 2 0 0112 2.586L15.414 6A2 2 0 0116 7.414V16a2 2 0 01-2 2H6a2 2 0 01-2-2V4zm2 6a1 1 0 011-1h6a1 1 0 110 2H7a1 1 0 01-1-1zm1 3a1 1 0 100 2h6a1 1 0 100-2H7z" clipRule="evenodd"/></svg> },
-        { to: '/calendar', label: 'Calendar', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M6 2a1 1 0 00-1 1v1H4a2 2 0 00-2 2v10a2 2 0 002 2h12a2 2 0 002-2V6a2 2 0 00-2-2h-1V3a1 1 0 10-2 0v1H7V3a1 1 0 00-1-1zm0 5a1 1 0 000 2h8a1 1 0 100-2H6z" clipRule="evenodd"/></svg> },
+        { to: '/market', label: 'Markets', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M12 7a1 1 0 110-2h5a1 1 0 011 1v5a1 1 0 11-2 0V8.414l-4.293 4.293a1 1 0 01-1.414 0L8 10.414l-4.293 4.293a1 1 0 01-1.414-1.414l5-5a1 1 0 011.414 0L11 10.586 14.586 7H12z" clipRule="evenodd" /></svg> },
+        { to: '/factors', label: 'Factor Analysis', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M2 11a1 1 0 011-1h2a1 1 0 011 1v5a1 1 0 01-1 1H3a1 1 0 01-1-1v-5zm6-4a1 1 0 011-1h2a1 1 0 011 1v9a1 1 0 01-1 1H9a1 1 0 01-1-1V7zm6-3a1 1 0 011-1h2a1 1 0 011 1v12a1 1 0 01-1 1h-2a1 1 0 01-1-1V4z" /></svg> },
+        { to: '/sentiment', label: 'Sentiment', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M18 10c0 3.866-3.582 7-8 7a8.841 8.841 0 01-4.083-.98L2 17l1.338-3.123C2.493 12.767 2 11.434 2 10c0-3.866 3.582-7 8-7s8 3.134 8 7zM7 9H5v2h2V9zm8 0h-2v2h2V9zM9 9h2v2H9V9z" clipRule="evenodd" /></svg> },
+        { to: '/research', label: 'Research', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M4 4a2 2 0 012-2h4.586A2 2 0 0112 2.586L15.414 6A2 2 0 0116 7.414V16a2 2 0 01-2 2H6a2 2 0 01-2-2V4zm2 6a1 1 0 011-1h6a1 1 0 110 2H7a1 1 0 01-1-1zm1 3a1 1 0 100 2h6a1 1 0 100-2H7z" clipRule="evenodd" /></svg> },
+        { to: '/calendar', label: 'Calendar', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M6 2a1 1 0 00-1 1v1H4a2 2 0 00-2 2v10a2 2 0 002 2h12a2 2 0 002-2V6a2 2 0 00-2-2h-1V3a1 1 0 10-2 0v1H7V3a1 1 0 00-1-1zm0 5a1 1 0 000 2h8a1 1 0 100-2H6z" clipRule="evenodd" /></svg> },
       ]
     },
     {
       section: 'Quantitative',
       items: [
-        { to: '/strategies', label: 'Strategy Builder', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M11.49 3.17c-.38-1.56-2.6-1.56-2.98 0a1.532 1.532 0 01-2.286.948c-1.372-.836-2.942.734-2.106 2.106.54.886.061 2.042-.947 2.287-1.561.379-1.561 2.6 0 2.978a1.532 1.532 0 01.947 2.287c-.836 1.372.734 2.942 2.106 2.106a1.532 1.532 0 012.287.947c.379 1.561 2.6 1.561 2.978 0a1.533 1.533 0 012.287-.947c1.372.836 2.942-.734 2.106-2.106a1.533 1.533 0 01.947-2.287c1.561-.379 1.561-2.6 0-2.978a1.532 1.532 0 01-.947-2.287c.836-1.372-.734-2.942-2.106-2.106a1.532 1.532 0 01-2.287-.947zM10 13a3 3 0 100-6 3 3 0 000 6z" clipRule="evenodd"/></svg> },
-        { to: '/backtests', label: 'Backtests', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm1-12a1 1 0 10-2 0v4a1 1 0 00.293.707l2.828 2.829a1 1 0 101.415-1.415L11 9.586V6z" clipRule="evenodd"/></svg> },
+        { to: '/strategies', label: 'Strategy Builder', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M11.49 3.17c-.38-1.56-2.6-1.56-2.98 0a1.532 1.532 0 01-2.286.948c-1.372-.836-2.942.734-2.106 2.106.54.886.061 2.042-.947 2.287-1.561.379-1.561 2.6 0 2.978a1.532 1.532 0 01.947 2.287c-.836 1.372.734 2.942 2.106 2.106a1.532 1.532 0 012.287.947c.379 1.561 2.6 1.561 2.978 0a1.533 1.533 0 012.287-.947c1.372.836 2.942-.734 2.106-2.106a1.533 1.533 0 01.947-2.287c1.561-.379 1.561-2.6 0-2.978a1.532 1.532 0 01-.947-2.287c.836-1.372-.734-2.942-2.106-2.106a1.532 1.532 0 01-2.287-.947zM10 13a3 3 0 100-6 3 3 0 000 6z" clipRule="evenodd" /></svg> },
+        { to: '/backtests', label: 'Backtests', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm1-12a1 1 0 10-2 0v4a1 1 0 00.293.707l2.828 2.829a1 1 0 101.415-1.415L11 9.586V6z" clipRule="evenodd" /></svg> },
+      ]
+    },
+    {
+      section: 'Analytics',
+      items: [
+        { to: '/portfolio-health', label: 'Health Score', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M3.172 5.172a4 4 0 015.656 0L10 6.343l1.172-1.171a4 4 0 115.656 5.656L10 17.657l-6.828-6.829a4 4 0 010-5.656z" clipRule="evenodd" /></svg> },
+        { to: '/bias-detector', label: 'Bias Detector', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M9 2a1 1 0 000 2h2a1 1 0 100-2H9z" /><path fillRule="evenodd" d="M4 5a2 2 0 012-2 3 3 0 003 3h2a3 3 0 003-3 2 2 0 012 2v11a2 2 0 01-2 2H6a2 2 0 01-2-2V5zm9.707 5.707a1 1 0 00-1.414-1.414L9 12.586l-1.293-1.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" /></svg> },
+        { to: '/crisis-replay', label: 'Crisis Replay', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M12.395 2.553a1 1 0 00-1.45-.385c-.345.23-.614.558-.822.88-.214.33-.403.713-.57 1.116-.334.804-.614 1.768-.84 2.734a31.365 31.365 0 00-.613 3.58 2.64 2.64 0 01-.945-1.067c-.328-.68-.398-1.534-.398-2.654A1 1 0 005.05 6.05 6.981 6.981 0 003 11a7 7 0 1011.95-4.95c-.592-.591-.98-.985-1.348-1.467-.363-.476-.724-1.063-1.207-2.03zM12.12 15.12A3 3 0 017 13s.879.5 2.5.5c0-1 .5-4 1.25-4.5.5 1 .786 1.293 1.371 1.879A2.99 2.99 0 0113 13a2.99 2.99 0 01-.879 2.121z" clipRule="evenodd" /></svg> },
+        { to: '/portfolio-dna', label: 'Portfolio DNA', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M10 3.5a1.5 1.5 0 013 0V4a1 1 0 001 1h3a1 1 0 011 1v3a1 1 0 01-1 1h-.5a1.5 1.5 0 000 3h.5a1 1 0 011 1v3a1 1 0 01-1 1h-3a1 1 0 01-1-1v-.5a1.5 1.5 0 00-3 0v.5a1 1 0 01-1 1H6a1 1 0 01-1-1v-3a1 1 0 00-1-1h-.5a1.5 1.5 0 010-3H4a1 1 0 001-1V6a1 1 0 011-1h3a1 1 0 001-1v-.5z" /></svg> },
       ]
     },
     {
       section: 'Portfolio',
       items: [
-        { to: '/portfolio', label: 'Optimization', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M2 10a8 8 0 018-8v8h8a8 8 0 11-16 0z"/><path d="M12 2.252A8.014 8.014 0 0117.748 8H12V2.252z"/></svg> },
-        { to: '/marketplace', label: 'Marketplace', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M3 1a1 1 0 000 2h1.22l.305 1.222a.997.997 0 00.01.042l1.358 5.43-.893.892C3.74 11.846 4.632 14 6.414 14H15a1 1 0 000-2H6.414l1-1H14a1 1 0 00.894-.553l3-6A1 1 0 0017 3H6.28l-.31-1.243A1 1 0 005 1H3zM16 16.5a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM6.5 18a1.5 1.5 0 100-3 1.5 1.5 0 000 3z"/></svg> },
+        { to: '/portfolio', label: 'Optimization', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M2 10a8 8 0 018-8v8h8a8 8 0 11-16 0z" /><path d="M12 2.252A8.014 8.014 0 0117.748 8H12V2.252z" /></svg> },
+        { to: '/marketplace', label: 'Marketplace', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path d="M3 1a1 1 0 000 2h1.22l.305 1.222a.997.997 0 00.01.042l1.358 5.43-.893.892C3.74 11.846 4.632 14 6.414 14H15a1 1 0 000-2H6.414l1-1H14a1 1 0 00.894-.553l3-6A1 1 0 0017 3H6.28l-.31-1.243A1 1 0 005 1H3zM16 16.5a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM6.5 18a1.5 1.5 0 100-3 1.5 1.5 0 000 3z" /></svg> },
+        { to: '/copilot', label: 'HedgeAI', icon: <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M6.672 1.911a1 1 0 10-1.932.518l.259.966a1 1 0 001.932-.518l-.26-.966zM2.429 4.74a1 1 0 10-.517 1.932l.966.259a1 1 0 00.517-1.932l-.966-.26zm8.814-.569a1 1 0 00-1.415-1.414l-.707.707a1 1 0 101.415 1.415l.707-.708zm-7.071 7.072l.707-.707A1 1 0 003.465 9.12l-.708.707a1 1 0 001.415 1.415zm3.2-5.171a1 1 0 00-1.3 1.3l4 10a1 1 0 001.823.075l1.38-2.759 3.018 3.02a1 1 0 001.414-1.415l-3.019-3.02 2.76-1.379a1 1 0 00-.076-1.822l-10-4z" clipRule="evenodd" /></svg> },
       ]
     },
   ];
@@ -97,8 +107,8 @@ export default function Sidebar({ onExpandChange }: SidebarProps) {
     >      <div className="sidebar-brand">
         <NavLink to="/dashboard" className="sidebar-logo">
           <svg width="32" height="32" viewBox="0 0 32 32" fill="none">
-            <rect width="32" height="32" rx="8" fill="#005241"/>
-            <path d="M8 22 L12 14 L16 18 L20 10 L24 16" stroke="white" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" fill="none"/>
+            <rect width="32" height="32" rx="8" fill="#005241" />
+            <path d="M8 22 L12 14 L16 18 L20 10 L24 16" stroke="white" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" fill="none" />
           </svg>
           <span className="sidebar-brand-text">
             Quant<em>Hedge</em>
@@ -142,7 +152,7 @@ export default function Sidebar({ onExpandChange }: SidebarProps) {
         </button>
         <button className="sidebar-link sidebar-logout" onClick={handleLogout}>
           <span className="sidebar-icon">
-            <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M3 3a1 1 0 00-1 1v12a1 1 0 102 0V4a1 1 0 00-1-1zm10.293 9.293a1 1 0 001.414 1.414l3-3a1 1 0 000-1.414l-3-3a1 1 0 10-1.414 1.414L14.586 9H7a1 1 0 100 2h7.586l-1.293 1.293z" clipRule="evenodd"/></svg>
+            <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M3 3a1 1 0 00-1 1v12a1 1 0 102 0V4a1 1 0 00-1-1zm10.293 9.293a1 1 0 001.414 1.414l3-3a1 1 0 000-1.414l-3-3a1 1 0 10-1.414 1.414L14.586 9H7a1 1 0 100 2h7.586l-1.293 1.293z" clipRule="evenodd" /></svg>
           </span>
           <span className="sidebar-label">Log Out</span>
         </button>
@@ -171,7 +181,7 @@ export default function Sidebar({ onExpandChange }: SidebarProps) {
             onClick={() => setDrawerOpen(!drawerOpen)}
           >
             <svg viewBox="0 0 20 20" fill="currentColor" width="20" height="20">
-              <path fillRule="evenodd" d="M3 5a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 10a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 15a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1z" clipRule="evenodd"/>
+              <path fillRule="evenodd" d="M3 5a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 10a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 15a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1z" clipRule="evenodd" />
             </svg>
             <span>More</span>
           </button>
@@ -219,7 +229,7 @@ export default function Sidebar({ onExpandChange }: SidebarProps) {
               </button>
               <button className="sidebar-link sidebar-logout" onClick={handleLogout} style={{ width: '100%' }}>
                 <span className="sidebar-icon">
-                  <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M3 3a1 1 0 00-1 1v12a1 1 0 102 0V4a1 1 0 00-1-1zm10.293 9.293a1 1 0 001.414 1.414l3-3a1 1 0 000-1.414l-3-3a1 1 0 10-1.414 1.414L14.586 9H7a1 1 0 100 2h7.586l-1.293 1.293z" clipRule="evenodd"/></svg>
+                  <svg viewBox="0 0 20 20" fill="currentColor"><path fillRule="evenodd" d="M3 3a1 1 0 00-1 1v12a1 1 0 102 0V4a1 1 0 00-1-1zm10.293 9.293a1 1 0 001.414 1.414l3-3a1 1 0 000-1.414l-3-3a1 1 0 10-1.414 1.414L14.586 9H7a1 1 0 100 2h7.586l-1.293 1.293z" clipRule="evenodd" /></svg>
                 </span>
                 <span className="sidebar-label">Log Out</span>
               </button>

frontend/src/index.css

@@ -35,8 +35,8 @@
 
   --gradient-accent: linear-gradient(135deg, #005241, #007d63);
   --gradient-dark: linear-gradient(135deg, #0c1f1a 0%, #1a3a2e 50%, #0c1f1a 100%);
-  --gradient-hero-overlay: linear-gradient(180deg, rgba(12,31,26,0.85) 0%, rgba(12,31,26,0.7) 50%, rgba(12,31,26,0.9) 100%);
-  --gradient-card-hover: linear-gradient(145deg, rgba(0,82,65,0.02), rgba(0,82,65,0.06));
+  --gradient-hero-overlay: linear-gradient(180deg, rgba(12, 31, 26, 0.85) 0%, rgba(12, 31, 26, 0.7) 50%, rgba(12, 31, 26, 0.9) 100%);
+  --gradient-card-hover: linear-gradient(145deg, rgba(0, 82, 65, 0.02), rgba(0, 82, 65, 0.06));
 
   --border-color: #e2e5ea;
   --border-subtle: #eef0f3;
@@ -45,7 +45,7 @@
   --shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.06);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.08);
   --shadow-lg: 0 8px 30px rgba(0, 0, 0, 0.1);
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.04), 0 1px 2px rgba(0,0,0,0.06);
+  --shadow-card: 0 1px 3px rgba(0, 0, 0, 0.04), 0 1px 2px rgba(0, 0, 0, 0.06);
   --shadow-card-hover: 0 10px 40px rgba(0, 0, 0, 0.08);
 
   --radius-sm: 4px;
@@ -103,7 +103,7 @@
   --blue-info: #3b82f6;
 
   --gradient-accent: linear-gradient(135deg, #00a87a, #00c896);
-  --gradient-card-hover: linear-gradient(145deg, rgba(0,168,122,0.04), rgba(0,168,122,0.08));
+  --gradient-card-hover: linear-gradient(145deg, rgba(0, 168, 122, 0.04), rgba(0, 168, 122, 0.08));
 
   --border-color: #1f2228;
   --border-subtle: #181b20;
@@ -112,7 +112,7 @@
   --shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.3);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.4);
   --shadow-lg: 0 8px 30px rgba(0, 0, 0, 0.5);
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.2), 0 1px 2px rgba(0,0,0,0.15);
+  --shadow-card: 0 1px 3px rgba(0, 0, 0, 0.2), 0 1px 2px rgba(0, 0, 0, 0.15);
   --shadow-card-hover: 0 10px 40px rgba(0, 0, 0, 0.35);
 
   --chart-axis: #6b7588;
@@ -132,34 +132,92 @@ body {
 }
 
 /* Dark mode: badge overrides */
-[data-theme="dark"] .badge-primary { background: rgba(0,168,122,0.15); color: var(--accent); }
-[data-theme="dark"] .badge-emerald { background: rgba(16,185,129,0.15); color: var(--green-positive); }
-[data-theme="dark"] .badge-rose { background: rgba(239,68,68,0.15); color: var(--red-negative); }
-[data-theme="dark"] .badge-amber { background: rgba(212,168,67,0.15); color: var(--amber-neutral); }
+[data-theme="dark"] .badge-primary {
+  background: rgba(0, 168, 122, 0.15);
+  color: var(--accent);
+}
+
+[data-theme="dark"] .badge-emerald {
+  background: rgba(16, 185, 129, 0.15);
+  color: var(--green-positive);
+}
+
+[data-theme="dark"] .badge-rose {
+  background: rgba(239, 68, 68, 0.15);
+  color: var(--red-negative);
+}
+
+[data-theme="dark"] .badge-amber {
+  background: rgba(212, 168, 67, 0.15);
+  color: var(--amber-neutral);
+}
 
 /* Dark mode: table header */
-[data-theme="dark"] th { background: var(--bg-tertiary); }
+[data-theme="dark"] th {
+  background: var(--bg-tertiary);
+}
 
 /* Dark mode: scrollbar */
-[data-theme="dark"] ::-webkit-scrollbar-track { background: var(--bg-secondary); }
-[data-theme="dark"] ::-webkit-scrollbar-thumb { background: #2a2d32; }
-[data-theme="dark"] ::-webkit-scrollbar-thumb:hover { background: var(--accent); }
+[data-theme="dark"] ::-webkit-scrollbar-track {
+  background: var(--bg-secondary);
+}
+
+[data-theme="dark"] ::-webkit-scrollbar-thumb {
+  background: #2a2d32;
+}
+
+[data-theme="dark"] ::-webkit-scrollbar-thumb:hover {
+  background: var(--accent);
+}
 
 /* Dark mode: selection */
-[data-theme="dark"] ::selection { background: rgba(0, 168, 122, 0.25); color: var(--text-primary); }
+[data-theme="dark"] ::selection {
+  background: rgba(0, 168, 122, 0.25);
+  color: var(--text-primary);
+}
 
 /* Dark mode: React Flow (Strategy Builder) */
-[data-theme="dark"] .react-flow__controls { background: var(--bg-tertiary); border-color: var(--border-color); border-radius: var(--radius-md); }
-[data-theme="dark"] .react-flow__controls-button { background: var(--bg-card); border-color: var(--border-color); fill: var(--text-secondary); }
-[data-theme="dark"] .react-flow__controls-button:hover { background: var(--bg-hover); }
-[data-theme="dark"] .react-flow__minimap { background: var(--bg-tertiary) !important; }
-[data-theme="dark"] .react-flow__attribution { background: transparent !important; }
-[data-theme="dark"] .react-flow__attribution a { color: var(--text-muted) !important; }
+[data-theme="dark"] .react-flow__controls {
+  background: var(--bg-tertiary);
+  border-color: var(--border-color);
+  border-radius: var(--radius-md);
+}
+
+[data-theme="dark"] .react-flow__controls-button {
+  background: var(--bg-card);
+  border-color: var(--border-color);
+  fill: var(--text-secondary);
+}
+
+[data-theme="dark"] .react-flow__controls-button:hover {
+  background: var(--bg-hover);
+}
+
+[data-theme="dark"] .react-flow__minimap {
+  background: var(--bg-tertiary) !important;
+}
+
+[data-theme="dark"] .react-flow__attribution {
+  background: transparent !important;
+}
+
+[data-theme="dark"] .react-flow__attribution a {
+  color: var(--text-muted) !important;
+}
 
 /* ── Reset ───────────────────────────────────────────────────────────── */
-*, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
+*,
+*::before,
+*::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
 
-html { scroll-behavior: smooth; -webkit-font-smoothing: antialiased; }
+html {
+  scroll-behavior: smooth;
+  -webkit-font-smoothing: antialiased;
+}
 
 body {
   font-family: var(--font-sans);
@@ -169,21 +227,52 @@ body {
   min-height: 100vh;
 }
 
-#root { min-height: 100vh; display: flex; flex-direction: column; }
+#root {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+a {
+  color: var(--accent);
+  text-decoration: none;
+  transition: color var(--transition-fast);
+}
 
-a { color: var(--accent); text-decoration: none; transition: color var(--transition-fast); }
-a:hover { color: var(--accent-light); }
+a:hover {
+  color: var(--accent-light);
+}
 
 /* ── Typography ──────────────────────────────────────────────────────── */
-h1, h2, h3, h4, h5, h6 {
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
   font-weight: 600;
   line-height: 1.25;
   letter-spacing: -0.02em;
   color: var(--text-primary);
 }
-h1 { font-size: clamp(2rem, 4.5vw, 3.25rem); font-family: var(--font-serif); font-weight: 500; }
-h2 { font-size: clamp(1.5rem, 3vw, 2.25rem); font-family: var(--font-serif); font-weight: 500; }
-h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
+
+h1 {
+  font-size: clamp(2rem, 4.5vw, 3.25rem);
+  font-family: var(--font-serif);
+  font-weight: 500;
+}
+
+h2 {
+  font-size: clamp(1.5rem, 3vw, 2.25rem);
+  font-family: var(--font-serif);
+  font-weight: 500;
+}
+
+h3 {
+  font-size: 1rem;
+  font-family: var(--font-sans);
+  font-weight: 600;
+}
 
 .text-gradient {
   background: var(--gradient-accent);
@@ -191,31 +280,85 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   -webkit-text-fill-color: transparent;
   background-clip: text;
 }
-.text-serif { font-family: var(--font-serif); }
-.text-accent { color: var(--accent); }
-.mono { font-family: var(--font-mono); font-size: 0.875em; }
+
+.text-serif {
+  font-family: var(--font-serif);
+}
+
+.text-accent {
+  color: var(--accent);
+}
+
+.mono {
+  font-family: var(--font-mono);
+  font-size: 0.875em;
+}
 
 /* ── Layout ──────────────────────────────────────────────────────────── */
 .app-layout {
   display: flex;
   min-height: 100vh;
 }
+
 .app-main {
   flex: 1;
   min-width: 0;
   margin-left: 68px;
   transition: margin-left var(--transition-base);
 }
-.page { flex: 1; padding: 2.5rem 3rem; max-width: 1320px; margin: 0 auto; width: 100%; }
-.page-header { margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid var(--border-color); }
-.page-header h1 { margin-bottom: 0.25rem; }
-.page-header p { color: var(--text-secondary); font-size: 0.95rem; }
 
-.grid-2 { display: grid; grid-template-columns: repeat(auto-fit, minmax(380px, 1fr)); gap: 1.75rem; }
-.grid-3 { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1.5rem; }
-.grid-4 { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 1.25rem; }
-.flex-between { display: flex; justify-content: space-between; align-items: center; }
-.flex-gap { display: flex; gap: 0.75rem; align-items: center; }
+.page {
+  flex: 1;
+  padding: 2.5rem 3rem;
+  max-width: 1320px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.page-header {
+  margin-bottom: 2rem;
+  padding-bottom: 1.5rem;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.page-header h1 {
+  margin-bottom: 0.25rem;
+}
+
+.page-header p {
+  color: var(--text-secondary);
+  font-size: 0.95rem;
+}
+
+.grid-2 {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(380px, 1fr));
+  gap: 1.75rem;
+}
+
+.grid-3 {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: 1.5rem;
+}
+
+.grid-4 {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+  gap: 1.25rem;
+}
+
+.flex-between {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.flex-gap {
+  display: flex;
+  gap: 0.75rem;
+  align-items: center;
+}
 
 /* ── Sidebar ────────────────────────────────────────────────────────── */
 .sidebar {
@@ -232,6 +375,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   transition: width 0.25s cubic-bezier(0.4, 0, 0.2, 1);
   z-index: 200;
 }
+
 .sidebar.sidebar-expanded {
   width: 260px;
 }
@@ -245,6 +389,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   display: flex;
   align-items: center;
 }
+
 .sidebar-logo {
   display: flex;
   align-items: center;
@@ -253,9 +398,11 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   color: var(--text-primary);
   white-space: nowrap;
 }
+
 .sidebar-logo svg {
   flex-shrink: 0;
 }
+
 .sidebar-brand-text {
   font-family: var(--font-serif);
   font-size: 1.2rem;
@@ -265,10 +412,12 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   transform: translateX(-8px);
   transition: opacity 0.2s ease 0.05s, transform 0.2s ease 0.05s;
 }
+
 .sidebar.sidebar-expanded .sidebar-brand-text {
   opacity: 1;
   transform: translateX(0);
 }
+
 .sidebar-brand-text em {
   font-style: normal;
   color: var(--accent);
@@ -281,11 +430,15 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   overflow-x: hidden;
   padding: 0.5rem 0;
 }
-.sidebar-nav::-webkit-scrollbar { width: 0; }
+
+.sidebar-nav::-webkit-scrollbar {
+  width: 0;
+}
 
 .sidebar-section {
   padding: 0.5rem 0;
 }
+
 .sidebar-section-label {
   padding: 0.375rem 1.4rem;
   font-size: 0.6rem;
@@ -297,6 +450,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   opacity: 0;
   transition: opacity 0.2s ease 0.05s;
 }
+
 .sidebar.sidebar-expanded .sidebar-section-label {
   opacity: 1;
 }
@@ -321,10 +475,12 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   text-align: left;
   font-family: var(--font-sans);
 }
+
 .sidebar-link:hover {
   background: var(--bg-hover);
   color: var(--accent);
 }
+
 .sidebar-link.active {
   background: var(--accent-lighter);
   color: var(--accent);
@@ -339,6 +495,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   align-items: center;
   justify-content: center;
 }
+
 .sidebar-icon svg {
   width: 18px;
   height: 18px;
@@ -349,6 +506,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   transform: translateX(-8px);
   transition: opacity 0.2s ease 0.05s, transform 0.2s ease 0.05s;
 }
+
 .sidebar.sidebar-expanded .sidebar-label {
   opacity: 1;
   transform: translateX(0);
@@ -360,6 +518,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   padding: 0.75rem;
   flex-shrink: 0;
 }
+
 .sidebar-user {
   display: flex;
   align-items: center;
@@ -369,6 +528,7 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   white-space: nowrap;
   overflow: hidden;
 }
+
 .sidebar-avatar {
   width: 32px;
   height: 32px;
@@ -382,29 +542,36 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   font-weight: 700;
   flex-shrink: 0;
 }
+
 .sidebar-user-info {
   opacity: 0;
   transition: opacity 0.2s ease 0.05s;
 }
+
 .sidebar.sidebar-expanded .sidebar-user-info {
   opacity: 1;
 }
+
 .sidebar-user-name {
   font-size: 0.78rem;
   font-weight: 600;
   color: var(--text-primary);
 }
+
 .sidebar-user-email {
   font-size: 0.65rem;
   color: var(--text-muted);
 }
+
 .sidebar-logout {
   color: var(--text-muted) !important;
 }
+
 .sidebar-logout:hover {
   color: var(--red-negative) !important;
   background: rgba(194, 48, 48, 0.05) !important;
 }
+
 .card {
   background: var(--bg-card);
   border: 1px solid var(--border-color);
@@ -413,10 +580,12 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   box-shadow: var(--shadow-card);
   transition: all var(--transition-base);
 }
+
 .card:hover {
   box-shadow: var(--shadow-card-hover);
   border-color: var(--border-accent);
 }
+
 .card-header {
   display: flex;
   justify-content: space-between;
@@ -425,7 +594,13 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   padding-bottom: 0.875rem;
   border-bottom: 1px solid var(--border-subtle);
 }
-.card-header h3 { font-size: 0.95rem; font-weight: 600; color: var(--text-primary); letter-spacing: 0; }
+
+.card-header h3 {
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  letter-spacing: 0;
+}
 
 /* ── Buttons ─────────────────────────────────────────────────────────── */
 .btn {
@@ -445,31 +620,55 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   letter-spacing: 0.02em;
   text-transform: uppercase;
 }
-.btn:active { transform: scale(0.98); }
+
+.btn:active {
+  transform: scale(0.98);
+}
 
 .btn-primary {
   background: var(--accent);
   color: #fff;
 }
-.btn-primary:hover { background: var(--accent-light); }
+
+.btn-primary:hover {
+  background: var(--accent-light);
+}
 
 .btn-secondary {
   background: transparent;
   color: var(--text-primary);
   border: 1px solid var(--border-color);
 }
+
 .btn-secondary:hover {
   background: var(--bg-hover);
   border-color: var(--accent);
   color: var(--accent);
 }
 
-.btn-sm { padding: 0.375rem 0.875rem; font-size: 0.75rem; }
-.btn-lg { padding: 0.875rem 2.25rem; font-size: 0.875rem; letter-spacing: 0.08em; }
-.btn-icon { width: 36px; height: 36px; padding: 0; border-radius: var(--radius-sm); }
+.btn-sm {
+  padding: 0.375rem 0.875rem;
+  font-size: 0.75rem;
+}
+
+.btn-lg {
+  padding: 0.875rem 2.25rem;
+  font-size: 0.875rem;
+  letter-spacing: 0.08em;
+}
+
+.btn-icon {
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border-radius: var(--radius-sm);
+}
 
 /* ── Form Elements ───────────────────────────────────────────────────── */
-.form-group { margin-bottom: 1.25rem; }
+.form-group {
+  margin-bottom: 1.25rem;
+}
+
 .form-group label {
   display: block;
   font-size: 0.75rem;
@@ -480,7 +679,9 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   letter-spacing: 0.06em;
 }
 
-.input, select, textarea {
+.input,
+select,
+textarea {
   width: 100%;
   padding: 0.625rem 0.875rem;
   background: var(--bg-primary);
@@ -492,11 +693,17 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   transition: all var(--transition-fast);
   outline: none;
 }
-.input:focus, select:focus, textarea:focus {
+
+.input:focus,
+select:focus,
+textarea:focus {
   border-color: var(--accent);
   box-shadow: 0 0 0 3px rgba(0, 82, 65, 0.1);
 }
-.input::placeholder { color: var(--text-muted); }
+
+.input::placeholder {
+  color: var(--text-muted);
+}
 
 /* ── Table ───────────────────────────────────────────────────────────── */
 .table-container {
@@ -504,7 +711,12 @@ h3 { font-size: 1rem; font-family: var(--font-sans); font-weight: 600; }
   border-radius: var(--radius-md);
   border: 1px solid var(--border-color);
 }
-table { width: 100%; border-collapse: collapse; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
 th {
   padding: 0.75rem 1rem;
   text-align: left;
@@ -516,6 +728,7 @@ th {
   background: var(--bg-secondary);
   border-bottom: 2px solid var(--border-color);
 }
+
 td {
   padding: 0.75rem 1rem;
   font-size: 0.85rem;
@@ -523,16 +736,24 @@ td {
   font-family: var(--font-mono);
   font-size: 0.8rem;
 }
-tr:hover td { background: var(--bg-hover); }
+
+tr:hover td {
+  background: var(--bg-hover);
+}
 
 /* ── Metrics ─────────────────────────────────────────────────────────── */
-.metric { text-align: center; padding: 1.25rem 1rem; }
+.metric {
+  text-align: center;
+  padding: 1.25rem 1rem;
+}
+
 .metric-value {
   font-size: 1.75rem;
   font-weight: 700;
   font-family: var(--font-mono);
   letter-spacing: -0.03em;
 }
+
 .metric-label {
   font-size: 0.65rem;
   text-transform: uppercase;
@@ -541,9 +762,18 @@ tr:hover td { background: var(--bg-hover); }
   margin-top: 0.25rem;
   font-weight: 600;
 }
-.positive { color: var(--green-positive); }
-.negative { color: var(--red-negative); }
-.neutral { color: var(--amber-neutral); }
+
+.positive {
+  color: var(--green-positive);
+}
+
+.negative {
+  color: var(--red-negative);
+}
+
+.neutral {
+  color: var(--amber-neutral);
+}
 
 /* ── Badge ───────────────────────────────────────────────────────────── */
 .badge {
@@ -556,10 +786,26 @@ tr:hover td { background: var(--bg-hover); }
   letter-spacing: 0.06em;
   text-transform: uppercase;
 }
-.badge-primary { background: var(--accent-lighter); color: var(--accent); }
-.badge-emerald { background: #e6f9f0; color: var(--green-positive); }
-.badge-rose { background: var(--error-bg); color: var(--red-negative); }
-.badge-amber { background: #fffbeb; color: var(--amber-neutral); }
+
+.badge-primary {
+  background: var(--accent-lighter);
+  color: var(--accent);
+}
+
+.badge-emerald {
+  background: #e6f9f0;
+  color: var(--green-positive);
+}
+
+.badge-rose {
+  background: var(--error-bg);
+  color: var(--red-negative);
+}
+
+.badge-amber {
+  background: #fffbeb;
+  color: var(--amber-neutral);
+}
 
 /* ── Tabs ────────────────────────────────────────────────────────────── */
 .tabs {
@@ -568,6 +814,7 @@ tr:hover td { background: var(--bg-hover); }
   border-bottom: 2px solid var(--border-color);
   margin-bottom: 1.75rem;
 }
+
 .tab {
   padding: 0.75rem 1.25rem;
   font-size: 0.8rem;
@@ -582,7 +829,11 @@ tr:hover td { background: var(--bg-hover); }
   text-transform: uppercase;
   letter-spacing: 0.06em;
 }
-.tab:hover { color: var(--text-primary); }
+
+.tab:hover {
+  color: var(--text-primary);
+}
+
 .tab.active {
   color: var(--accent);
   border-bottom-color: var(--accent);
@@ -597,7 +848,12 @@ tr:hover td { background: var(--bg-hover); }
   border-radius: 50%;
   animation: spin 0.8s linear infinite;
 }
-@keyframes spin { to { transform: rotate(360deg); } }
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
 
 .loading-overlay {
   display: flex;
@@ -611,15 +867,34 @@ tr:hover td { background: var(--bg-hover); }
 
 /* ── Animations ──────────────────────────────────────────────────────── */
 @keyframes fadeInUp {
-  from { opacity: 0; transform: translateY(24px); }
-  to { opacity: 1; transform: translateY(0); }
+  from {
+    opacity: 0;
+    transform: translateY(24px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
 }
+
 @keyframes fadeIn {
-  from { opacity: 0; }
-  to { opacity: 1; }
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+
+.animate-fade-in {
+  animation: fadeIn 0.6s ease-out;
+}
+
+.animate-fade-in-up {
+  animation: fadeInUp 0.7s ease-out;
 }
-.animate-fade-in { animation: fadeIn 0.6s ease-out; }
-.animate-fade-in-up { animation: fadeInUp 0.7s ease-out; }
 
 /* ── Chart ───────────────────────────────────────────────────────────── */
 .chart-container {
@@ -639,11 +914,25 @@ tr:hover td { background: var(--bg-hover); }
   text-align: center;
   color: var(--text-muted);
 }
-.empty-state h3 { color: var(--text-secondary); margin-bottom: 0.5rem; }
-.empty-state p { max-width: 400px; font-size: 0.9rem; line-height: 1.7; }
+
+.empty-state h3 {
+  color: var(--text-secondary);
+  margin-bottom: 0.5rem;
+}
+
+.empty-state p {
+  max-width: 400px;
+  font-size: 0.9rem;
+  line-height: 1.7;
+}
 
 /* ── Divider ─────────────────────────────────────────────────────────── */
-.divider { width: 60px; height: 2px; background: var(--accent); margin: 1rem 0; }
+.divider {
+  width: 60px;
+  height: 2px;
+  background: var(--accent);
+  margin: 1rem 0;
+}
 
 /* ── Professional Icon Container ─────────────────────────────────────── */
 .icon-box {
@@ -657,7 +946,11 @@ tr:hover td { background: var(--bg-hover); }
   color: var(--accent);
   flex-shrink: 0;
 }
-.icon-box svg { width: 22px; height: 22px; }
+
+.icon-box svg {
+  width: 22px;
+  height: 22px;
+}
 
 /* ═══════════════════════════════════════════════════════════════════════
    MOBILE RESPONSIVE — max-width: 768px
@@ -669,7 +962,8 @@ tr:hover td { background: var(--bg-hover); }
   /* ── App Shell ─────────────────────────────────────────────────────── */
   .app-main {
     margin-left: 0 !important;
-    padding-bottom: 72px; /* space for bottom tab bar */
+    padding-bottom: 72px;
+    /* space for bottom tab bar */
   }
 
   /* ── Desktop Sidebar hidden on mobile ──────────────────────────────── */
@@ -691,6 +985,7 @@ tr:hover td { background: var(--bg-hover); }
     padding: 0 0.25rem;
     box-shadow: 0 -2px 12px rgba(0, 0, 0, 0.06);
   }
+
   .mobile-nav-items {
     display: flex;
     justify-content: space-around;
@@ -698,6 +993,7 @@ tr:hover td { background: var(--bg-hover); }
     width: 100%;
     height: 100%;
   }
+
   .mobile-nav-item {
     display: flex;
     flex-direction: column;
@@ -717,10 +1013,12 @@ tr:hover td { background: var(--bg-hover); }
     cursor: pointer;
     font-family: var(--font-sans);
   }
+
   .mobile-nav-item svg {
     width: 20px;
     height: 20px;
   }
+
   .mobile-nav-item.active,
   .mobile-nav-item:hover {
     color: var(--accent);
@@ -734,6 +1032,7 @@ tr:hover td { background: var(--bg-hover); }
     z-index: 400;
     animation: fadeIn 0.2s ease;
   }
+
   .mobile-drawer {
     position: fixed;
     bottom: 0;
@@ -747,10 +1046,17 @@ tr:hover td { background: var(--bg-hover); }
     overflow-y: auto;
     animation: slideUp 0.25s ease;
   }
+
   @keyframes slideUp {
-    from { transform: translateY(100%); }
-    to { transform: translateY(0); }
+    from {
+      transform: translateY(100%);
+    }
+
+    to {
+      transform: translateY(0);
+    }
   }
+
   .mobile-drawer-handle {
     width: 36px;
     height: 4px;
@@ -758,6 +1064,7 @@ tr:hover td { background: var(--bg-hover); }
     border-radius: 2px;
     margin: 0 auto 1rem;
   }
+
   .mobile-drawer .sidebar-link {
     width: 100%;
     padding: 0.75rem 1rem;
@@ -766,14 +1073,17 @@ tr:hover td { background: var(--bg-hover); }
     border-radius: var(--radius-md);
     opacity: 1;
   }
+
   .mobile-drawer .sidebar-link .sidebar-label {
     opacity: 1;
     transform: none;
   }
+
   .mobile-drawer .sidebar-link .sidebar-icon {
     width: 22px;
     height: 22px;
   }
+
   .mobile-drawer .sidebar-section-label {
     opacity: 1;
     padding: 0.5rem 1rem 0.25rem;
@@ -785,13 +1095,16 @@ tr:hover td { background: var(--bg-hover); }
     padding: 1.25rem 1rem !important;
     max-width: 100%;
   }
+
   .page-header {
     margin-bottom: 1.25rem;
     padding-bottom: 1rem;
   }
+
   .page-header h1 {
     font-size: 1.5rem !important;
   }
+
   .page-header p {
     font-size: 0.85rem;
   }
@@ -809,12 +1122,14 @@ tr:hover td { background: var(--bg-hover); }
     padding: 1.125rem !important;
     border-radius: var(--radius-md);
   }
+
   .card-header {
     margin-bottom: 1rem;
     padding-bottom: 0.75rem;
     flex-wrap: wrap;
     gap: 0.5rem;
   }
+
   .card-header h3 {
     font-size: 0.88rem;
   }
@@ -827,7 +1142,9 @@ tr:hover td { background: var(--bg-hover); }
     border-right: none;
     -webkit-overflow-scrolling: touch;
   }
-  th, td {
+
+  th,
+  td {
     padding: 0.5rem 0.625rem;
     font-size: 0.72rem;
     white-space: nowrap;
@@ -840,9 +1157,17 @@ tr:hover td { background: var(--bg-hover); }
   }
 
   /* ── Metrics ───────────────────────────────────────────────────────── */
-  .metric { padding: 0.875rem 0.75rem; }
-  .metric-value { font-size: 1.375rem; }
-  .metric-label { font-size: 0.6rem; }
+  .metric {
+    padding: 0.875rem 0.75rem;
+  }
+
+  .metric-value {
+    font-size: 1.375rem;
+  }
+
+  .metric-label {
+    font-size: 0.6rem;
+  }
 
   /* ── Tabs ───────────────────────────────────────────────────────────── */
   .tabs {
@@ -853,7 +1178,11 @@ tr:hover td { background: var(--bg-hover); }
     margin-bottom: 1.25rem;
     scrollbar-width: none;
   }
-  .tabs::-webkit-scrollbar { display: none; }
+
+  .tabs::-webkit-scrollbar {
+    display: none;
+  }
+
   .tab {
     padding: 0.625rem 0.875rem;
     font-size: 0.7rem;
@@ -867,9 +1196,13 @@ tr:hover td { background: var(--bg-hover); }
   }
 
   /* ── Forms ─────────────────────────────────────────────────────────── */
-  .input, select, textarea {
-    font-size: 16px; /* prevents iOS zoom on focus */
+  .input,
+  select,
+  textarea {
+    font-size: 16px;
+    /* prevents iOS zoom on focus */
   }
+
   .form-group label {
     font-size: 0.7rem;
   }
@@ -901,7 +1234,11 @@ tr:hover td { background: var(--bg-hover); }
     width: 40px;
     height: 40px;
   }
-  .icon-box svg { width: 18px; height: 18px; }
+
+  .icon-box svg {
+    width: 18px;
+    height: 18px;
+  }
 
   /* ═════════════════════════════════════════════════════════════════════
      PAGE-SPECIFIC MOBILE OVERRIDES
@@ -911,30 +1248,38 @@ tr:hover td { background: var(--bg-hover); }
   .landing-header {
     padding: 0.875rem 1rem !important;
   }
+
   .landing-header .brand-text {
     font-size: 1.1rem;
   }
+
   .landing-hero {
     min-height: 80vh !important;
     padding: 1rem !important;
   }
+
   .landing-hero h1 {
     font-size: clamp(1.75rem, 7vw, 2.5rem) !important;
     line-height: 1.2 !important;
   }
+
   .landing-hero p {
     font-size: 0.9rem !important;
   }
+
   .landing-hero .flex-gap {
     flex-direction: column;
     width: 100%;
   }
+
   .landing-hero .flex-gap .btn {
     width: 100%;
   }
+
   .landing-section {
     padding: 3rem 1.25rem !important;
   }
+
   .landing-footer {
     flex-direction: column !important;
     gap: 0.5rem;
@@ -946,10 +1291,12 @@ tr:hover td { background: var(--bg-hover); }
   .auth-container {
     flex-direction: column !important;
   }
+
   .auth-card {
     padding: 2rem 1.25rem !important;
     min-height: 100vh;
   }
+
   .auth-image {
     display: none !important;
   }
@@ -958,6 +1305,7 @@ tr:hover td { background: var(--bg-hover); }
   .dashboard-ticker-strip {
     gap: 0.375rem !important;
   }
+
   .dashboard-ticker-strip button {
     min-width: 120px !important;
     padding: 0.5rem 0.625rem !important;
@@ -968,20 +1316,25 @@ tr:hover td { background: var(--bg-hover); }
     flex-direction: column !important;
     gap: 0.75rem !important;
   }
+
   .market-search-bar .input {
     width: 100% !important;
   }
+
   .market-search-bar select {
     width: 100% !important;
   }
+
   .market-tabs {
     overflow-x: auto !important;
     flex-wrap: nowrap !important;
   }
+
   .ticker-chips {
     flex-wrap: wrap !important;
     gap: 0.375rem !important;
   }
+
   .company-info-grid {
     grid-template-columns: 1fr 1fr !important;
     gap: 0.625rem !important;
@@ -992,6 +1345,7 @@ tr:hover td { background: var(--bg-hover); }
     flex-direction: column !important;
     gap: 0.75rem !important;
   }
+
   .factor-input-bar .input {
     width: 100% !important;
   }
@@ -1006,6 +1360,7 @@ tr:hover td { background: var(--bg-hover); }
     flex-direction: column !important;
     gap: 0.5rem !important;
   }
+
   .holdings-actions .btn {
     width: 100%;
   }
@@ -1025,6 +1380,7 @@ tr:hover td { background: var(--bg-hover); }
   .recharts-wrapper {
     font-size: 0.7rem;
   }
+
   .recharts-cartesian-axis-tick-value {
     font-size: 0.65rem;
   }
@@ -1034,9 +1390,11 @@ tr:hover td { background: var(--bg-hover); }
   [style*="grid-template-columns: repeat"] {
     grid-template-columns: 1fr !important;
   }
+
   [style*="gridTemplateColumns"] {
     grid-template-columns: 1fr !important;
   }
+
   [style*="padding: 6rem 3rem"],
   [style*="padding:'6rem 3rem'"] {
     padding: 3rem 1.25rem !important;
@@ -1049,9 +1407,1207 @@ tr:hover td { background: var(--bg-hover); }
 }
 
 /* ── Scrollbar ───────────────────────────────────────────────────────── */
-::-webkit-scrollbar { width: 6px; height: 6px; }
-::-webkit-scrollbar-track { background: var(--bg-secondary); }
-::-webkit-scrollbar-thumb { background: var(--border-color); border-radius: 3px; }
-::-webkit-scrollbar-thumb:hover { background: var(--accent); }
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
 
-::selection { background: rgba(0, 82, 65, 0.15); color: var(--text-primary); }
+::-webkit-scrollbar-track {
+  background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--border-color);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--accent);
+}
+
+::selection {
+  background: rgba(0, 82, 65, 0.15);
+  color: var(--text-primary);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Shared Base Styles — page-container, loading-spinner, data-table
+   ═══════════════════════════════════════════════════════════════════════ */
+.page-container {
+  flex: 1;
+  padding: 2.5rem 3rem;
+  max-width: 1320px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.page-subtitle {
+  color: var(--text-secondary);
+  font-size: 0.95rem;
+  margin-top: 0.25rem;
+}
+
+.loading-spinner {
+  width: 32px;
+  height: 32px;
+  border: 3px solid var(--border-color);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+  margin: 3rem auto;
+}
+
+.alert-card {
+  padding: 1.5rem;
+  border-radius: var(--radius-lg);
+  background: var(--bg-secondary);
+  color: var(--text-secondary);
+  text-align: center;
+  border: 1px solid var(--border-color);
+}
+
+.alert-card.error {
+  background: var(--error-bg);
+  border-color: var(--error-border);
+  color: var(--red-negative);
+}
+
+.data-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.data-table th {
+  padding: 0.625rem 1rem;
+  text-align: left;
+  font-size: 0.7rem;
+  font-weight: 700;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  background: var(--bg-secondary);
+  border-bottom: 2px solid var(--border-color);
+}
+
+.data-table td {
+  padding: 0.625rem 1rem;
+  font-size: 0.82rem;
+  border-bottom: 1px solid var(--border-subtle);
+  font-family: var(--font-mono);
+  font-size: 0.78rem;
+}
+
+.data-table tr:hover td {
+  background: var(--bg-hover);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Portfolio Health Score Page
+   ═══════════════════════════════════════════════════════════════════════ */
+.health-top-row {
+  display: grid;
+  grid-template-columns: 260px 1fr;
+  gap: 1.5rem;
+  margin-top: 1.5rem;
+}
+
+.health-gauge-card {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.health-gauge {
+  position: relative;
+  width: 160px;
+  height: 160px;
+}
+
+.gauge-svg {
+  width: 100%;
+  height: 100%;
+  transform: rotate(-90deg);
+}
+
+.gauge-center {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.gauge-score {
+  font-size: 2.5rem;
+  font-weight: 700;
+  font-family: var(--font-mono);
+  line-height: 1;
+}
+
+.gauge-grade {
+  font-size: 1.25rem;
+  font-weight: 700;
+  margin-top: 0.25rem;
+}
+
+.gauge-meta {
+  display: flex;
+  align-items: center;
+  gap: 0;
+  margin-top: 1.25rem;
+}
+
+.gauge-meta-item {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 0 1rem;
+}
+
+.gauge-meta-value {
+  font-family: var(--font-mono);
+  font-weight: 700;
+  font-size: 0.88rem;
+}
+
+.gauge-meta-label {
+  font-size: 0.65rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--text-muted);
+  margin-top: 0.125rem;
+}
+
+.gauge-meta-divider {
+  width: 1px;
+  height: 28px;
+  background: var(--border-color);
+}
+
+.health-chart-card {
+  overflow: hidden;
+}
+
+.health-bar-chart {
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+.hbar-row {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+}
+
+.hbar-label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.hbar-name {
+  font-size: 0.78rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.hbar-grade-pill {
+  font-size: 0.6rem;
+  font-weight: 700;
+  padding: 0.1rem 0.4rem;
+  border-radius: 3px;
+}
+
+.hbar-track-container {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.hbar-track {
+  flex: 1;
+  height: 8px;
+  background: var(--bg-tertiary);
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.hbar-fill {
+  height: 100%;
+  border-radius: 4px;
+  transition: width 0.8s ease;
+}
+
+.hbar-value {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  min-width: 24px;
+  text-align: right;
+}
+
+.health-bottom-row {
+  display: grid;
+  grid-template-columns: 1fr 1.5fr;
+  gap: 1.5rem;
+  margin-top: 1.5rem;
+}
+
+.health-radar-card {
+  display: flex;
+  flex-direction: column;
+}
+
+.radar-wrapper {
+  width: 100%;
+  max-width: 300px;
+  margin: 0 auto;
+}
+
+.radar-svg {
+  width: 100%;
+}
+
+.health-detail-card {
+  overflow-x: auto;
+}
+
+.health-tips-section {
+  margin-top: 1.5rem;
+}
+
+.health-tips-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(350px, 1fr));
+  gap: 0.75rem;
+}
+
+.health-tip-item {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.625rem;
+  padding: 0.75rem 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius-md);
+  border-left: 3px solid var(--accent);
+  font-size: 0.85rem;
+  line-height: 1.6;
+}
+
+.health-tip-icon {
+  color: var(--accent);
+  flex-shrink: 0;
+  margin-top: 0.125rem;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Behavioral Bias Detector Page
+   ═══════════════════════════════════════════════════════════════════════ */
+.bias-summary-row {
+  display: grid;
+  grid-template-columns: 1fr auto auto auto;
+  gap: 1rem;
+  margin: 1.5rem 0;
+}
+
+.bias-score-card {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.bias-score-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+}
+
+.bias-score-label {
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--text-muted);
+  font-weight: 600;
+}
+
+.bias-score-value {
+  font-size: 2rem;
+  font-weight: 700;
+  font-family: var(--font-mono);
+}
+
+.bias-score-bar-track {
+  height: 6px;
+  background: var(--bg-tertiary);
+  border-radius: 3px;
+  overflow: hidden;
+}
+
+.bias-score-bar-fill {
+  height: 100%;
+  border-radius: 3px;
+  transition: width 0.8s ease;
+}
+
+.bias-score-grade {
+  font-size: 0.78rem;
+  font-weight: 600;
+  margin-top: 0.25rem;
+}
+
+.bias-stat-card {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 0.375rem;
+  min-width: 90px;
+}
+
+.bias-stat-value {
+  font-family: var(--font-mono);
+  font-size: 1.5rem;
+  font-weight: 700;
+}
+
+.bias-stat-label {
+  font-size: 0.65rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--text-muted);
+  font-weight: 600;
+}
+
+.bias-stacked-chart {
+  margin-bottom: 1.5rem;
+}
+
+.bias-chart-bars {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.bias-chart-row {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.bias-chart-name {
+  width: 140px;
+  font-size: 0.78rem;
+  font-weight: 600;
+  flex-shrink: 0;
+  text-align: right;
+}
+
+.bias-chart-track {
+  flex: 1;
+  height: 10px;
+  background: var(--bg-tertiary);
+  border-radius: 5px;
+  overflow: hidden;
+}
+
+.bias-chart-fill {
+  height: 100%;
+  border-radius: 5px;
+  transition: width 0.8s ease;
+}
+
+.bias-chart-val {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  font-weight: 600;
+  min-width: 28px;
+}
+
+.bias-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
+  gap: 1.25rem;
+}
+
+.bias-detail-card {
+  overflow: hidden;
+}
+
+.bias-detail-top {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.bias-detail-top h3 {
+  font-size: 0.92rem;
+  margin-bottom: 0.25rem;
+}
+
+.bias-detail-desc {
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  line-height: 1.5;
+}
+
+.bias-badge-group {
+  flex-shrink: 0;
+}
+
+.bias-severity-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.375rem;
+  padding: 0.25rem 0.625rem;
+  border-radius: 3px;
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+}
+
+.bias-detail-meter {
+  margin-bottom: 0.75rem;
+}
+
+.bias-detail-meter-track {
+  height: 5px;
+  background: var(--bg-tertiary);
+  border-radius: 3px;
+  overflow: hidden;
+}
+
+.bias-detail-meter-fill {
+  height: 100%;
+  border-radius: 3px;
+  transition: width 0.8s ease;
+}
+
+.bias-detail-meta {
+  display: flex;
+  justify-content: space-between;
+  margin-top: 0.375rem;
+  font-size: 0.72rem;
+  font-family: var(--font-mono);
+  color: var(--text-muted);
+}
+
+.bias-detail-text {
+  font-size: 0.78rem;
+  color: var(--text-secondary);
+  line-height: 1.6;
+}
+
+.bias-coaching-section {
+  margin-top: 1.5rem;
+}
+
+.bias-coaching-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+.bias-coaching-item {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.75rem;
+  padding: 0.75rem 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius-md);
+  font-size: 0.85rem;
+  line-height: 1.6;
+}
+
+.bias-coaching-num {
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: white;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.7rem;
+  font-weight: 700;
+  flex-shrink: 0;
+  margin-top: 0.125rem;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Crisis Replay Page
+   ═══════════════════════════════════════════════════════════════════════ */
+.crisis-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 1rem;
+  margin: 1.5rem 0;
+}
+
+.crisis-card {
+  cursor: pointer;
+  text-align: left;
+  transition: all var(--transition-fast);
+  border: 1px solid var(--border-color);
+  background: var(--bg-card);
+}
+
+.crisis-card:hover {
+  border-color: var(--accent);
+  transform: translateY(-2px);
+  box-shadow: var(--shadow-card-hover);
+}
+
+.crisis-card.active {
+  border-color: var(--accent);
+  background: var(--accent-lighter);
+}
+
+.crisis-card-top {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 0.75rem;
+}
+
+.crisis-card-top h3 {
+  font-size: 0.85rem;
+}
+
+.crisis-card-metrics {
+  display: flex;
+  flex-direction: column;
+  gap: 0.375rem;
+}
+
+.crisis-card-metrics>div {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.crisis-metric-label {
+  font-size: 0.65rem;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  font-weight: 600;
+}
+
+.crisis-metric-value {
+  font-family: var(--font-mono);
+  font-size: 0.82rem;
+  font-weight: 600;
+}
+
+.crisis-detail-section {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.crisis-detail-header {
+  overflow: hidden;
+}
+
+.crisis-detail-title h2 {
+  font-size: 1.4rem;
+  margin-bottom: 0.375rem;
+}
+
+.crisis-detail-title p {
+  color: var(--text-secondary);
+  font-size: 0.88rem;
+  margin-bottom: 1.25rem;
+}
+
+.crisis-kpi-row {
+  display: flex;
+  gap: 0;
+  border-top: 1px solid var(--border-subtle);
+}
+
+.crisis-kpi {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  padding: 1rem 1.25rem;
+  border-right: 1px solid var(--border-subtle);
+}
+
+.crisis-kpi:last-child {
+  border-right: none;
+}
+
+.crisis-kpi-label {
+  font-size: 0.65rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--text-muted);
+  font-weight: 600;
+}
+
+.crisis-kpi-value {
+  font-family: var(--font-mono);
+  font-weight: 700;
+  font-size: 0.95rem;
+}
+
+.crisis-chart-container {
+  width: 100%;
+}
+
+.crisis-equity-svg {
+  width: 100%;
+  height: auto;
+  display: block;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Portfolio DNA Fingerprint Page
+   ═══════════════════════════════════════════════════════════════════════ */
+.dna-style-header {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin: 1rem 0;
+  flex-wrap: wrap;
+}
+
+.dna-style-chip,
+.dna-match-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 1rem;
+  background: var(--accent-lighter);
+  border-radius: var(--radius-md);
+  font-size: 0.82rem;
+  color: var(--text-secondary);
+}
+
+.dna-style-chip strong,
+.dna-match-chip strong {
+  color: var(--accent);
+}
+
+.dna-layout {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 1.5rem;
+}
+
+.dna-radar-card {
+  display: flex;
+  flex-direction: column;
+}
+
+.dna-radar-wrapper {
+  width: 100%;
+  max-width: 320px;
+  margin: 0 auto;
+}
+
+.dna-radar-svg {
+  width: 100%;
+}
+
+.dna-legend {
+  display: flex;
+  gap: 1rem;
+  font-size: 0.72rem;
+  color: var(--text-secondary);
+}
+
+.dna-legend-item {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+}
+
+.dna-legend-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+}
+
+.dna-dims-card h3 {
+  margin-bottom: 1.25rem;
+}
+
+.dna-dim-row {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 0.875rem;
+}
+
+.dna-dim-label {
+  width: 110px;
+  font-size: 0.78rem;
+  font-weight: 500;
+  flex-shrink: 0;
+}
+
+.dna-dim-bar-track {
+  flex: 1;
+  height: 8px;
+  background: var(--bg-tertiary);
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.dna-dim-bar {
+  height: 100%;
+  background: var(--accent);
+  border-radius: 4px;
+  transition: width 0.8s ease;
+}
+
+.dna-dim-value {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  color: var(--text-secondary);
+  min-width: 28px;
+  text-align: right;
+}
+
+.dna-comparison-chart-card {
+  grid-column: span 2;
+}
+
+.dna-comparison-chart-wrapper {
+  width: 100%;
+  overflow-x: auto;
+}
+
+.dna-comparison-svg {
+  width: 100%;
+  height: auto;
+  display: block;
+}
+
+.dna-compare-card {
+  grid-column: span 2;
+}
+
+.dna-compare-card h3 {
+  margin-bottom: 1rem;
+}
+
+.dna-comparison-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: 0.875rem;
+}
+
+.dna-comparison-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 1rem 1.25rem;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-lg);
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  text-align: left;
+  width: 100%;
+  font-family: var(--font-sans);
+}
+
+.dna-comparison-item:hover {
+  border-color: var(--accent);
+  background: var(--accent-lighter);
+}
+
+.dna-comparison-item.active {
+  border-color: var(--accent);
+  background: var(--accent-lighter);
+  box-shadow: 0 0 0 2px var(--accent);
+}
+
+.dna-fp-info strong {
+  display: block;
+  font-size: 0.85rem;
+  margin-bottom: 0.125rem;
+  color: var(--text-primary);
+}
+
+.dna-fp-style {
+  display: block;
+  font-size: 0.68rem;
+  color: var(--accent);
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.dna-fp-desc {
+  display: block;
+  font-size: 0.72rem;
+  color: var(--text-muted);
+  margin-top: 0.25rem;
+}
+
+.dna-similarity {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  flex-shrink: 0;
+  margin-left: 1rem;
+}
+
+.dna-sim-pct {
+  font-family: var(--font-mono);
+  font-size: 1.25rem;
+  font-weight: 700;
+  color: var(--accent);
+}
+
+.dna-sim-label {
+  font-size: 0.6rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--text-muted);
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   HedgeAIChat Page
+   ═══════════════════════════════════════════════════════════════════════ */
+.copilot-page {
+  display: flex;
+  flex-direction: column;
+  height: calc(100vh - 2rem);
+}
+
+.copilot-header-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.copilot-status {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  font-weight: 600;
+}
+
+.copilot-status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--green-positive);
+  animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.5;
+  }
+}
+
+.copilot-chat {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
+  overflow: hidden;
+  min-height: 0;
+}
+
+.copilot-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 1.5rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+}
+
+.copilot-msg {
+  display: flex;
+  gap: 0.75rem;
+  max-width: 78%;
+  animation: fadeInUp 0.3s ease;
+}
+
+.copilot-msg-user {
+  align-self: flex-end;
+  flex-direction: row-reverse;
+}
+
+.copilot-msg-assistant {
+  align-self: flex-start;
+}
+
+.copilot-msg-avatar {
+  flex-shrink: 0;
+  width: 32px;
+  height: 32px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-subtle);
+}
+
+.copilot-msg-content {
+  max-width: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.copilot-msg-label {
+  font-size: 0.65rem;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
+  font-weight: 600;
+  margin-bottom: 0.25rem;
+}
+
+.copilot-msg-user .copilot-msg-label {
+  text-align: right;
+}
+
+.copilot-msg-text {
+  padding: 0.875rem 1.125rem;
+  border-radius: var(--radius-lg);
+  font-size: 0.85rem;
+  line-height: 1.7;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.copilot-msg-user .copilot-msg-text {
+  background: var(--accent);
+  color: white;
+  border-bottom-right-radius: 4px;
+}
+
+.copilot-msg-assistant .copilot-msg-text {
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+  border-bottom-left-radius: 4px;
+  border: 1px solid var(--border-subtle);
+}
+
+.copilot-intent-tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  margin-top: 0.375rem;
+  padding: 0.2rem 0.625rem;
+  font-size: 0.65rem;
+  font-weight: 600;
+  background: var(--accent-lighter);
+  color: var(--accent);
+  border-radius: 3px;
+}
+
+.copilot-actions {
+  display: flex;
+  gap: 0.5rem;
+  margin-top: 0.5rem;
+  flex-wrap: wrap;
+}
+
+.copilot-action-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.375rem;
+  padding: 0.375rem 0.875rem;
+  font-size: 0.75rem;
+  font-weight: 600;
+  background: transparent;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  color: var(--accent);
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  font-family: var(--font-sans);
+}
+
+.copilot-action-btn:hover {
+  background: var(--accent-lighter);
+  border-color: var(--accent);
+}
+
+.copilot-typing {
+  display: flex;
+  gap: 4px;
+  padding: 0.875rem 1.125rem;
+}
+
+.copilot-typing span {
+  width: 7px;
+  height: 7px;
+  background: var(--text-muted);
+  border-radius: 50%;
+  animation: typingBounce 1.4s infinite ease-in-out;
+}
+
+.copilot-typing span:nth-child(2) {
+  animation-delay: 0.2s;
+}
+
+.copilot-typing span:nth-child(3) {
+  animation-delay: 0.4s;
+}
+
+@keyframes typingBounce {
+
+  0%,
+  80%,
+  100% {
+    transform: scale(0.6);
+    opacity: 0.4;
+  }
+
+  40% {
+    transform: scale(1);
+    opacity: 1;
+  }
+}
+
+.copilot-input-area {
+  display: flex;
+  align-items: flex-end;
+  gap: 0.75rem;
+  padding: 1rem 1.25rem;
+  border-top: 1px solid var(--border-color);
+  background: var(--bg-primary);
+}
+
+.copilot-input {
+  flex: 1;
+  padding: 0.75rem 1rem;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+  font-family: var(--font-sans);
+  font-size: 0.85rem;
+  resize: none;
+  outline: none;
+  min-height: 44px;
+  max-height: 120px;
+  line-height: 1.5;
+}
+
+.copilot-input:focus {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px rgba(0, 82, 65, 0.1);
+}
+
+.copilot-send-btn {
+  width: 42px;
+  height: 42px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: white;
+  border: none;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all var(--transition-fast);
+  flex-shrink: 0;
+}
+
+.copilot-send-btn:hover:not(:disabled) {
+  background: var(--accent-light);
+  transform: scale(1.05);
+}
+
+.copilot-send-btn:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+   Mobile Overrides for New Pages
+   ═══════════════════════════════════════════════════════════════════════ */
+@media (max-width: 768px) {
+  .page-container {
+    padding: 1.25rem 1rem !important;
+  }
+
+  .health-top-row {
+    grid-template-columns: 1fr !important;
+  }
+
+  .health-bottom-row {
+    grid-template-columns: 1fr !important;
+  }
+
+  .health-tips-grid {
+    grid-template-columns: 1fr !important;
+  }
+
+  .bias-summary-row {
+    grid-template-columns: 1fr 1fr !important;
+  }
+
+  .bias-grid {
+    grid-template-columns: 1fr !important;
+  }
+
+  .bias-chart-name {
+    width: 100px;
+    font-size: 0.7rem;
+  }
+
+  .crisis-grid {
+    grid-template-columns: 1fr 1fr !important;
+  }
+
+  .crisis-kpi-row {
+    flex-wrap: wrap;
+  }
+
+  .crisis-kpi {
+    min-width: 50%;
+    border-bottom: 1px solid var(--border-subtle);
+  }
+
+  .dna-layout {
+    grid-template-columns: 1fr !important;
+  }
+
+  .dna-comparison-chart-card,
+  .dna-compare-card {
+    grid-column: span 1 !important;
+  }
+
+  .dna-comparison-list {
+    grid-template-columns: 1fr !important;
+  }
+
+  .copilot-msg {
+    max-width: 92%;
+  }
+
+  .copilot-header-row {
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+}

frontend/src/pages/BiasDetector.tsx

@@ -0,0 +1,155 @@
+import { useState, useEffect } from 'react';
+import { holdingsAPI } from '../api/client';
+
+interface Bias {
+  name: string;
+  description: string;
+  score: number;
+  grade: string;
+  severity: string;
+  detail: string;
+  icon: string;
+}
+
+interface BiasData {
+  score: number;
+  grade: string;
+  biases: Bias[];
+  tips: string[];
+  position_count: number;
+  winners: number;
+  losers: number;
+}
+
+const severityColor = (s: string) =>
+  s === 'low' ? '#00c853' : s === 'moderate' ? '#ff9800' : s === 'high' ? '#f44336' : '#b71c1c';
+
+const severityIcon = (s: string) => {
+  if (s === 'low') return <svg viewBox="0 0 20 20" fill="currentColor" width="14" height="14"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd"/></svg>;
+  if (s === 'moderate') return <svg viewBox="0 0 20 20" fill="currentColor" width="14" height="14"><path fillRule="evenodd" d="M8.257 3.099c.765-1.36 2.722-1.36 3.486 0l5.58 9.92c.75 1.334-.213 2.98-1.742 2.98H4.42c-1.53 0-2.493-1.646-1.743-2.98l5.58-9.92zM11 13a1 1 0 11-2 0 1 1 0 012 0zm-1-8a1 1 0 00-1 1v3a1 1 0 002 0V6a1 1 0 00-1-1z" clipRule="evenodd"/></svg>;
+  return <svg viewBox="0 0 20 20" fill="currentColor" width="14" height="14"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd"/></svg>;
+};
+
+export default function BiasDetector() {
+  const [data, setData] = useState<BiasData | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => { loadBiases(); }, []);
+
+  const loadBiases = async () => {
+    try {
+      const res = await holdingsAPI.biasAnalysis();
+      setData(res.data);
+    } catch { /* ignore */ } finally { setLoading(false); }
+  };
+
+  if (loading) return <div className="page-container"><div className="loading-spinner" /></div>;
+  if (!data) return <div className="page-container"><div className="alert-card">Add holdings to analyze behavioral biases.</div></div>;
+
+  const sorted = [...data.biases].sort((a, b) => b.score - a.score);
+  const overallColor = data.grade <= 'B' ? '#00c853' : data.grade <= 'C' ? '#ff9800' : '#f44336';
+
+  return (
+    <div className="page-container">
+      <div className="page-header">
+        <h1>Behavioral Bias Detector</h1>
+        <p className="page-subtitle">Identify cognitive biases that may impact your investment decisions</p>
+      </div>
+
+      {/* Summary Row */}
+      <div className="bias-summary-row">
+        <div className="card bias-score-card">
+          <div className="bias-score-header">
+            <span className="bias-score-label">Behavioral Score</span>
+            <span className="bias-score-value" style={{ color: overallColor }}>{data.score}</span>
+          </div>
+          <div className="bias-score-bar-track">
+            <div className="bias-score-bar-fill" style={{ width: `${data.score}%`, background: `linear-gradient(90deg, ${overallColor}80, ${overallColor})` }} />
+          </div>
+          <div className="bias-score-grade" style={{ color: overallColor }}>Grade: {data.grade}</div>
+        </div>
+        <div className="card bias-stat-card">
+          <svg viewBox="0 0 20 20" fill="var(--text-muted)" width="20" height="20"><path d="M9 2a1 1 0 000 2h2a1 1 0 100-2H9z"/><path fillRule="evenodd" d="M4 5a2 2 0 012-2 3 3 0 003 3h2a3 3 0 003-3 2 2 0 012 2v11a2 2 0 01-2 2H6a2 2 0 01-2-2V5zm3 4a1 1 0 000 2h.01a1 1 0 100-2H7zm3 0a1 1 0 000 2h3a1 1 0 100-2h-3zm-3 4a1 1 0 100 2h.01a1 1 0 100-2H7zm3 0a1 1 0 100 2h3a1 1 0 100-2h-3z" clipRule="evenodd"/></svg>
+          <span className="bias-stat-value">{data.position_count}</span>
+          <span className="bias-stat-label">Positions</span>
+        </div>
+        <div className="card bias-stat-card">
+          <svg viewBox="0 0 20 20" fill="var(--green-positive)" width="20" height="20"><path fillRule="evenodd" d="M12 7a1 1 0 110-2h5a1 1 0 011 1v5a1 1 0 11-2 0V8.414l-4.293 4.293a1 1 0 01-1.414 0L8 10.414l-4.293 4.293a1 1 0 01-1.414-1.414l5-5a1 1 0 011.414 0L11 10.586 14.586 7H12z" clipRule="evenodd"/></svg>
+          <span className="bias-stat-value positive">{data.winners}</span>
+          <span className="bias-stat-label">Winners</span>
+        </div>
+        <div className="card bias-stat-card">
+          <svg viewBox="0 0 20 20" fill="var(--red-negative)" width="20" height="20"><path fillRule="evenodd" d="M12 13a1 1 0 100 2h5a1 1 0 001-1V9a1 1 0 10-2 0v2.586l-4.293-4.293a1 1 0 00-1.414 0L8 9.586 3.707 5.293a1 1 0 00-1.414 1.414l5 5a1 1 0 001.414 0L11 9.414 14.586 13H12z" clipRule="evenodd"/></svg>
+          <span className="bias-stat-value negative">{data.losers}</span>
+          <span className="bias-stat-label">Losers</span>
+        </div>
+      </div>
+
+      {/* Stacked Bar Visualization */}
+      <div className="card bias-stacked-chart">
+        <div className="card-header">
+          <h3>Bias Severity Distribution</h3>
+        </div>
+        <div className="bias-chart-bars">
+          {sorted.map((bias) => (
+            <div key={bias.name} className="bias-chart-row">
+              <span className="bias-chart-name">{bias.name}</span>
+              <div className="bias-chart-track">
+                <div className="bias-chart-fill" style={{ width: `${bias.score}%`, background: severityColor(bias.severity) }} />
+              </div>
+              <span className="bias-chart-val" style={{ color: severityColor(bias.severity) }}>{bias.score}</span>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      {/* Bias Cards Grid */}
+      <div className="bias-grid">
+        {sorted.map((bias) => (
+          <div key={bias.name} className="card bias-detail-card">
+            <div className="bias-detail-top">
+              <div>
+                <h3>{bias.name}</h3>
+                <p className="bias-detail-desc">{bias.description}</p>
+              </div>
+              <div className="bias-badge-group">
+                <span className="bias-severity-badge" style={{ background: severityColor(bias.severity) + '15', color: severityColor(bias.severity) }}>
+                  {severityIcon(bias.severity)}
+                  <span>{bias.severity.toUpperCase()}</span>
+                </span>
+              </div>
+            </div>
+            <div className="bias-detail-meter">
+              <div className="bias-detail-meter-track">
+                <div className="bias-detail-meter-fill" style={{ width: `${bias.score}%`, background: severityColor(bias.severity) }} />
+              </div>
+              <div className="bias-detail-meta">
+                <span>Score: {bias.score}/100</span>
+                <span style={{ color: severityColor(bias.severity), fontWeight: 700 }}>{bias.grade}</span>
+              </div>
+            </div>
+            <p className="bias-detail-text">{bias.detail}</p>
+          </div>
+        ))}
+      </div>
+
+      {/* Tips */}
+      {data.tips.length > 0 && (
+        <div className="card bias-coaching-section">
+          <div className="card-header">
+            <h3>Behavioral Coaching</h3>
+            <span className="badge badge-primary">{data.tips.length} Recommendations</span>
+          </div>
+          <div className="bias-coaching-list">
+            {data.tips.map((tip, i) => (
+              <div key={i} className="bias-coaching-item">
+                <div className="bias-coaching-num">{i + 1}</div>
+                <span>{tip}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/pages/Copilot.tsx

@@ -0,0 +1,160 @@
+import { useState, useRef, useEffect } from 'react';
+import { copilotAPI } from '../api/client';
+import { useNavigate } from 'react-router-dom';
+
+interface Message {
+  id: number;
+  role: 'user' | 'assistant';
+  content: string;
+  intent?: string;
+  actions?: { label: string; route: string }[];
+  timestamp: Date;
+}
+
+const BotIcon = () => (
+  <svg viewBox="0 0 24 24" fill="none" width="18" height="18" stroke="var(--accent)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+    <rect x="3" y="11" width="18" height="10" rx="2" />
+    <circle cx="12" cy="5" r="3" />
+    <line x1="12" y1="8" x2="12" y2="11" />
+    <circle cx="8" cy="16" r="1" fill="var(--accent)" />
+    <circle cx="16" cy="16" r="1" fill="var(--accent)" />
+  </svg>
+);
+
+const UserIcon = () => (
+  <svg viewBox="0 0 20 20" fill="var(--text-muted)" width="16" height="16">
+    <path fillRule="evenodd" d="M10 9a3 3 0 100-6 3 3 0 000 6zm-7 9a7 7 0 1114 0H3z" clipRule="evenodd" />
+  </svg>
+);
+
+const SendIcon = () => (
+  <svg viewBox="0 0 24 24" fill="currentColor" width="18" height="18">
+    <path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" />
+  </svg>
+);
+
+export default function Copilot() {
+  const [messages, setMessages] = useState<Message[]>([
+    {
+      id: 0,
+      role: 'assistant',
+      content: "Welcome to the QuantHedge HedgeAI. I can help you analyze your portfolio risk, evaluate hedging strategies, run stress tests, and interpret market sentiment.\n\nTry asking:\n\n\u2022 \"How would my portfolio perform in a recession?\"\n\u2022 \"What is my biggest risk exposure?\"\n\u2022 \"Analyze sentiment for AAPL\"\n\u2022 \"Should I hedge my NVDA position?\"",
+      timestamp: new Date(),
+    },
+  ]);
+  const [input, setInput] = useState('');
+  const [loading, setLoading] = useState(false);
+  const bottomRef = useRef<HTMLDivElement>(null);
+  const navigate = useNavigate();
+
+  useEffect(() => {
+    bottomRef.current?.scrollIntoView({ behavior: 'smooth' });
+  }, [messages]);
+
+  const sendMessage = async () => {
+    if (!input.trim() || loading) return;
+    const userMsg: Message = { id: Date.now(), role: 'user', content: input.trim(), timestamp: new Date() };
+    setMessages(prev => [...prev, userMsg]);
+    setInput('');
+    setLoading(true);
+    try {
+      const res = await copilotAPI.chat(input.trim());
+      const data = res.data;
+      setMessages(prev => [...prev, {
+        id: Date.now() + 1,
+        role: 'assistant',
+        content: data.response || 'I could not process that request. Please try again.',
+        intent: data.intent,
+        actions: data.actions,
+        timestamp: new Date(),
+      }]);
+    } catch {
+      setMessages(prev => [...prev, {
+        id: Date.now() + 1,
+        role: 'assistant',
+        content: 'An error occurred while processing your request. Please try again.',
+        timestamp: new Date(),
+      }]);
+    } finally { setLoading(false); }
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendMessage(); }
+  };
+
+  const formatIntent = (intent: string) => intent.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+
+  return (
+    <div className="page-container copilot-page">
+      <div className="page-header">
+        <div className="copilot-header-row">
+          <div>
+            <h1>HedgeAI</h1>
+            <p className="page-subtitle">Natural language portfolio analysis assistant</p>
+          </div>
+          <div className="copilot-status">
+            <span className="copilot-status-dot" />
+            <span>Online</span>
+          </div>
+        </div>
+      </div>
+
+      <div className="copilot-chat">
+        <div className="copilot-messages">
+          {messages.map(msg => (
+            <div key={msg.id} className={`copilot-msg copilot-msg-${msg.role}`}>
+              <div className="copilot-msg-avatar">
+                {msg.role === 'user' ? <UserIcon /> : <BotIcon />}
+              </div>
+              <div className="copilot-msg-content">
+                <div className="copilot-msg-label">{msg.role === 'user' ? 'You' : 'QuantHedge Copilot'}</div>
+                <div className="copilot-msg-text">{msg.content}</div>
+                {msg.intent && msg.intent !== 'general' && (
+                  <div className="copilot-intent-tag">
+                    <svg viewBox="0 0 20 20" fill="currentColor" width="10" height="10"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-8.707l-3-3a1 1 0 00-1.414 0l-3 3a1 1 0 001.414 1.414L9 9.414V13a1 1 0 102 0V9.414l1.293 1.293a1 1 0 001.414-1.414z" clipRule="evenodd" /></svg>
+                    <span>{formatIntent(msg.intent)}</span>
+                  </div>
+                )}
+                {msg.actions && msg.actions.length > 0 && (
+                  <div className="copilot-actions">
+                    {msg.actions.map((a, i) => (
+                      <button key={i} className="copilot-action-btn" onClick={() => navigate(a.route)}>
+                        {a.label}
+                        <svg viewBox="0 0 20 20" fill="currentColor" width="12" height="12"><path fillRule="evenodd" d="M10.293 3.293a1 1 0 011.414 0l6 6a1 1 0 010 1.414l-6 6a1 1 0 01-1.414-1.414L14.586 11H3a1 1 0 110-2h11.586l-4.293-4.293a1 1 0 010-1.414z" clipRule="evenodd" /></svg>
+                      </button>
+                    ))}
+                  </div>
+                )}
+              </div>
+            </div>
+          ))}
+          {loading && (
+            <div className="copilot-msg copilot-msg-assistant">
+              <div className="copilot-msg-avatar"><BotIcon /></div>
+              <div className="copilot-msg-content">
+                <div className="copilot-msg-label">QuantHedge Copilot</div>
+                <div className="copilot-typing"><span /><span /><span /></div>
+              </div>
+            </div>
+          )}
+          <div ref={bottomRef} />
+        </div>
+
+        <div className="copilot-input-area">
+          <textarea
+            className="copilot-input"
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            onKeyDown={handleKeyDown}
+            placeholder="Ask about portfolio risk, hedging strategies, or market analysis..."
+            rows={1}
+            disabled={loading}
+          />
+          <button className="copilot-send-btn" onClick={sendMessage} disabled={loading || !input.trim()}>
+            <SendIcon />
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/pages/CrisisReplay.tsx

@@ -0,0 +1,226 @@
+import { useState, useEffect } from 'react';
+import { holdingsAPI } from '../api/client';
+
+interface CrisisSummary {
+  crisis_id: string;
+  name: string;
+  total_pnl: number;
+  total_pnl_pct: number;
+  max_drawdown_pct: number;
+  trading_days: number;
+}
+
+interface EquityPoint {
+  date: string;
+  portfolio_value: number;
+  daily_return: number;
+  cumulative_return: number;
+}
+
+interface CrisisDetail {
+  crisis: { name: string; description: string; start: string; end: string; peak_decline: number };
+  portfolio_value: number;
+  final_value: number;
+  total_pnl: number;
+  total_pnl_pct: number;
+  max_drawdown_pct: number;
+  equity_curve: EquityPoint[];
+  holding_impacts: { ticker: string; sector: string; impact: number; sector_return: number }[];
+}
+
+export default function CrisisReplay() {
+  const [summaries, setSummaries] = useState<CrisisSummary[]>([]);
+  const [detail, setDetail] = useState<CrisisDetail | null>(null);
+  const [selectedCrisis, setSelectedCrisis] = useState('');
+  const [loading, setLoading] = useState(true);
+  const [detailLoading, setDetailLoading] = useState(false);
+
+  useEffect(() => { loadSummaries(); }, []);
+
+  const loadSummaries = async () => {
+    try {
+      const res = await holdingsAPI.allCrisisReplays();
+      setSummaries(res.data.crises || []);
+    } catch { /* ignore */ } finally { setLoading(false); }
+  };
+
+  const loadCrisis = async (crisisId: string) => {
+    setSelectedCrisis(crisisId);
+    setDetailLoading(true);
+    try {
+      const res = await holdingsAPI.crisisReplay(crisisId);
+      setDetail(res.data);
+    } catch { /* ignore */ } finally { setDetailLoading(false); }
+  };
+
+  if (loading) return <div className="page-container"><div className="loading-spinner" /></div>;
+
+  const renderEquityCurve = () => {
+    if (!detail?.equity_curve?.length) return null;
+    const points = detail.equity_curve;
+    const values = points.map(p => p.portfolio_value);
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const range = max - min || 1;
+    const w = 700;
+    const h = 220;
+    const pad = { top: 20, right: 20, bottom: 30, left: 60 };
+    const plotW = w - pad.left - pad.right;
+    const plotH = h - pad.top - pad.bottom;
+
+    const isNeg = (detail.total_pnl || 0) < 0;
+    const lineColor = isNeg ? 'var(--red-negative)' : 'var(--green-positive)';
+
+    const pathD = points.map((p, i) => {
+      const x = pad.left + (i / (points.length - 1)) * plotW;
+      const y = pad.top + plotH - ((p.portfolio_value - min) / range) * plotH;
+      return `${i === 0 ? 'M' : 'L'} ${x} ${y}`;
+    }).join(' ');
+
+    const areaD = `${pathD} L ${pad.left + plotW} ${pad.top + plotH} L ${pad.left} ${pad.top + plotH} Z`;
+
+    // Y-axis labels
+    const ySteps = 5;
+    const yLabels = Array.from({ length: ySteps + 1 }, (_, i) => min + (range * i) / ySteps);
+
+    return (
+      <svg viewBox={`0 0 ${w} ${h}`} className="crisis-equity-svg" preserveAspectRatio="xMidYMid meet">
+        {/* Grid lines */}
+        {yLabels.map((v, i) => {
+          const y = pad.top + plotH - ((v - min) / range) * plotH;
+          return (
+            <g key={i}>
+              <line x1={pad.left} y1={y} x2={pad.left + plotW} y2={y} stroke="var(--border-subtle)" strokeWidth="0.5" />
+              <text x={pad.left - 8} y={y + 3} textAnchor="end" fill="var(--text-muted)" fontSize="8" fontFamily="var(--font-mono)">${(v / 1000).toFixed(1)}k</text>
+            </g>
+          );
+        })}
+        {/* X-axis labels (first/mid/last) */}
+        {[0, Math.floor(points.length / 2), points.length - 1].map((idx) => {
+          const x = pad.left + (idx / (points.length - 1)) * plotW;
+          const d = points[idx]?.date?.slice(5, 10) || '';
+          return <text key={idx} x={x} y={h - 5} textAnchor="middle" fill="var(--text-muted)" fontSize="8" fontFamily="var(--font-mono)">{d}</text>;
+        })}
+        {/* Area fill */}
+        <defs>
+          <linearGradient id="eqGrad" x1="0" y1="0" x2="0" y2="1">
+            <stop offset="0%" stopColor={lineColor} stopOpacity="0.2" />
+            <stop offset="100%" stopColor={lineColor} stopOpacity="0.02" />
+          </linearGradient>
+        </defs>
+        <path d={areaD} fill="url(#eqGrad)" />
+        <path d={pathD} fill="none" stroke={lineColor} strokeWidth="1.5" />
+      </svg>
+    );
+  };
+
+  // Mini sparkline for summary cards
+  const sparkline = (pnl: number) => {
+    const col = pnl < 0 ? 'var(--red-negative)' : 'var(--green-positive)';
+    const points = pnl < 0 ? 'M0,4 L8,6 L16,3 L24,8 L32,12 L40,10' : 'M0,10 L8,8 L16,6 L24,4 L32,3 L40,2';
+    return <svg viewBox="0 0 40 14" width="40" height="14" style={{ display: 'block' }}><path d={points} fill="none" stroke={col} strokeWidth="1.5" strokeLinecap="round" /></svg>;
+  };
+
+  return (
+    <div className="page-container">
+      <div className="page-header">
+        <h1>Historical Crisis Replay</h1>
+        <p className="page-subtitle">Simulate your portfolio performance during major historical market crises</p>
+      </div>
+
+      {/* Crisis Cards */}
+      <div className="crisis-grid">
+        {summaries.map((s) => (
+          <button key={s.crisis_id} className={`card crisis-card ${selectedCrisis === s.crisis_id ? 'active' : ''}`} onClick={() => loadCrisis(s.crisis_id)}>
+            <div className="crisis-card-top">
+              <h3>{s.name}</h3>
+              {sparkline(s.total_pnl_pct)}
+            </div>
+            <div className="crisis-card-metrics">
+              <div>
+                <span className="crisis-metric-label">Impact</span>
+                <span className={`crisis-metric-value ${s.total_pnl_pct < 0 ? 'negative' : 'positive'}`}>{s.total_pnl_pct > 0 ? '+' : ''}{s.total_pnl_pct.toFixed(1)}%</span>
+              </div>
+              <div>
+                <span className="crisis-metric-label">Max DD</span>
+                <span className="crisis-metric-value negative">{s.max_drawdown_pct.toFixed(1)}%</span>
+              </div>
+              <div>
+                <span className="crisis-metric-label">Duration</span>
+                <span className="crisis-metric-value">{s.trading_days}d</span>
+              </div>
+            </div>
+          </button>
+        ))}
+      </div>
+
+      {/* Detail View */}
+      {detailLoading && <div className="loading-spinner" />}
+      {detail && !detailLoading && (
+        <div className="crisis-detail-section">
+          {/* Header + Key Metrics */}
+          <div className="card crisis-detail-header">
+            <div className="crisis-detail-title">
+              <h2>{detail.crisis.name}</h2>
+              <p>{detail.crisis.description}</p>
+            </div>
+            <div className="crisis-kpi-row">
+              <div className="crisis-kpi">
+                <span className="crisis-kpi-label">Period</span>
+                <span className="crisis-kpi-value">{detail.crisis.start} — {detail.crisis.end}</span>
+              </div>
+              <div className="crisis-kpi">
+                <span className="crisis-kpi-label">Portfolio Impact</span>
+                <span className={`crisis-kpi-value ${detail.total_pnl < 0 ? 'negative' : 'positive'}`}>${detail.total_pnl.toLocaleString(undefined, { maximumFractionDigits: 0 })}</span>
+              </div>
+              <div className="crisis-kpi">
+                <span className="crisis-kpi-label">Return</span>
+                <span className={`crisis-kpi-value ${detail.total_pnl_pct < 0 ? 'negative' : 'positive'}`}>{detail.total_pnl_pct > 0 ? '+' : ''}{detail.total_pnl_pct.toFixed(2)}%</span>
+              </div>
+              <div className="crisis-kpi">
+                <span className="crisis-kpi-label">Max Drawdown</span>
+                <span className="crisis-kpi-value negative">{detail.max_drawdown_pct.toFixed(2)}%</span>
+              </div>
+            </div>
+          </div>
+
+          {/* Equity Curve Chart */}
+          <div className="card">
+            <div className="card-header">
+              <h3>Portfolio Equity Curve</h3>
+              <span className="badge badge-primary">{detail.equity_curve?.length || 0} Trading Days</span>
+            </div>
+            <div className="crisis-chart-container">{renderEquityCurve()}</div>
+          </div>
+
+          {/* Per-Holding Impact Table */}
+          <div className="card">
+            <div className="card-header">
+              <h3>Per-Holding Impact Analysis</h3>
+            </div>
+            <table className="data-table">
+              <thead>
+                <tr>
+                  <th>Ticker</th>
+                  <th>Sector</th>
+                  <th>Sector Return</th>
+                  <th>Dollar Impact</th>
+                </tr>
+              </thead>
+              <tbody>
+                {detail.holding_impacts?.sort((a, b) => a.impact - b.impact).map((h) => (
+                  <tr key={h.ticker}>
+                    <td style={{ fontWeight: 700 }}>{h.ticker}</td>
+                    <td style={{ fontFamily: 'var(--font-sans)', textTransform: 'capitalize' }}>{h.sector}</td>
+                    <td className={h.sector_return < 0 ? 'negative' : 'positive'}>{h.sector_return > 0 ? '+' : ''}{h.sector_return.toFixed(1)}%</td>
+                    <td className={h.impact < 0 ? 'negative' : 'positive'}>${h.impact.toLocaleString(undefined, { maximumFractionDigits: 0 })}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/pages/PortfolioDNA.tsx

@@ -0,0 +1,218 @@
+import { useState, useEffect } from 'react';
+import { holdingsAPI } from '../api/client';
+
+interface DNAProfile {
+  [key: string]: number;
+}
+
+interface FamousPortfolio {
+  id: string;
+  name: string;
+  description: string;
+  style: string;
+  similarity: number;
+  dna: DNAProfile;
+}
+
+interface DNAData {
+  dna: DNAProfile;
+  style: string;
+  dominant_trait: string;
+  closest_match: FamousPortfolio | null;
+  comparisons: FamousPortfolio[];
+  position_count: number;
+}
+
+const DIMENSION_LABELS: Record<string, string> = {
+  momentum: 'Momentum',
+  value: 'Value',
+  volatility: 'Volatility',
+  regime_sensitivity: 'Regime Sens.',
+  concentration: 'Concentration',
+  hedge_coverage: 'Hedge Coverage',
+};
+
+export default function PortfolioDNA() {
+  const [data, setData] = useState<DNAData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [overlayId, setOverlayId] = useState<string | null>(null);
+
+  useEffect(() => { loadDNA(); }, []);
+
+  const loadDNA = async () => {
+    try {
+      const res = await holdingsAPI.portfolioDNA();
+      setData(res.data);
+    } catch { /* ignore */ } finally { setLoading(false); }
+  };
+
+  if (loading) return <div className="page-container"><div className="loading-spinner" /></div>;
+  if (!data?.dna) return <div className="page-container"><div className="alert-card">Add holdings to compute your Portfolio DNA fingerprint.</div></div>;
+
+  const dims = Object.keys(data.dna).sort();
+  const overlayFP = data.comparisons.find(c => c.id === overlayId);
+
+  const renderRadar = () => {
+    const w = 320, cx = 160, cy = 160, R = 120;
+    return (
+      <svg viewBox={`0 0 ${w} ${w}`} className="dna-radar-svg">
+        {[20, 40, 60, 80, 100].map(r => (
+          <polygon key={r} points={dims.map((_, i) => {
+            const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+            return `${cx + R * (r/100) * Math.cos(a)},${cy + R * (r/100) * Math.sin(a)}`;
+          }).join(' ')} fill="none" stroke="var(--border-subtle)" strokeWidth="0.5" opacity={0.4} />
+        ))}
+        {dims.map((_, i) => {
+          const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+          return <line key={i} x1={cx} y1={cy} x2={cx + R * Math.cos(a)} y2={cy + R * Math.sin(a)} stroke="var(--border-subtle)" strokeWidth="0.5" opacity={0.25} />;
+        })}
+        {/* Overlay */}
+        {overlayFP && (
+          <polygon points={dims.map((d, i) => {
+            const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+            const r = (overlayFP.dna[d] || 0) / 100;
+            return `${cx + R * r * Math.cos(a)},${cy + R * r * Math.sin(a)}`;
+          }).join(' ')} fill="rgba(255,152,0,0.08)" stroke="#ff9800" strokeWidth="1.5" strokeDasharray="4 2" />
+        )}
+        {/* User DNA */}
+        <polygon points={dims.map((d, i) => {
+          const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+          const r = data.dna[d] / 100;
+          return `${cx + R * r * Math.cos(a)},${cy + R * r * Math.sin(a)}`;
+        }).join(' ')} fill="var(--accent)" fillOpacity="0.1" stroke="var(--accent)" strokeWidth="2" />
+        {dims.map((d, i) => {
+          const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+          const r = data.dna[d] / 100;
+          return <circle key={d} cx={cx + R * r * Math.cos(a)} cy={cy + R * r * Math.sin(a)} r="3.5" fill="var(--accent)" />;
+        })}
+        {dims.map((d, i) => {
+          const a = (Math.PI * 2 * i) / dims.length - Math.PI / 2;
+          return <text key={d} x={cx + (R + 18) * Math.cos(a)} y={cy + (R + 18) * Math.sin(a)} textAnchor="middle" dominantBaseline="middle" fill="var(--text-secondary)" fontSize="9" fontWeight="500">{DIMENSION_LABELS[d] || d}</text>;
+        })}
+      </svg>
+    );
+  };
+
+  // Grouped bar chart: user vs closest match
+  const renderComparisonBars = () => {
+    const match = data.closest_match || data.comparisons[0];
+    if (!match) return null;
+    const barH = 20;
+    const gap = 8;
+    const rowH = barH * 2 + gap + 16;
+    const svgH = dims.length * rowH + 20;
+    const labelW = 90;
+    const barW = 260;
+
+    return (
+      <svg viewBox={`0 0 ${labelW + barW + 50} ${svgH}`} className="dna-comparison-svg">
+        {dims.map((d, i) => {
+          const y = i * rowH + 10;
+          const userVal = data.dna[d] || 0;
+          const matchVal = match.dna[d] || 0;
+          return (
+            <g key={d}>
+              <text x={labelW - 8} y={y + barH / 2 + 4} textAnchor="end" fill="var(--text-secondary)" fontSize="9" fontWeight="500">{DIMENSION_LABELS[d] || d}</text>
+              <rect x={labelW} y={y} width={(userVal / 100) * barW} height={barH} rx="3" fill="var(--accent)" opacity="0.8" />
+              <text x={labelW + (userVal / 100) * barW + 6} y={y + barH / 2 + 3} fill="var(--text-secondary)" fontSize="8" fontFamily="var(--font-mono)">{userVal}</text>
+              <rect x={labelW} y={y + barH + 2} width={(matchVal / 100) * barW} height={barH} rx="3" fill="#ff9800" opacity="0.6" />
+              <text x={labelW + (matchVal / 100) * barW + 6} y={y + barH + 2 + barH / 2 + 3} fill="var(--text-muted)" fontSize="8" fontFamily="var(--font-mono)">{matchVal}</text>
+            </g>
+          );
+        })}
+      </svg>
+    );
+  };
+
+  return (
+    <div className="page-container">
+      <div className="page-header">
+        <h1>Portfolio DNA Fingerprint</h1>
+        <p className="page-subtitle">Your investing style decoded and compared against legendary investors</p>
+      </div>
+
+      {/* Style Badge */}
+      <div className="dna-style-header">
+        <div className="dna-style-chip">
+          <svg viewBox="0 0 20 20" fill="var(--accent)" width="16" height="16"><path d="M10 3.5a1.5 1.5 0 013 0V4a1 1 0 001 1h3a1 1 0 011 1v3a1 1 0 01-1 1h-.5a1.5 1.5 0 000 3h.5a1 1 0 011 1v3a1 1 0 01-1 1h-3a1 1 0 01-1-1v-.5a1.5 1.5 0 00-3 0v.5a1 1 0 01-1 1H6a1 1 0 01-1-1v-3a1 1 0 00-1-1h-.5a1.5 1.5 0 010-3H4a1 1 0 001-1V6a1 1 0 011-1h3a1 1 0 001-1v-.5z"/></svg>
+          <span>Investing Style: <strong>{data.style}</strong></span>
+        </div>
+        {data.closest_match && (
+          <div className="dna-match-chip">
+            <svg viewBox="0 0 20 20" fill="var(--accent)" width="14" height="14"><path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd"/></svg>
+            <span>Closest Match: <strong>{data.closest_match.name}</strong> ({data.closest_match.similarity.toFixed(0)}%)</span>
+          </div>
+        )}
+      </div>
+
+      <div className="dna-layout">
+        {/* Radar Chart */}
+        <div className="card dna-radar-card">
+          <div className="card-header">
+            <h3>DNA Profile</h3>
+            {overlayFP && (
+              <div className="dna-legend">
+                <span className="dna-legend-item"><span className="dna-legend-dot" style={{ background: 'var(--accent)' }} /> You</span>
+                <span className="dna-legend-item"><span className="dna-legend-dot" style={{ background: '#ff9800' }} /> {overlayFP.name}</span>
+              </div>
+            )}
+          </div>
+          <div className="dna-radar-wrapper">{renderRadar()}</div>
+        </div>
+
+        {/* Dimension Bars */}
+        <div className="card dna-dims-card">
+          <div className="card-header">
+            <h3>Dimension Scores</h3>
+          </div>
+          {dims.map(d => (
+            <div key={d} className="dna-dim-row">
+              <span className="dna-dim-label">{DIMENSION_LABELS[d] || d}</span>
+              <div className="dna-dim-bar-track">
+                <div className="dna-dim-bar" style={{ width: `${data.dna[d]}%` }} />
+              </div>
+              <span className="dna-dim-value">{data.dna[d]}</span>
+            </div>
+          ))}
+        </div>
+
+        {/* Comparison Chart */}
+        {data.closest_match && (
+          <div className="card dna-comparison-chart-card">
+            <div className="card-header">
+              <h3>You vs {data.closest_match.name}</h3>
+              <div className="dna-legend">
+                <span className="dna-legend-item"><span className="dna-legend-dot" style={{ background: 'var(--accent)' }} /> Your Portfolio</span>
+                <span className="dna-legend-item"><span className="dna-legend-dot" style={{ background: '#ff9800' }} /> {data.closest_match.name}</span>
+              </div>
+            </div>
+            <div className="dna-comparison-chart-wrapper">{renderComparisonBars()}</div>
+          </div>
+        )}
+
+        {/* Famous Portfolios */}
+        <div className="card dna-compare-card">
+          <div className="card-header">
+            <h3>Famous Portfolio Comparisons</h3>
+            <span className="badge badge-primary">{data.comparisons.length} Benchmarks</span>
+          </div>
+          <div className="dna-comparison-list">
+            {data.comparisons.map(fp => (
+              <button key={fp.id} className={`dna-comparison-item ${overlayId === fp.id ? 'active' : ''}`} onClick={() => setOverlayId(overlayId === fp.id ? null : fp.id)}>
+                <div className="dna-fp-info">
+                  <strong>{fp.name}</strong>
+                  <span className="dna-fp-style">{fp.style}</span>
+                  <span className="dna-fp-desc">{fp.description}</span>
+                </div>
+                <div className="dna-similarity">
+                  <span className="dna-sim-pct">{fp.similarity.toFixed(0)}%</span>
+                  <span className="dna-sim-label">match</span>
+                </div>
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/pages/PortfolioHealth.tsx

@@ -0,0 +1,216 @@
+import { useState, useEffect } from 'react';
+import { holdingsAPI } from '../api/client';
+
+interface HealthComponent {
+  name: string;
+  score: number;
+  weight: number;
+  grade: string;
+  detail: string;
+}
+
+interface HealthData {
+  score: number;
+  grade: string;
+  grade_color: string;
+  components: HealthComponent[];
+  tips: string[];
+  position_count: number;
+  total_value: number;
+}
+
+const gradeColor = (grade: string) =>
+  grade.startsWith('A') ? '#00c853' : grade.startsWith('B') ? '#2196f3' : grade.startsWith('C') ? '#ff9800' : '#f44336';
+
+export default function PortfolioHealth() {
+  const [data, setData] = useState<HealthData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState('');
+
+  useEffect(() => { loadHealth(); }, []);
+
+  const loadHealth = async () => {
+    setLoading(true);
+    try {
+      const res = await holdingsAPI.healthScore();
+      setData(res.data);
+    } catch (e: any) {
+      setError(e.response?.data?.detail || 'Failed to load health score');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (loading) return <div className="page-container"><div className="loading-spinner" /></div>;
+  if (error) return <div className="page-container"><div className="alert-card error">{error}</div></div>;
+  if (!data) return null;
+
+  const circumference = 2 * Math.PI * 70;
+  const filled = (data.score / 100) * circumference;
+
+  // Bar chart data for component scores
+  const sortedComponents = [...data.components].sort((a, b) => b.score - a.score);
+
+  return (
+    <div className="page-container">
+      <div className="page-header">
+        <h1>Portfolio Health Score</h1>
+        <p className="page-subtitle">Comprehensive portfolio assessment across 7 risk-adjusted dimensions</p>
+      </div>
+
+      {/* Top Summary Row */}
+      <div className="health-top-row">
+        <div className="card health-gauge-card">
+          <div className="health-gauge">
+            <svg viewBox="0 0 160 160" className="gauge-svg">
+              <circle cx="80" cy="80" r="70" fill="none" stroke="var(--border-subtle)" strokeWidth="10" />
+              <circle
+                cx="80" cy="80" r="70" fill="none"
+                stroke={data.grade_color || gradeColor(data.grade)}
+                strokeWidth="10"
+                strokeDasharray={`${filled} ${circumference}`}
+                strokeDashoffset={circumference * 0.25}
+                strokeLinecap="round"
+                style={{ transition: 'stroke-dasharray 1s ease' }}
+              />
+            </svg>
+            <div className="gauge-center">
+              <span className="gauge-score">{data.score}</span>
+              <span className="gauge-grade" style={{ color: data.grade_color || gradeColor(data.grade) }}>{data.grade}</span>
+            </div>
+          </div>
+          <div className="gauge-meta">
+            <div className="gauge-meta-item">
+              <span className="gauge-meta-value">{data.position_count}</span>
+              <span className="gauge-meta-label">Positions</span>
+            </div>
+            <div className="gauge-meta-divider" />
+            <div className="gauge-meta-item">
+              <span className="gauge-meta-value">${(data.total_value || 0).toLocaleString()}</span>
+              <span className="gauge-meta-label">Total Value</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Component Scores Bar Chart */}
+        <div className="card health-chart-card">
+          <div className="card-header">
+            <h3>Component Breakdown</h3>
+            <span className="badge badge-primary">7 Dimensions</span>
+          </div>
+          <div className="health-bar-chart">
+            {sortedComponents.map((c) => (
+              <div key={c.name} className="hbar-row">
+                <div className="hbar-label">
+                  <span className="hbar-name">{c.name}</span>
+                  <span className="hbar-grade-pill" style={{ background: gradeColor(c.grade) + '18', color: gradeColor(c.grade) }}>{c.grade}</span>
+                </div>
+                <div className="hbar-track-container">
+                  <div className="hbar-track">
+                    <div className="hbar-fill" style={{ width: `${c.score}%`, background: `linear-gradient(90deg, ${gradeColor(c.grade)}80, ${gradeColor(c.grade)})` }} />
+                  </div>
+                  <span className="hbar-value">{c.score}</span>
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {/* Radar + Details Row */}
+      <div className="health-bottom-row">
+        {/* Radar Chart */}
+        <div className="card health-radar-card">
+          <div className="card-header">
+            <h3>Risk Profile Radar</h3>
+          </div>
+          <div className="radar-wrapper">
+            <svg viewBox="0 0 300 300" className="radar-svg">
+              {[20, 40, 60, 80, 100].map((r) => (
+                <polygon key={r}
+                  points={data.components.map((_, i) => {
+                    const angle = (Math.PI * 2 * i) / data.components.length - Math.PI / 2;
+                    return `${150 + (r / 100) * 110 * Math.cos(angle)},${150 + (r / 100) * 110 * Math.sin(angle)}`;
+                  }).join(' ')}
+                  fill="none" stroke="var(--border-subtle)" strokeWidth="0.5" opacity={0.5}
+                />
+              ))}
+              {data.components.map((_, i) => {
+                const angle = (Math.PI * 2 * i) / data.components.length - Math.PI / 2;
+                return <line key={i} x1="150" y1="150" x2={150 + 110 * Math.cos(angle)} y2={150 + 110 * Math.sin(angle)} stroke="var(--border-subtle)" strokeWidth="0.5" opacity={0.3} />;
+              })}
+              <polygon
+                points={data.components.map((c, i) => {
+                  const angle = (Math.PI * 2 * i) / data.components.length - Math.PI / 2;
+                  const r = c.score / 100;
+                  return `${150 + r * 110 * Math.cos(angle)},${150 + r * 110 * Math.sin(angle)}`;
+                }).join(' ')}
+                fill="var(--accent)" fillOpacity="0.12" stroke="var(--accent)" strokeWidth="2"
+              />
+              {data.components.map((c, i) => {
+                const angle = (Math.PI * 2 * i) / data.components.length - Math.PI / 2;
+                const r = c.score / 100;
+                return <circle key={i} cx={150 + r * 110 * Math.cos(angle)} cy={150 + r * 110 * Math.sin(angle)} r="4" fill="var(--accent)" />;
+              })}
+              {data.components.map((c, i) => {
+                const angle = (Math.PI * 2 * i) / data.components.length - Math.PI / 2;
+                const x = 150 + 130 * Math.cos(angle);
+                const y = 150 + 130 * Math.sin(angle);
+                return <text key={i} x={x} y={y} textAnchor="middle" dominantBaseline="middle" fill="var(--text-secondary)" fontSize="9" fontWeight="500">{c.name}</text>;
+              })}
+            </svg>
+          </div>
+        </div>
+
+        {/* Component Details Table */}
+        <div className="card health-detail-card">
+          <div className="card-header">
+            <h3>Dimension Detail</h3>
+          </div>
+          <table className="data-table">
+            <thead>
+              <tr>
+                <th>Dimension</th>
+                <th>Score</th>
+                <th>Grade</th>
+                <th>Weight</th>
+                <th>Assessment</th>
+              </tr>
+            </thead>
+            <tbody>
+              {data.components.map((c) => (
+                <tr key={c.name}>
+                  <td style={{ fontFamily: 'var(--font-sans)', fontWeight: 600 }}>{c.name}</td>
+                  <td>{c.score}</td>
+                  <td><span className="badge" style={{ background: gradeColor(c.grade) + '18', color: gradeColor(c.grade) }}>{c.grade}</span></td>
+                  <td>{(c.weight * 100).toFixed(0)}%</td>
+                  <td style={{ fontFamily: 'var(--font-sans)', fontSize: '0.78rem', color: 'var(--text-secondary)' }}>{c.detail}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      {/* Coaching Tips */}
+      {data.tips.length > 0 && (
+        <div className="card health-tips-section">
+          <div className="card-header">
+            <h3>Actionable Recommendations</h3>
+            <span className="badge badge-primary">{data.tips.length} Tips</span>
+          </div>
+          <div className="health-tips-grid">
+            {data.tips.map((tip, i) => (
+              <div key={i} className="health-tip-item">
+                <div className="health-tip-icon">
+                  <svg viewBox="0 0 20 20" fill="currentColor" width="16" height="16"><path fillRule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z" clipRule="evenodd" /></svg>
+                </div>
+                <span>{tip}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}