Update app.py

app.py

@@ -1,12 +1,5 @@
 # app.py
-# Efficient Portfolio Advisor — CML-consistent plotting + suggestion picker
-# Modality: Text. Optional reranking model: FinLang/finance-embeddings-investopedia
-
-import os
-import io
-import math
-import json
-import warnings
+import os, io, math, json, time, random, warnings
 warnings.filterwarnings("ignore")
 
 from typing import List, Tuple, Dict, Optional
@@ -15,96 +8,144 @@ import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 from PIL import Image
-import gradio as gr
 import requests
 import yfinance as yf
+import gradio as gr
 
-_ST_MODEL = None  # lazy load for embeddings
+# Optional: finance embeddings for mild re-ranking of candidates
+try:
+    from sentence_transformers import SentenceTransformer
+    _EMB_MODEL = "FinLang/finance-embeddings-investopedia"
+    _emb = SentenceTransformer(_EMB_MODEL)
+except Exception:
+    _emb = None
+
+# ---------------- config ----------------
+DATA_DIR = "data"
+os.makedirs(DATA_DIR, exist_ok=True)
 
-# ---------------- Config ----------------
-DATA_DIR = "data"; os.makedirs(DATA_DIR, exist_ok=True)
-MARKET_TICKER = "VOO"
-MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 10
-DATASET_ROWS = 1000
+MAX_TICKERS = 25
+MARKET_TICKER = "VOO"
+
+POS_COLS = ["ticker", "amount_usd", "weight_exposure", "beta"]
+SUG_TABLE_COLS = ["ticker", "weight_%", "amount_$"]
 
 FRED_MAP = [
-    (1,  "DGS1"), (2,  "DGS2"), (3,  "DGS3"), (5,  "DGS5"),
-    (7,  "DGS7"), (10, "DGS10"), (20, "DGS20"), (30, "DGS30"), (100, "DGS30")
+    (1,  "DGS1"),
+    (2,  "DGS2"),
+    (3,  "DGS3"),
+    (5,  "DGS5"),
+    (7,  "DGS7"),
+    (10, "DGS10"),
+    (20, "DGS20"),
+    (30, "DGS30"),
+    (100, "DGS30"),
 ]
 
-POS_COLS = ["ticker", "amount_usd", "weight_exposure", "beta"]
-SUG_COLS_HOLD = ["pick", "ticker", "weight_%", "amount_$"]
+# ---------------- helpers ----------------
+def ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
 
-# ---------------- Small helpers ----------------
-def fmt_pct(x: float, dec: int = 2) -> str:
-    try: return f"{x*100:.{dec}f}%"
-    except: return "—"
+def empty_positions_df():
+    return pd.DataFrame(columns=POS_COLS)
 
-def ensure_dir(p: str):
-    os.makedirs(os.path.dirname(p), exist_ok=True)
+def empty_suggest_df():
+    return pd.DataFrame(columns=SUG_TABLE_COLS)
 
 def fred_series_for_horizon(years: float) -> str:
     y = max(1.0, min(100.0, float(years)))
     for cutoff, code in FRED_MAP:
-        if y <= cutoff: return code
+        if y <= cutoff:
+            return code
     return "DGS30"
 
 def fetch_fred_yield_annual(code: str) -> float:
     url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={code}"
     try:
-        r = requests.get(url, timeout=10); r.raise_for_status()
+        r = requests.get(url, timeout=10)
+        r.raise_for_status()
         df = pd.read_csv(io.StringIO(r.text))
         s = pd.to_numeric(df.iloc[:, 1], errors="coerce").dropna()
         return float(s.iloc[-1] / 100.0) if len(s) else 0.03
-    except: return 0.03
+    except Exception:
+        return 0.03
+
+def _extract_close(df: pd.DataFrame, tickers: List[str]) -> pd.DataFrame:
+    """
+    Make yfinance output consistently a (date x tickers) DataFrame of Close prices.
+    Handles single/multi ticker and (Adj Close|Close) cases.
+    """
+    if isinstance(df, pd.Series):
+        # Rare, but normalize
+        out = df.to_frame(name=tickers[0])
+        return out
+
+    if isinstance(df.columns, pd.MultiIndex):
+        lv0 = df.columns.get_level_values(0)
+        if "Close" in lv0:
+            px = df["Close"].copy()
+        elif "Adj Close" in lv0:
+            px = df["Adj Close"].copy()
+        else:
+            # Fallback to the first price-like level
+            first = next((x for x in ["Adj Close", "Close", "Close*"] if x in lv0), None)
+            if first is None:
+                first = lv0[0]
+            px = df[first].copy()
+        px.columns = [str(c) for c in px.columns]
+        return px
+
+    # Single ticker case with flat columns
+    candidates = [c for c in ["Close", "Adj Close"] if c in df.columns]
+    if candidates:
+        col = candidates[0]
+        return df[[col]].rename(columns={col: tickers[0]})
+
+    # Fallback: take first numeric column
+    first_num = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+    if first_num:
+        out = df[[first_num[0]]].copy()
+        out.columns = [tickers[0]]
+        return out
+
+    raise ValueError("Could not extract a price column")
 
-# ---------------- Prices & returns ----------------
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
     start = pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)
     end = pd.Timestamp.today(tz="UTC")
-    raw = yf.download(
+    df = yf.download(
         list(dict.fromkeys(tickers)),
-        start=start.date(), end=end.date(),
-        interval="1mo", auto_adjust=False, progress=False,
-        group_by="ticker", threads=False
+        start=start.date(),
+        end=end.date(),
+        interval="1mo",
+        auto_adjust=True,
+        progress=False,
+        group_by="column",
     )
-    if raw is None or len(raw) == 0:
-        return pd.DataFrame()
-
-    if isinstance(raw.columns, pd.MultiIndex):
-        price = None
-        for field in ("Adj Close", "Close"):
-            if field in raw.columns.get_level_values(-1):
-                price = raw.xs(field, axis=1, level=-1, drop_level=True); break
-        if price is None:
-            price = raw.copy()
-            price.columns = [c[0] if isinstance(c, tuple) else c for c in price.columns]
-    else:
-        if "Adj Close" in raw.columns: price = raw["Adj Close"]
-        elif "Close" in raw.columns:   price = raw["Close"]
-        else:                          price = raw
-
-    if isinstance(price, pd.Series): price = price.to_frame()
-    price = price.dropna(how="all").fillna(method="ffill")
-    price = price.loc[:, ~pd.Index(price.columns).duplicated()]
-    return price
+    px = _extract_close(df, tickers)
+    px = px.dropna(how="all").ffill()
+    return px
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
     return prices.pct_change().dropna()
 
-def annualize_mean(m):  return np.asarray(m, dtype=float) * 12.0
-def annualize_sigma(s): return np.asarray(s, dtype=float) * math.sqrt(12.0)
+def annualize_mean(m):
+    return np.asarray(m, dtype=float) * 12.0
+
+def annualize_sigma(s):
+    return np.asarray(s, dtype=float) * math.sqrt(12.0)
 
-# ---------------- Search & validation ----------------
 def yahoo_search(query: str):
-    if not query or not query.strip(): return []
+    if not query or len(query.strip()) == 0:
+        return []
     url = "https://query1.finance.yahoo.com/v1/finance/search"
     params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
     headers = {"User-Agent": "Mozilla/5.0"}
     try:
         r = requests.get(url, params=params, headers=headers, timeout=10)
-        r.raise_for_status(); data = r.json()
+        r.raise_for_status()
+        data = r.json()
         out = []
         for q in data.get("quotes", []):
             sym = q.get("symbol")
@@ -113,58 +154,63 @@ def yahoo_search(query: str):
             if sym and sym.isascii():
                 out.append({"symbol": sym, "name": name, "exchange": exch})
         if not out:
-            out = [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "—"}]
+            out = [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n a"}]
         return out[:10]
-    except:
-        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "—"}]
+    except Exception:
+        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n a"}]
 
 def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    base = list(dict.fromkeys([s.strip().upper() for s in symbols if s.strip()]))[:MAX_TICKERS]
-    px = fetch_prices_monthly(base + [MARKET_TICKER], years)
+    base = [s for s in dict.fromkeys(symbols) if s]
+    try:
+        px = fetch_prices_monthly(base + [MARKET_TICKER], years)
+    except Exception:
+        return []
     ok = [s for s in base if s in px.columns]
     return ok
 
-# ---------------- Aligned CAPM moments (now includes MARKET in cov & μ) ----------------
+# -------------- aligned moments --------------
 def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
-    uniq = [c for c in dict.fromkeys(symbols)]
-    px = fetch_prices_monthly(uniq, years)
+    uniq = [c for c in dict.fromkeys(symbols) if c != MARKET_TICKER]
+    tickers = uniq + [MARKET_TICKER]
+    px = fetch_prices_monthly(tickers, years)
     rets = monthly_returns(px)
-    cols = [c for c in uniq if c in rets.columns]
+    cols = [c for c in uniq if c in rets.columns] + ([MARKET_TICKER] if MARKET_TICKER in rets.columns else [])
     R = rets[cols].dropna(how="any")
     return R.loc[:, ~R.columns.duplicated()]
 
 def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
     R = get_aligned_monthly_returns(symbols + [MARKET_TICKER], years)
     if MARKET_TICKER not in R.columns or R.shape[0] < 3:
-        raise ValueError("Not enough aligned data to estimate moments.")
+        raise ValueError("Not enough aligned returns (market missing or few rows).")
     rf_m = rf_ann / 12.0
 
-    # Means
-    mu_m = R[MARKET_TICKER];  mu_m_ann = float(annualize_mean(mu_m.mean()))
-    mu_all_ann = annualize_mean(R.mean(axis=0))  # pandas Series across all cols
-    sigma_m_ann = float(annualize_sigma(mu_m.std(ddof=1)))
+    m = R[MARKET_TICKER]
+    if isinstance(m, pd.DataFrame):
+        m = m.iloc[:, 0].squeeze()
+
+    mu_m_ann = float(annualize_mean(m.mean()))
+    sigma_m_ann = float(annualize_sigma(m.std(ddof=1)))
     erp_ann = float(mu_m_ann - rf_ann)
 
-    # Betas vs market
-    ex_m = mu_m - rf_m
-    var_m = float(np.var(ex_m.values, ddof=1)); var_m = max(var_m, 1e-6)
+    ex_m = m - rf_m
+    var_m = float(np.var(ex_m.values, ddof=1))
+    var_m = max(var_m, 1e-8)
+
     betas: Dict[str, float] = {}
-    for s in R.columns:
+    for s in [c for c in R.columns if c != MARKET_TICKER]:
         ex_s = R[s] - rf_m
         betas[s] = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
-    betas[MARKET_TICKER] = 1.0
 
-    # Covariance includes MARKET_TICKER too
-    cov_m = np.cov(R.values.T, ddof=1)
-    covA = pd.DataFrame(cov_m * 12.0, index=R.columns, columns=R.columns)
+    betas[MARKET_TICKER] = 1.0  # by definition
 
-    return {
-        "betas": betas,
-        "cov_ann": covA,
-        "erp_ann": erp_ann,
-        "sigma_m_ann": sigma_m_ann,
-        "mu_all_ann": pd.Series(mu_all_ann, index=R.columns)  # annualized means per asset incl. market
-    }
+    asset_cols = [c for c in R.columns if c != MARKET_TICKER]
+    if asset_cols:
+        cov_m = np.cov(R[asset_cols].values.T, ddof=1)
+        covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
+    else:
+        covA = pd.DataFrame([], index=[], columns=[])
+
+    return {"betas": betas, "cov_ann": covA, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
 
 def capm_er(beta: float, rf_ann: float, erp_ann: float) -> float:
     return float(rf_ann + beta * erp_ann)
@@ -175,191 +221,254 @@ def portfolio_stats(weights: Dict[str, float],
                     rf_ann: float,
                     erp_ann: float) -> Tuple[float, float, float]:
     tickers = list(weights.keys())
-    if len(tickers) == 0: return 0.0, 0.0, 0.0
     w = np.array([weights[t] for t in tickers], dtype=float)
-    gross = float(np.sum(np.abs(w)));  w_expo = w / max(gross, 1e-12)
-
+    gross = float(np.sum(np.abs(w)))
+    if gross == 0:
+        return 0.0, 0.0, 0.0
+    w_expo = w / gross
     beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
-    er_p   = capm_er(beta_p, rf_ann, erp_ann)
-
+    er_p = capm_er(beta_p, rf_ann, erp_ann)  # CAPM expected return
     cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
     sigma_p = math.sqrt(float(max(w_expo.T @ cov @ w_expo, 0.0)))
     return beta_p, er_p, sigma_p
 
-def portfolio_hist_return(weights: Dict[str, float], mu_all_ann: pd.Series) -> float:
-    tickers = list(weights.keys())
-    w = np.array([weights[t] for t in tickers], dtype=float)
-    gross = float(np.sum(np.abs(w)));  w_expo = w / max(gross, 1e-12)
-    mu = mu_all_ann.reindex(tickers).fillna(0.0).to_numpy()
-    return float(np.dot(mu, w_expo))
-
-# ---------------- CML plot (percent axes) ----------------
+# -------------- CML helpers --------------
 def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
-    if sigma_mkt <= 1e-12: return 0.0, 1.0, rf_ann
+    if sigma_mkt <= 1e-12:
+        return 0.0, 1.0, rf_ann
     a = sigma_target / sigma_mkt
     return a, 1.0 - a, rf_ann + a * erp_ann
 
 def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
-    if abs(erp_ann) <= 1e-12: return 0.0, 1.0, rf_ann
+    if abs(erp_ann) <= 1e-12:
+        return 0.0, 1.0, rf_ann
     a = (mu_target - rf_ann) / erp_ann
     return a, 1.0 - a, abs(a) * sigma_mkt
 
-def plot_cml_percent(base, suggestion=None) -> Image.Image:
-    rf_ann = base["rf"]; erp = base["erp"]; sig_m = base["sigma_m"]
-    pt_s   = base["pt_sigma"]; pt_mu = base["pt_mu"]
-    sames_s_s = base["same_sigma_sigma"]; sames_s_mu = base["same_sigma_mu"]
-    same_mu_s = base["same_mu_sigma"];   same_mu_mu = base["same_mu_mu"]
-
-    fig = plt.figure(figsize=(6,4), dpi=120)
-    xmax = max(0.3, sig_m*2.0, pt_s*1.4, same_mu_s*1.4, sames_s_s*1.4, (suggestion["sigma"] if suggestion else 0.0)*1.4)
-    xs = np.linspace(0, xmax, 160)
-    slope = erp / max(sig_m, 1e-12)
+def _pct(x: float) -> float:
+    return float(x) * 100.0
+
+def plot_cml(
+    rf_ann, erp_ann, sigma_mkt,
+    pt_sigma, pt_mu,                  # <-- portfolio CAPM point
+    same_sigma_sigma, same_sigma_mu,
+    same_mu_sigma, same_mu_mu,
+    sugg_sigma=None, sugg_mu=None
+) -> Image.Image:
+    fig = plt.figure(figsize=(6.4, 4.2), dpi=140)
+
+    xmax = max(0.30, sigma_mkt * 2.0, pt_sigma * 1.4, same_mu_sigma * 1.4, same_sigma_sigma * 1.4, (sugg_sigma or 0.0) * 1.4)
+    xs = np.linspace(0, xmax, 200)
+    slope = erp_ann / max(sigma_mkt, 1e-12)
     cml = rf_ann + slope * xs
-    plt.plot(xs*100, cml*100, label="CML via Market")
-
-    plt.scatter([0.0], [rf_ann*100], label="Risk-free (FRED)")
-    plt.scatter([sig_m*100], [(rf_ann+erp)*100], label="Market VOO")
-    plt.scatter([pt_s*100], [pt_mu*100], label="Your portfolio")
-    plt.scatter([sames_s_s*100], [sames_s_mu*100], label="Efficient same σ")
-    plt.scatter([same_mu_s*100], [same_mu_mu*100], label="Efficient same return")
-
-    if suggestion:
-        plt.scatter([suggestion["sigma"]*100], [suggestion["mu"]*100], label="Suggestion")
-
-    plt.xlabel("σ (annualized, %)"); plt.ylabel("Expected return (annual, %)")
-    plt.legend(loc="best", fontsize=8); plt.tight_layout()
-
-    buf = io.BytesIO(); plt.savefig(buf, format="png"); plt.close(fig); buf.seek(0)
+    plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
+
+    # Key points
+    plt.scatter([0.0], [_pct(rf_ann)], label="Risk-free (FRED)")
+    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label=f"Market {MARKET_TICKER}")
+    plt.scatter([_pct(pt_sigma)], [_pct(pt_mu)], label="Your portfolio (CAPM)")
+
+    plt.scatter([_pct(same_sigma_sigma)], [_pct(same_sigma_mu)], label="Efficient same σ")
+    plt.scatter([_pct(same_mu_sigma)], [_pct(same_mu_mu)], label="Efficient same return")
+    if sugg_sigma is not None and sugg_mu is not None:
+        plt.scatter([_pct(sugg_sigma)], [_pct(sugg_mu)], label="Suggestion")
+
+    plt.xlabel("σ (annualized, %)")
+    plt.ylabel("Expected return (annual, %)")
+    plt.legend(loc="best", fontsize=8)
+    plt.tight_layout()
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png")
+    plt.close(fig)
+    buf.seek(0)
     return Image.open(buf)
 
-# ---------------- Synthetic dataset (universe only) ----------------
-def _row_exposures(row: pd.Series, universe: List[str]) -> Optional[np.ndarray]:
-    try:
-        ts = [t.strip() for t in str(row["tickers"]).split(",")]
-        ws = [float(x) for x in str(row["weights"]).split(",")]
-        wmap = {t: ws[i] for i, t in enumerate(ts) if i < len(ws)}
-        w = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
-        gross = float(np.sum(np.abs(w)));  
-        if gross <= 1e-12: return None
-        return w / gross
-    except: return None
+# -------------- synthetic dataset for suggestions --------------
+def synth_profile(rng: np.random.Generator) -> str:
+    risk = rng.choice(["cautious", "balanced", "moderate", "growth", "aggressive"])
+    horizon = rng.choice(["three years", "five years", "seven years", "ten years", "fifteen years"])
+    goal = rng.choice(["retirement savings", "first home", "education fund", "wealth building", "travel fund", "emergency buffer"])
+    return f"{risk} investor, {horizon} horizon, goal is {goal}."
 
-def build_synthetic_dataset(universe: List[str], years: int, rf_ann: float, erp_ann: float, n_rows: int = DATASET_ROWS) -> pd.DataFrame:
-    moms = estimate_all_moments_aligned(universe, years, rf_ann)
-    covA, betas = moms["cov_ann"], moms["betas"]
-
-    rng = np.random.default_rng(12345); rows = []
-    for i in range(n_rows):
-        k = int(rng.integers(low=min(2, len(universe)), high=min(8, len(universe)) + 1))
+def build_synthetic_dataset(universe: List[str], years: int, rf_ann: float, erp_ann: float, covA: pd.DataFrame, betas: Dict[str, float]) -> pd.DataFrame:
+    # build 1,000 random portfolios over the user universe (CAPM ER, cov-based sigma)
+    rng = np.random.default_rng(42 + int(time.time()) % 10000)
+    rows = []
+    for i in range(1000):
+        k = rng.integers(low=min(2, len(universe)), high=min(8, len(universe)) + 1)
         picks = list(rng.choice(universe, size=k, replace=False))
-        signs = rng.choice([-1.0, 1.0], size=k, p=[0.2, 0.8])
+        signs = rng.choice([-1.0, 1.0], size=k, p=[0.25, 0.75])
         raw = rng.dirichlet(np.ones(k))
         gross = 1.0 + float(rng.gamma(2.0, 0.5))
-        w = gross * signs * raw
-        beta_p, er_p, sigma_p = portfolio_stats({picks[j]: w[j] for j in range(k)}, covA, betas, rf_ann, erp_ann)
+        w = gross * signs * raw  # exposure weights that sum (in abs) to gross
+
+        wmap = {picks[j]: float(w[j]) for j in range(k)}
+        beta_p, er_p, sigma_p = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
+
         rows.append({
             "id": i,
+            "profile_text": synth_profile(rng),
             "tickers": ",".join(picks),
             "weights": ",".join(f"{x:.6f}" for x in w),
-            "er_p": er_p, "sigma_p": sigma_p, "beta_p": beta_p
+            "beta_p": beta_p,
+            "er_p": er_p,
+            "sigma_p": sigma_p
         })
     return pd.DataFrame(rows)
 
-def dataset_path_for_universe(universe: List[str]) -> str:
-    key = ",".join(sorted(universe))
-    h = abs(hash(key)) % (10**8)
-    return os.path.join(DATA_DIR, f"investor_profiles_{h}.csv")
-
-# ---------------- Suggestions (build + picker) ----------------
-def _risk_targets(sigmas: np.ndarray) -> Dict[str, float]:
-    return {"Low": float(np.quantile(sigmas, 0.15)),
-            "Medium": float(np.quantile(sigmas, 0.50)),
-            "High": float(np.quantile(sigmas, 0.85))}
-
-def _describe_row_for_embeddings(row: pd.Series, universe: List[str]) -> str:
-    parts = [f"sigma {row['sigma_p']:.4f}", f"beta {row['beta_p']:.2f}", f"expected return {row['er_p']:.4f}"]
-    ex = _row_exposures(row, universe)
-    if ex is not None:
-        top = sorted([(universe[i], float(abs(ex[i]))) for i in range(len(universe))], key=lambda kv: -kv[1])[:4]
-        parts.append("focus " + ", ".join([f"{t}:{w:.2f}" for t, w in top]))
-    return " ".join(parts)
-
-def _maybe_load_st_model():
-    global _ST_MODEL
-    if _ST_MODEL is None:
-        from sentence_transformers import SentenceTransformer
-        _ST_MODEL = SentenceTransformer("FinLang/finance-embeddings-investopedia")
-    return _ST_MODEL
-
-def build_suggestions(csv_path: str,
-                      universe: List[str],
-                      total_amount: float,
-                      risk_level: str,
-                      use_embeddings: bool,
-                      covA: pd.DataFrame,
-                      betas: Dict[str, float],
-                      rf_ann: float,
-                      erp_ann: float,
-                      mu_all_ann: pd.Series):
-    try: df = pd.read_csv(csv_path)
-    except Exception: return [], pd.DataFrame(columns=SUG_COLS_HOLD)
-
-    if df.empty: return [], pd.DataFrame(columns=SUG_COLS_HOLD)
-
-    sigmas = df["sigma_p"].to_numpy(dtype=float)
-    target_sigma = _risk_targets(sigmas).get(risk_level, float(np.median(sigmas)))
-
-    df = df.copy(); df["dist"] = (df["sigma_p"] - target_sigma).abs()
-    cand = df.nsmallest(100, "dist").reset_index(drop=True)
+def _row_to_exposures(row: pd.Series, universe: List[str]) -> Optional[np.ndarray]:
+    try:
+        ts = [t.strip() for t in str(row["tickers"]).split(",")]
+        ws = [float(x) for x in str(row["weights"]).split(",")]
+        wmap = {t: ws[i] for i, t in enumerate(ts) if i < len(ws)}
+        w = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
+        gross = float(np.sum(np.abs(w)))
+        if gross <= 1e-12:
+            return None
+        return w / gross
+    except Exception:
+        return None
+
+def _risk_query_text(risk: str) -> str:
+    if risk == "Low":
+        return "conservative low-volatility long-term capital preservation diversified investment grade"
+    if risk == "High":
+        return "aggressive high risk high growth momentum speculative tech heavy"
+    return "balanced moderate risk growth and income diversified core equities and bonds"
+
+def _embed_scores(texts: List[str], query: str) -> np.ndarray:
+    if _emb is None:
+        return np.zeros(len(texts), dtype=float)
+    qv = _emb.encode([query], normalize_embeddings=True)[0]
+    M = _emb.encode(texts, normalize_embeddings=True)
+    sims = (M @ qv).astype(float)
+    return sims
+
+def make_suggestions(csv_path: str,
+                     universe: List[str],
+                     risk: str,
+                     use_embeddings: bool) -> List[Dict]:
+    """
+    Return a list of 3 suggestions. Each item:
+      {"weights": {ticker: expo}, "er": float, "sigma": float, "beta": float, "row_text": str}
+    """
+    try:
+        df = pd.read_csv(csv_path)
+    except Exception:
+        return []
 
+    # Keep only rows that map nicely to current universe
+    rows = []
+    exps = []
+    for _, r in df.iterrows():
+        x = _row_to_exposures(r, universe)
+        if x is None:
+            continue
+        rows.append(r)
+        exps.append(x)
+    if not rows:
+        return []
+
+    exps = np.vstack(exps)
+    sigs = np.array([float(r["sigma_p"]) for r in rows])
+    ers = np.array([float(r["er_p"]) for r in rows])
+
+    # Choose a target sigma by risk quantile
+    qmap = {"Low": 0.25, "Medium": 0.50, "High": 0.85}
+    q = qmap.get(risk, 0.50)
+    target_sigma = float(np.quantile(sigs, q=q))
+
+    # Rank by closeness in sigma to target
+    base_idx = np.argsort(np.abs(sigs - target_sigma))
+
+    # Optional: light re-ranking using embeddings to prefer text that matches risk intent
     if use_embeddings:
-        model = _maybe_load_st_model()
-        prompt = {"Low":"low risk conservative mix","Medium":"balanced moderate risk","High":"aggressive growth high risk"}[risk_level]
-        texts = [prompt] + [_describe_row_for_embeddings(r, universe) for _, r in cand.iterrows()]
-        embs = model.encode(texts)
-        S = model.similarity(embs[0:1], embs[1:]).flatten()
-        cand = cand.assign(sim=S).sort_values("sim", ascending=False).head(50).reset_index(drop=True)
-
-    cand["score"] = cand["dist"] - 0.2*cand["er_p"]
-    picks = cand.nsmallest(3, "score").reset_index(drop=True)
-
-    suggestions = []
-    for i, row in picks.iterrows():
-        expo = _row_exposures(row, universe)
-        if expo is None: continue
-        wmap = {universe[j]: float(expo[j]) for j in range(len(universe)) if abs(float(expo[j])) > 1e-4}
-        # recompute metrics using current moments (historical μ for plotting)
-        beta_s, er_capm_s, sigma_s = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
-        mu_hist_s = portfolio_hist_return(wmap, mu_all_ann)
-        # holdings table for this pick
-        rows_hold = [{
-            "pick": i+1,
-            "ticker": t,
-            "weight_%": round(w*100.0, 2),
-            "amount_$": round(w*total_amount, 2)
-        } for t, w in sorted(wmap.items(), key=lambda kv: -abs(kv[1]))]
-        suggestions.append({
-            "pick": i+1,
-            "hold_df": pd.DataFrame(rows_hold, columns=SUG_COLS_HOLD),
-            "mu_hist": mu_hist_s, "sigma_hist": sigma_s,
-            "beta": beta_s, "er_capm": er_capm_s
+        texts = [str(rows[i]["profile_text"]) for i in base_idx[:120]]
+        sims = _embed_scores(texts, _risk_query_text(risk))
+        # Blend: 80% sigma closeness (smaller better) and -20% similarity (larger better)
+        closeness = np.abs(sigs[base_idx[:120]] - target_sigma)
+        score = 0.8 * (closeness / (closeness.max() + 1e-9)) - 0.2 * sims
+        rerank_local = np.argsort(score)
+        idx = base_idx[:120][rerank_local]
+    else:
+        idx = base_idx
+
+    # Take top 3 diverse by exposure distance
+    picks, chosen = [], []
+    for i in idx:
+        wvec = exps[i]
+        # enforce some diversity
+        ok = True
+        for j in chosen:
+            if np.linalg.norm(wvec - exps[j]) < 0.25:
+                ok = False
+                break
+        if not ok:
+            continue
+        chosen.append(i)
+        r = rows[i]
+        wmap = {universe[k]: float(wvec[k]) for k in range(len(universe)) if abs(wvec[k]) > 1e-4}
+        picks.append({
+            "weights": wmap,
+            "er": float(r["er_p"]),
+            "sigma": float(r["sigma_p"]),
+            "beta": float(r["beta_p"]),
+            "row_text": str(r["profile_text"])
         })
+        if len(picks) == 3:
+            break
+    return picks
+
+# -------------- formatting helpers --------------
+def fmt_pct(x: float, dp: int = 2) -> str:
+    return f"{x*100:.{dp}f}%"
+
+def build_summary_md(lookback, horizon, rf, rf_code, erp, sigma_mkt,
+                     beta_p, sigma_hist, mu_hist, mu_capm,
+                     a_sigma, b_sigma, mu_eff_sigma,
+                     a_mu, b_mu, sigma_eff_mu) -> str:
+    lines = []
+    lines.append("### Inputs")
+    lines.append(f"- Lookback years **{lookback}**")
+    lines.append(f"- Horizon years **{horizon}**")
+    lines.append(f"- Risk-free **{fmt_pct(rf)}** from **{rf_code}**")
+    lines.append(f"- Market ERP **{fmt_pct(erp)}**")
+    lines.append(f"- Market σ **{fmt_pct(sigma_mkt)}**")
+    lines.append("")
+    lines.append("### Your portfolio (CAPM expectations)")
+    lines.append(f"- Beta **{beta_p:.2f}**")
+    lines.append(f"- σ (historical) **{fmt_pct(sigma_hist)}**")
+    lines.append(f"- Expected return (historical) **{fmt_pct(mu_hist)}**")
+    lines.append(f"- Expected return (CAPM / SML) **{fmt_pct(mu_capm)}**")
+    lines.append("")
+    lines.append("### Efficient alternatives on CML")
+    lines.append(f"- Same σ as your portfolio → Market weight **{a_sigma:.2f}**, Bills weight **{b_sigma:.2f}**, return **{fmt_pct(mu_eff_sigma)}**")
+    lines.append(f"- Same return (CAPM) → Market weight **{a_mu:.2f}**, Bills weight **{b_mu:.2f}**, σ **{fmt_pct(sigma_eff_mu)}**")
+    return "\n".join(lines)
+
+# -------------- stateful globals on launch --------------
+ensure_data_dir()
+HORIZON_YEARS = 10
+RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
+RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
-    first_table = suggestions[0]["hold_df"] if suggestions else pd.DataFrame(columns=SUG_COLS_HOLD)
-    return suggestions, first_table
-
-# ---------------- UI callbacks ----------------
+# -------------- gradio callbacks --------------
 def search_tickers_cb(q: str):
     hits = yahoo_search(q)
-    if not hits: return "No matches", []
+    if not hits:
+        return "No matches", []
     opts = [f"{h['symbol']}  |  {h['name']}  |  {h['exchange']}" for h in hits]
     return "Select a symbol and click Add", opts
 
 def add_symbol(selection: str, table: pd.DataFrame):
-    if not selection: return table, "Pick a row from Matches first."
+    if not selection:
+        return table, "Pick a row from Matches first"
     symbol = selection.split("|")[0].strip().upper()
     current = [] if table is None or len(table) == 0 else [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
     tickers = current if symbol in current else current + [symbol]
+
+    # validate against yfinance (with market ticker alongside to force download structure)
     val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
     tickers = [t for t in tickers if t in val]
     amt_map = {}
@@ -371,7 +480,8 @@ def add_symbol(selection: str, table: pd.DataFrame):
     new_table = pd.DataFrame({"ticker": tickers, "amount_usd": [amt_map.get(t, 0.0) for t in tickers]})
     msg = f"Added {symbol}" if symbol in tickers else f"{symbol} not valid"
     if len(new_table) > MAX_TICKERS:
-        new_table = new_table.iloc[:MAX_TICKERS]; msg = f"Reached max of {MAX_TICKERS}"
+        new_table = new_table.iloc[:MAX_TICKERS]
+        msg = f"Reached max of {MAX_TICKERS}"
     return new_table, msg
 
 def lock_ticker_column(tb: pd.DataFrame):
@@ -384,165 +494,196 @@ def lock_ticker_column(tb: pd.DataFrame):
     amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
     return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
 
-HORIZON_YEARS = 10
-RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
-RF_ANN = fetch_fred_yield_annual(RF_CODE)
-
 def set_horizon(years: float):
     y = max(1.0, min(100.0, float(years)))
-    code = fred_series_for_horizon(y); rf = fetch_fred_yield_annual(code)
+    code = fred_series_for_horizon(y)
+    rf = fetch_fred_yield_annual(code)
     global HORIZON_YEARS, RF_CODE, RF_ANN
-    HORIZON_YEARS = y; RF_CODE = code; RF_ANN = rf
-    return f"Risk-free series {code}. Latest annual rate {fmt_pct(rf)}. Horizon set to {int(round(y))} years."
+    HORIZON_YEARS = int(round(y))
+    RF_CODE = code
+    RF_ANN = rf
+    return f"Risk free series {code}. Latest annual rate {rf:.2%}. Using this for CAPM."
+
+def _build_dataset_path() -> str:
+    return os.path.join(DATA_DIR, f"investor_profiles_{hex(random.getrandbits(32))[2:]}.csv")
+
+def compute(
+    years_lookback: int,
+    table: pd.DataFrame,
+    risk_choice: str,
+    use_embeddings: bool
+):
+    # --- sanitize input table ---
+    if table is None or len(table) == 0:
+        return None, "Add at least one ticker", "Universe empty", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
 
-def compute(lookback_years: int,
-            table: pd.DataFrame,
-            risk_level: str,
-            use_embeddings: bool):
     df = table.dropna()
     df["ticker"] = df["ticker"].astype(str).str.upper().str.strip()
     df["amount_usd"] = pd.to_numeric(df["amount_usd"], errors="coerce").fillna(0.0)
-
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
-        empty_hold = pd.DataFrame(columns=SUG_COLS_HOLD)
-        empty_pos = pd.DataFrame(columns=POS_COLS)
-        return None, "Add at least one ticker.", "—", empty_pos, empty_hold, None, [], {}
+        return None, "Add at least one ticker", "Universe empty", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
 
-    symbols = validate_tickers(symbols, lookback_years)
+    symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        empty_hold = pd.DataFrame(columns=SUG_COLS_HOLD)
-        empty_pos = pd.DataFrame(columns=POS_COLS)
-        return None, "Could not validate any tickers.", "—", empty_pos, empty_hold, None, [], {}
+        return None, "Could not validate any tickers", "Universe invalid", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
 
-    universe = list(sorted(set(symbols + [MARKET_TICKER])))[:MAX_TICKERS]
+    universe = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
 
     df = df[df["ticker"].isin(symbols)].copy()
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
-    total_amt = float(sum(abs(v) for v in amounts.values()))
-    if total_amt <= 1e-12:
-        empty_hold = pd.DataFrame(columns=SUG_COLS_HOLD)
-        empty_pos = pd.DataFrame(columns=POS_COLS)
-        return None, "All amounts are zero.", f"Universe set to {', '.join(universe)}", empty_pos, empty_hold, None, [], {}
-
-    weights = {k: v / total_amt for k, v in amounts.items()}
-
-    moms = estimate_all_moments_aligned(universe, lookback_years, RF_ANN)
-    betas, covA, erp_ann = moms["betas"], moms["cov_ann"], moms["erp_ann"]
-    sigma_mkt, mu_all_ann = moms["sigma_m_ann"], moms["mu_all_ann"]
-
-    beta_p, er_capm_p, sigma_p = portfolio_stats(weights, covA, betas, RF_ANN, erp_ann)
-    mu_hist_p = portfolio_hist_return(weights, mu_all_ann)  # use this for plotting
-
-    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_p, RF_ANN, erp_ann, sigma_mkt)
-    a_mu, b_mu, sigma_eff_mu     = efficient_same_return(mu_hist_p, RF_ANN, erp_ann, sigma_mkt)
-
-    # dataset for this universe
-    csv_path = dataset_path_for_universe(universe)
-    if not os.path.exists(csv_path):
-        synth = build_synthetic_dataset(universe, lookback_years, RF_ANN, erp_ann, n_rows=DATASET_ROWS)
-        ensure_dir(csv_path); synth.to_csv(csv_path, index=False)
-
-    # suggestions list + first table
-    suggestions, first_table = build_suggestions(
-        csv_path, universe, total_amt, risk_level, use_embeddings,
-        covA, betas, RF_ANN, erp_ann, mu_all_ann
+    gross = sum(abs(v) for v in amounts.values())
+    if gross <= 1e-12:
+        return None, "All amounts are zero", "Universe ok", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
+
+    # --- CAPM ingredients ---
+    rf_ann = RF_ANN
+    moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
+    betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
+
+    # portfolio weights/exposures
+    weights = {k: v / gross for k, v in amounts.items()}
+    beta_p, mu_capm, sigma_p = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
+
+    # historical mean (for info only)
+    try:
+        R = get_aligned_monthly_returns(symbols, years_lookback)
+        mu_hist = float(annualize_mean(R[symbols].mean().dot(np.array([weights[s] for s in symbols]))))
+        sigma_hist = sigma_p  # same sigma as built from covA
+    except Exception:
+        mu_hist = mu_capm
+        sigma_hist = sigma_p
+
+    # efficient points on CML (use CAPM target)
+    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_p, rf_ann, erp_ann, sigma_mkt)
+    a_mu, b_mu, sigma_eff_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
+
+    # --- Build dataset once for this run (universe-specific) ---
+    ds_path = _build_dataset_path()
+    synth_df = build_synthetic_dataset(
+        universe=[u for u in universe if u != MARKET_TICKER],
+        years=years_lookback,
+        rf_ann=rf_ann,
+        erp_ann=erp_ann,
+        covA=covA,
+        betas=betas
+    )
+    synth_df.to_csv(ds_path, index=False)
+
+    # --- Suggestions (3 picks) ---
+    picks = make_suggestions(ds_path, [u for u in universe if u != MARKET_TICKER], risk_choice, use_embeddings)
+    if not picks:
+        pick_choices = []
+        sugg_table = empty_suggest_df()
+        sugg_sigma = None
+        sugg_mu = None
+    else:
+        pick_choices = [f"Pick #{i+1}" for i in range(len(picks))]
+        # default selection = first pick
+        first = picks[0]
+        sugg_sigma = float(first["sigma"])
+        sugg_mu = float(first["er"])
+        sugg_table = _pick_table(first, amounts)
+
+    # --- Plot with CAPM portfolio and suggestion point (if any) ---
+    img = plot_cml(
+        rf_ann, erp_ann, sigma_mkt,
+        pt_sigma=sigma_p, pt_mu=mu_capm,
+        same_sigma_sigma=sigma_p, same_sigma_mu=mu_eff_sigma,
+        same_mu_sigma=sigma_eff_mu, same_mu_mu=mu_capm,
+        sugg_sigma=sugg_sigma, sugg_mu=sugg_mu
     )
 
-    # plot state + initial image with first suggestion overlay
-    plot_state = {
-        "rf": RF_ANN, "erp": erp_ann, "sigma_m": sigma_mkt,
-        "pt_sigma": sigma_p, "pt_mu": mu_hist_p,
-        "same_sigma_sigma": sigma_p, "same_sigma_mu": mu_eff_sigma,
-        "same_mu_sigma": sigma_eff_mu, "same_mu_mu": mu_hist_p
-    }
-    sug_overlay = {"sigma": suggestions[0]["sigma_hist"], "mu": suggestions[0]["mu_hist"]} if suggestions else None
-    img = plot_cml_percent(plot_state, suggestion=sug_overlay)
-
-    # summary text (show both CAPM and historical for your portfolio)
-    info_lines = []
-    info_lines += [
-        "### Inputs",
-        f"- Lookback years {int(lookback_years)}",
-        f"- Horizon years {int(round(HORIZON_YEARS))}",
-        f"- Risk-free {fmt_pct(RF_ANN)} from {RF_CODE}",
-        f"- Market ERP {fmt_pct(erp_ann)}",
-        f"- Market σ {fmt_pct(sigma_mkt)}",
-        "",
-        "### Your portfolio",
-        f"- Beta {beta_p:.2f}",
-        f"- σ (historical) {fmt_pct(sigma_p)}",
-        f"- Expected return (historical) {fmt_pct(mu_hist_p)}",
-        f"- Expected return (CAPM / SML) {fmt_pct(er_capm_p)}",
-        "",
-        "### Efficient alternatives on CML",
-        f"- Same σ as your portfolio → Market {a_sigma:.2f}, Bills {b_sigma:.2f}, return {fmt_pct(mu_eff_sigma)}",
-        f"- Same return (historical) → Market {a_mu:.2f}, Bills {b_mu:.2f}, σ {fmt_pct(sigma_eff_mu)}",
-        "",
-        f"### Dataset-based suggestions (risk: {risk_level})",
-        "- Use the selector below to flip between Pick #1 / #2 / #3. Table shows % exposure and $ amounts."
-    ]
-    if use_embeddings:
-        info_lines.append("- Reranked with finance embeddings (FinLang/finance-embeddings-investopedia).")
-    info = "\n".join(info_lines)
+    # --- Summary text ---
+    summary = build_summary_md(
+        years_lookback, HORIZON_YEARS, rf_ann, RF_CODE, erp_ann, sigma_mkt,
+        beta_p, sigma_hist, mu_hist, mu_capm,
+        a_sigma, b_sigma, mu_eff_sigma,
+        a_mu, b_mu, sigma_eff_mu
+    )
 
     # positions table
     rows = []
     for t in symbols:
+        beta_val = 1.0 if t == MARKET_TICKER else betas.get(t, np.nan)
         rows.append({
             "ticker": t,
-            "amount_usd": round(amounts.get(t, 0.0), 2),
-            "weight_exposure": round(weights.get(t, 0.0), 6),
-            "beta": round(betas.get(t, np.nan), 6),
+            "amount_usd": amounts.get(t, 0.0),
+            "weight_exposure": weights.get(t, 0.0),
+            "beta": beta_val,
         })
     pos_table = pd.DataFrame(rows, columns=POS_COLS)
 
-    uni_msg = f"Universe set to: {', '.join(universe)}"
-    # also return a short pick-info for pick #1
-    pick_info = ""
-    if suggestions:
-        s = suggestions[0]
-        pick_info = (f"**Pick #1** — σ {fmt_pct(s['sigma_hist'])}, "
-                     f"ER (hist) {fmt_pct(s['mu_hist'])}, "
-                     f"ER (CAPM) {fmt_pct(s['er_capm'])}, beta {s['beta']:.2f}")
-
-    return img, info, uni_msg, pos_table, first_table, csv_path, suggestions, plot_state, pick_info
-
-def change_pick(idx: int, suggestions, plot_state):
-    # idx is 1..3
-    if not suggestions or idx is None:
-        return pd.DataFrame(columns=SUG_COLS_HOLD), plot_cml_percent(plot_state), ""
-    i = int(idx) - 1
-    if i < 0 or i >= len(suggestions):
-        i = 0
-    s = suggestions[i]
-    img = plot_cml_percent(plot_state, suggestion={"sigma": s["sigma_hist"], "mu": s["mu_hist"]})
-    pick_info = (f"**Pick #{idx}** — σ {fmt_pct(s['sigma_hist'])}, "
-                 f"ER (hist) {fmt_pct(s['mu_hist'])}, "
-                 f"ER (CAPM) {fmt_pct(s['er_capm'])}, beta {s['beta']:.2f}")
-    return s["hold_df"], img, pick_info
-
-# ---------------- UI ----------------
+    uni_msg = f"Universe set to {', '.join(universe)}"
+    # Return suggestions state so the picker can swap views
+    suggestions_state = {"picks": picks, "amounts": amounts, "rf": rf_ann, "erp": erp_ann, "sigma_mkt": sigma_mkt, "mu_capm": mu_capm, "sigma_p": sigma_p}
+    return img, summary, uni_msg, pos_table, gr.update(choices=pick_choices, value=(pick_choices[0] if pick_choices else None), interactive=bool(pick_choices)), sugg_table, ds_path, suggestions_state
+
+def _pick_table(pick: Dict, amounts_map: Dict[str, float]) -> pd.DataFrame:
+    gross = float(sum(abs(v) for v in amounts_map.values()))
+    wmap = pick["weights"]
+    # normalize to exposures sum of abs = 1 for display
+    gross_w = sum(abs(v) for v in wmap.values())
+    if gross_w <= 1e-12:
+        return empty_suggest_df()
+    w_norm = {k: v / gross_w for k, v in wmap.items()}
+    rows = []
+    for t, w in sorted(w_norm.items(), key=lambda kv: -abs(kv[1])):
+        rows.append({
+            "ticker": t,
+            "weight_%": 100.0 * float(w),
+            "amount_$": float(w) * gross
+        })
+    df = pd.DataFrame(rows, columns=SUG_TABLE_COLS)
+    return df
+
+def on_select_pick(choice: Optional[str], suggestions_state: Dict):
+    if not choice or not suggestions_state or not suggestions_state.get("picks"):
+        return empty_suggest_df(), gr.update(value=None)
+    idx = int(choice.split("#")[1]) - 1
+    idx = max(0, min(idx, len(suggestions_state["picks"]) - 1))
+    pick = suggestions_state["picks"][idx]
+    table = _pick_table(pick, suggestions_state["amounts"])
+
+    # Update the plot with the chosen suggestion dot
+    img = plot_cml(
+        suggestions_state["rf"],
+        suggestions_state["erp"],
+        suggestions_state["sigma_mkt"],
+        pt_sigma=suggestions_state["sigma_p"],
+        pt_mu=suggestions_state["mu_capm"],
+        same_sigma_sigma=suggestions_state["sigma_p"],
+        same_sigma_mu=efficient_same_sigma(suggestions_state["sigma_p"], suggestions_state["rf"], suggestions_state["erp"], suggestions_state["sigma_mkt"])[2],
+        same_mu_sigma=efficient_same_return(suggestions_state["mu_capm"], suggestions_state["rf"], suggestions_state["erp"], suggestions_state["sigma_mkt"])[2],
+        same_mu_mu=suggestions_state["mu_capm"],
+        sugg_sigma=float(pick["sigma"]),
+        sugg_mu=float(pick["er"]),
+    )
+    return table, img
+
+# -------------- UI --------------
 with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     with gr.Accordion("About (assignment section 1)", open=False):
         gr.Markdown(
-            "**Modality**: Text.\n\n"
-            "**Use case**: Given a user’s stock/ETF universe and dollar amounts, the system recommends three "
-            "alternative mixes (Low / Medium / High risk) drawn from a 1,000-row dataset generated from the user’s current universe.\n\n"
-            "**System goal**: User inputs text (tickers & amounts). System returns three similar items (suggested mixes) from the dataset. "
-            "Optional reranking uses the text-embedding model `FinLang/finance-embeddings-investopedia`."
+            "**Modality:** Text\n\n"
+            "**Model:** FinLang/finance-embeddings-investopedia (optional, for mild re-ranking of dataset suggestions).\n\n"
+            "**Use case:** User enters tickers and dollar amounts; the app computes CAPM expectations and shows the "
+            "Capital Market Line. From a synthetic dataset (1,000 portfolios generated over the user’s universe), "
+            "the system returns 3 similar portfolios (Low/Medium/High risk picks). The user can flip between the "
+            "suggested picks and see holdings in % and $ plus where the suggestion sits on the CML.\n"
         )
 
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
         "Search symbols, enter dollar amounts, set your horizon. Prices from Yahoo Finance. Risk-free from FRED. "
-        "Suggestions are built only from your current universe and optionally refined with finance embeddings."
+        "Low/Medium/High suggestions are chosen only from a 1,000-row dataset generated from your current universe, "
+        "optionally refined with finance embeddings."
     )
 
     with gr.Row():
         with gr.Column(scale=1):
             q = gr.Textbox(label="Search symbol")
-            search_note = gr.Markdown(" ")
+            search_note = gr.Markdown()
             matches = gr.Dropdown(choices=[], label="Matches")
             with gr.Row():
                 search_btn = gr.Button("Search")
@@ -552,8 +693,8 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             table = gr.Dataframe(
                 headers=["ticker", "amount_usd"],
                 datatype=["str", "number"],
-                row_count=0, col_count=(2, "fixed"),
-                value=pd.DataFrame(columns=["ticker", "amount_usd"])
+                row_count=0,
+                col_count=(2, "fixed")
             )
 
             horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
@@ -561,41 +702,46 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
 
             gr.Markdown("### Suggestions")
             risk = gr.Radio(["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
-            use_st = gr.Checkbox(label="Use finance embeddings to refine picks", value=False)
-            run_btn = gr.Button("Compute (build dataset & suggest)")
+            use_emb = gr.Checkbox(label="Use finance embeddings to refine picks", value=True)
+
+            run_btn = gr.Button("Compute (build dataset & suggest)", variant="primary")
 
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CML)", type="pil")
-            summary = gr.Markdown(label="Summary")
+            summary = gr.Markdown(label="Inputs & CAPM expectations")
             universe_msg = gr.Textbox(label="Universe status", interactive=False)
+
             positions = gr.Dataframe(
                 label="Computed positions",
                 headers=POS_COLS,
                 datatype=["str", "number", "number", "number"],
                 col_count=(len(POS_COLS), "fixed"),
-                value=pd.DataFrame(columns=POS_COLS),
+                value=empty_positions_df(),
                 interactive=False
             )
 
-            # Suggestion picker
-            pick_slider = gr.Slider(1, 3, value=1, step=1, label="View suggested mix #", interactive=True)
-            pick_info = gr.Markdown("")
-            suggestions_tbl = gr.Dataframe(
-                label="Holdings (for selected pick) — percent & dollars",
-                headers=SUG_COLS_HOLD,
-                datatype=["number", "str", "number", "number"],
-                col_count=(len(SUG_COLS_HOLD), "fixed"),
-                value=pd.DataFrame(columns=SUG_COLS_HOLD),
+    with gr.Row():
+        with gr.Column(scale=1):
+            pick_select = gr.Radio(choices=[], label="Suggested pick (flip between #1 / #2 / #3)", interactive=False)
+        with gr.Column(scale=1):
+            sugg_table = gr.Dataframe(
+                label="Suggestion holdings — % and $",
+                headers=SUG_TABLE_COLS,
+                datatype=["str", "number", "number"],
+                col_count=(len(SUG_TABLE_COLS), "fixed"),
+                value=empty_suggest_df(),
                 interactive=False
             )
-            dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
+    dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
+
+    # hidden state for suggestions
+    suggestions_state = gr.State({})
 
-    # States to support picker
-    sug_state = gr.State([])
-    plot_state = gr.State({})
+    # wire events
+    def do_search(query):
+        note, options = search_tickers_cb(query)
+        return note, gr.update(choices=options)
 
-    # Wire up events
-    def do_search(query): note, options = search_tickers_cb(query); return note, gr.update(choices=options)
     search_btn.click(fn=do_search, inputs=q, outputs=[search_note, matches])
     add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
@@ -603,14 +749,14 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
 
     run_btn.click(
         fn=compute,
-        inputs=[lookback, table, risk, use_st],
-        outputs=[plot, summary, universe_msg, positions, suggestions_tbl, dl, sug_state, plot_state, pick_info]
+        inputs=[lookback, table, risk, use_emb],
+        outputs=[plot, summary, universe_msg, positions, pick_select, sugg_table, dl, suggestions_state]
     )
 
-    pick_slider.change(
-        fn=change_pick,
-        inputs=[pick_slider, sug_state, plot_state],
-        outputs=[suggestions_tbl, plot, pick_info]
+    pick_select.change(
+        fn=on_select_pick,
+        inputs=[pick_select, suggestions_state],
+        outputs=[sugg_table, plot]
     )
 
 if __name__ == "__main__":