Update app.py

app.py

@@ -1,5 +1,5 @@
-# app.py — Efficient Portfolio Advisor (CML-safe, same-ticker suggestions, embeddings always on)
-import os, io, math, time, warnings
+# app.py
+import os, io, math, time, warnings, json, random
 warnings.filterwarnings("ignore")
 
 from typing import List, Tuple, Dict, Optional
@@ -18,16 +18,18 @@ os.makedirs(DATA_DIR, exist_ok=True)
 
 MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 10
-MARKET_TICKER = "VOO"
 
-SYNTH_ROWS = 1000
-EMBED_MODEL_NAME = "FinLang/finance-embeddings-investopedia"
-EMBED_ALPHA = 0.6   # exposure similarity weight
-MMR_LAMBDA = 0.7    # diversity for re-ranking (kept for consistency even though we output 1 per band)
+# Market proxy used only for CAPM/CML math. We never add it to your portfolio or suggestions.
+MARKET_PROXY = "VOO"
 
+SYNTH_ROWS = 1000  # size of generated dataset for suggestions
+EMBED_ALPHA = 0.6  # exposure-sim weight in score (1-alpha uses text embeddings)
+MMR_LAMBDA = 0.7   # diversity for MMR (higher favors quality over diversity)
+
+# Globals that update with horizon changes
 HORIZON_YEARS = 10
 RF_CODE = "DGS10"
-RF_ANN = 0.0375
+RF_ANN = 0.0375  # updated at launch
 
 # ---------------- helpers ----------------
 def fred_series_for_horizon(years: float) -> str:
@@ -43,7 +45,8 @@ def fred_series_for_horizon(years: float) -> str:
 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
@@ -51,227 +54,344 @@ def fetch_fred_yield_annual(code: str) -> float:
         return 0.03
 
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers if t]))
-    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=int(years), days=7)).date()
+    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers]))
+    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)).date()
     end = pd.Timestamp.today(tz="UTC").date()
+
     df = yf.download(
-        tickers, start=start, end=end, interval="1mo",
-        auto_adjust=True, actions=False, progress=False,
-        group_by="column", threads=False,
+        tickers,
+        start=start,
+        end=end,
+        interval="1mo",
+        auto_adjust=True,
+        actions=False,
+        progress=False,
+        group_by="column",
+        threads=False,
     )
-    if isinstance(df, pd.Series): df = df.to_frame()
+
+    if isinstance(df, pd.Series):
+        df = df.to_frame()
     if isinstance(df.columns, pd.MultiIndex):
         lvl0 = [str(x) for x in df.columns.get_level_values(0).unique()]
-        if "Close" in lvl0: df = df["Close"]
-        elif "Adj Close" in lvl0: df = df["Adj Close"]
-        else: df = df.xs(df.columns.levels[0][-1], axis=1, level=0, drop_level=True)
+        if "Close" in lvl0:
+            df = df["Close"]
+        elif "Adj Close" in lvl0:
+            df = df["Adj Close"]
+        else:
+            df = df.xs(df.columns.levels[0][-1], axis=1, level=0, drop_level=True)
+
     cols = [c for c in tickers if c in df.columns]
-    return df[cols].dropna(how="all").fillna(method="ffill")
+    out = df[cols].dropna(how="all").fillna(method="ffill")
+    return out
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
     return prices.pct_change().dropna()
 
 def yahoo_search(query: str):
-    if not query or not str(query).strip(): return []
+    if not query or not str(query).strip():
+        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(); out = []
+        r = requests.get(url, params=params, headers=headers, timeout=10)
+        r.raise_for_status()
+        data = r.json()
+        out = []
         for q in data.get("quotes", []):
-            sym = q.get("symbol"); name = q.get("shortname") or q.get("longname") or ""; exch = q.get("exchDisp") or ""
-            if sym and sym.isascii(): out.append(f"{sym}  |  {name}  |  {exch}")
-        if not out: out = [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
+            sym = q.get("symbol")
+            name = q.get("shortname") or q.get("longname") or ""
+            exch = q.get("exchDisp") or ""
+            if sym and sym.isascii():
+                out.append(f"{sym}  |  {name}  |  {exch}")
+        if not out:
+            out = [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
         return out[:10]
     except Exception:
         return [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
 
 def validate_tickers(symbols: List[str], years: int) -> List[str]:
     base = [s for s in dict.fromkeys([t.upper().strip() for t in symbols]) if s]
-    px = fetch_prices_monthly(base + [MARKET_TICKER], years)
+    # We fetch base + MARKET_PROXY only to compute CAPM, but we don't add MARKET_PROXY to suggestions.
+    px = fetch_prices_monthly(base + [MARKET_PROXY], years)
     ok = [s for s in base if s in px.columns]
-    if MARKET_TICKER not in px.columns: return []
+    # Need market proxy data available; otherwise we cannot compute β/ERP/CML.
+    if MARKET_PROXY not in px.columns:
+        return []  # cannot proceed without market series
     return ok
 
-# ---------- aligned moments & covariances (incl. market) ----------
+# -------------- aligned moments (vs market proxy) --------------
 def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
-    uniq = [c for c in dict.fromkeys(symbols)]
-    if MARKET_TICKER not in uniq: uniq.append(MARKET_TICKER)
-    px = fetch_prices_monthly(uniq, years)
+    uniq = [c for c in dict.fromkeys(symbols) if c != MARKET_PROXY]
+    tickers = uniq + [MARKET_PROXY]
+    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_PROXY] if MARKET_PROXY 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, years)
-    if MARKET_TICKER not in R.columns or len(R) < 3:
+    if MARKET_PROXY not in R.columns or len(R) < 3:
         raise ValueError("Not enough aligned data with market proxy.")
     rf_m = rf_ann / 12.0
 
-    m = R[MARKET_TICKER]
-    if isinstance(m, pd.DataFrame): m = m.iloc[:, 0].squeeze()
+    m = R[MARKET_PROXY]
+    if isinstance(m, pd.DataFrame):
+        m = m.iloc[:, 0].squeeze()
+
     mu_m_ann = float(m.mean() * 12.0)
     sigma_m_ann = float(m.std(ddof=1) * math.sqrt(12.0))
     erp_ann = float(mu_m_ann - rf_ann)
 
     ex_m = m - rf_m
-    var_m = float(np.var(ex_m.values, ddof=1)); var_m = max(var_m, 1e-9)
+    var_m = float(np.var(ex_m.values, ddof=1))
+    var_m = max(var_m, 1e-9)
 
     betas: Dict[str, float] = {}
-    for s in [c for c in R.columns if c != MARKET_TICKER]:
+    for s in [c for c in R.columns if c != MARKET_PROXY]:
         ex_s = R[s] - rf_m
         cov_sm = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1])
         betas[s] = cov_sm / var_m
-    betas[MARKET_TICKER] = 1.0
 
-    # Full covariance including MARKET_TICKER
-    cov_all_ann = pd.DataFrame(np.cov(R.values.T, ddof=1) * 12.0,
-                               index=R.columns, columns=R.columns)
+    asset_cols = [c for c in R.columns if c != MARKET_PROXY]
+    cov_m = np.cov(R[asset_cols].values.T, ddof=1) if asset_cols else np.zeros((0, 0))
+    covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
 
-    return {"betas": betas, "cov_all_ann": cov_all_ann, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
+    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)
 
 def portfolio_stats(weights: Dict[str, float],
-                    cov_all_ann: pd.DataFrame,
+                    cov_ann: pd.DataFrame,
                     betas: Dict[str, float],
                     rf_ann: float,
                     erp_ann: float) -> Tuple[float, float, float]:
     tickers = list(weights.keys())
     w = np.array([weights[t] for t in tickers], dtype=float)
     gross = float(np.sum(np.abs(w)))
-    if gross <= 1e-12: return 0.0, rf_ann, 0.0
+    if gross <= 1e-12:
+        return 0.0, rf_ann, 0.0
     w_expo = w / gross
     beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
     mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-    cov = cov_all_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
+    cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
     sigma_hist = float(max(w_expo.T @ cov @ w_expo, 0.0)) ** 0.5
     return beta_p, mu_capm, sigma_hist
 
 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
 
-# -------------- plotting --------------
+# -------------- plotting (CAPM on CML) --------------
 def _pct(x): return np.asarray(x, dtype=float) * 100.0
 
-def plot_cml_hybrid(rf_ann, erp_ann, sigma_mkt,
-                    sigma_hist_port, mu_capm_port,
-                    mu_eff_same_sigma, sigma_eff_same_return,
-                    sugg_mu=None, sugg_sigma_hist=None) -> Image.Image:
-    fig = plt.figure(figsize=(6.5, 4.2), dpi=120)
-    xmax = max(0.3, sigma_mkt * 2.2, (sigma_hist_port or 0.0) * 1.6,
-               (sigma_eff_same_return or 0.0) * 1.6, (sugg_sigma_hist or 0.0) * 1.6)
-    xs = np.linspace(0.0, xmax, 240)
-    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs if sigma_mkt > 1e-12 else np.full_like(xs, rf_ann)
+def _clamp_to_cml_y(mu_capm, sigma_hist, rf_ann, erp_ann, sigma_mkt):
+    # Return y that never exceeds CML at given (historical) sigma
+    slope = erp_ann / max(sigma_mkt, 1e-12)
+    y_cml = rf_ann + slope * max(0.0, float(sigma_hist))
+    return float(min(mu_capm, y_cml))
+
+def plot_cml(rf_ann, erp_ann, sigma_mkt,
+             sigma_hist_p, mu_capm_p,
+             same_sigma_mu, same_mu_sigma,
+             sugg_sigma_hist=None, sugg_mu_capm=None) -> Image.Image:
+
+    fig = plt.figure(figsize=(6.5, 4.3), dpi=120)
+
+    xmax = max(0.3, sigma_mkt * 2.4, (sigma_hist_p or 0.0) * 1.6, (sugg_sigma_hist or 0.0) * 1.6)
+    xs = np.linspace(0, xmax, 200)
+    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs
+
     plt.plot(_pct(xs), _pct(cml), label="CML (Market/Bills)", linewidth=1.8)
-    plt.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free", zorder=3)
-    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market", zorder=3)
-    plt.scatter([_pct(sigma_hist_port)], [_pct(mu_capm_port)], label="Your CAPM point", marker="o", zorder=4)
-    plt.scatter([_pct(sigma_hist_port)], [_pct(mu_eff_same_sigma)], label="Efficient (same σ)", marker="^", zorder=4)
-    plt.scatter([_pct(sigma_eff_same_return)], [_pct(mu_capm_port)], label="Efficient (same E[r])", marker="s", zorder=4)
-    if (sugg_mu is not None) and (sugg_sigma_hist is not None):
-        plt.scatter([_pct(sugg_sigma_hist)], [_pct(sugg_mu)], label="Selected Suggestion", marker="X", s=70, zorder=5)
-    plt.xlabel("σ (historical, annualized, %)"); plt.ylabel("CAPM E[r] (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.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free")
+    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market")
+
+    # Your CAPM point (y clamped under CML; x = historical σ)
+    y_you = _clamp_to_cml_y(mu_capm_p, sigma_hist_p, rf_ann, erp_ann, sigma_mkt)
+    plt.scatter([_pct(sigma_hist_p)], [_pct(y_you)], label="Your CAPM point")
+
+    # Efficient points
+    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], label="Efficient (same σ)", marker="^")
+    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], marker="^")  # ensure visible
+
+    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], marker="^")
+
+    a_mu_sigma = same_mu_sigma
+    a_sigma_mu = same_sigma_mu
+    plt.scatter([_pct(a_mu_sigma)], [_pct(a_sigma_mu)], marker="^", label="Efficient (same E[r])")
+
+    # Selected suggestion (if any)
+    if sugg_sigma_hist is not None and sugg_mu_capm is not None:
+        y_s = _clamp_to_cml_y(sugg_mu_capm, sugg_sigma_hist, rf_ann, erp_ann, sigma_mkt)
+        plt.scatter([_pct(sugg_sigma_hist)], [_pct(y_s)], label="Selected Suggestion", marker="X", s=60)
+
+    plt.xlabel("σ (historical, annualized, %)")
+    plt.ylabel("CAPM E[r] (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 (re-weights of SAME tickers) --------------
-def build_synthetic_dataset_same_tickers(tickers: List[str],
-                                         cov_all_ann: pd.DataFrame,
-                                         betas: Dict[str, float],
-                                         rf_ann: float,
-                                         erp_ann: float,
-                                         n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
-    """Generate long-only Dirichlet weights over EXACTLY the user's tickers."""
+# -------------- synthetic dataset (from current universe only) --------------
+def build_synthetic_dataset(universe: List[str],
+                            covA: pd.DataFrame,
+                            betas: Dict[str, float],
+                            rf_ann: float,
+                            erp_ann: float,
+                            sigma_mkt: float,
+                            n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
     rng = np.random.default_rng(12345)
-    picks = [t for t in tickers]  # fixed set
-    k = len(picks)
+    assets = list(universe)
+    if not assets:
+        return pd.DataFrame(columns=["tickers","weights","beta","mu_capm","sigma_hist"])
+
     rows = []
     for _ in range(n_rows):
-        w = rng.dirichlet(np.ones(k))
+        k = int(rng.integers(low=2, high=min(8, len(assets)) + 1))
+        picks = list(rng.choice(assets, size=k, replace=False))
+        w = rng.dirichlet(np.ones(k))  # long-only, sum=1
         beta_p = float(np.dot([betas.get(t, 0.0) for t in picks], w))
         mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-        sub_cov = cov_all_ann.reindex(index=picks, columns=picks).fillna(0.0).to_numpy()
-        sigma_hist = float(max(w.T @ sub_cov @ w, 0.0)) ** 0.5
+        sub = covA.reindex(index=picks, columns=picks).fillna(0.0).to_numpy()
+        sigma_hist = float(max(w.T @ sub @ w, 0.0)) ** 0.5
+
         rows.append({
             "tickers": ",".join(picks),
-            "weights": ",".join(f"{x:.6f}" for x in w),
+            "weights": ",".join(f"{x:.8f}" for x in w),
             "beta": beta_p,
             "mu_capm": mu_capm,
             "sigma_hist": sigma_hist
         })
     return pd.DataFrame(rows)
 
+# ---- band helpers (by historical sigma) ----
 def _band_bounds_sigma_hist(sigma_mkt: float, band: str) -> Tuple[float, float]:
     band = (band or "Medium").strip().lower()
-    if band.startswith("low"): return 0.0, 0.8 * sigma_mkt
-    if band.startswith("high"): return 1.2 * sigma_mkt, 3.0 * sigma_mkt
+    if band.startswith("low"):
+        return 0.0, 0.8 * sigma_mkt
+    if band.startswith("high"):
+        return 1.2 * sigma_mkt, 3.0 * sigma_mkt
     return 0.8 * sigma_mkt, 1.2 * sigma_mkt
 
-# -------------- embeddings & scoring --------------
-_EMBED_MODEL = None
-_TICKER_EMBED_CACHE: Dict[str, np.ndarray] = {}
-
-def _load_embed_model():
-    global _EMBED_MODEL
-    if _EMBED_MODEL is not None: return _EMBED_MODEL
+def candidates_for_band(synth: pd.DataFrame, sigma_mkt: float, band: str):
+    """Return (band_df, used_fallback) ensuring Low/Medium/High are monotone in σ."""
+    lo, hi = _band_bounds_sigma_hist(sigma_mkt, band)
+    band_df = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)]
+    if not band_df.empty:
+        return band_df.copy(), False
+
+    # widen gradually
+    widen = 0.15
+    for _ in range(4):
+        lo = max(0.0, lo * (1.0 - widen))
+        hi = hi * (1.0 + widen)
+        band_df = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)]
+        if not band_df.empty:
+            return band_df.copy(), True
+
+    # quantile fallback
+    q1 = synth["sigma_hist"].quantile(0.33)
+    q2 = synth["sigma_hist"].quantile(0.66)
+    b = (band or "medium").lower()
+    if b.startswith("low"):
+        band_df = synth[synth["sigma_hist"] <= q1]
+    elif b.startswith("high"):
+        band_df = synth[synth["sigma_hist"] >= q2]
+    else:
+        band_df = synth[(synth["sigma_hist"] > q1) & (synth["sigma_hist"] < q2)]
+    return band_df.copy(), True
+
+# -------------- Embeddings & scoring (always on; fail gracefully) --------------
+def _load_st_model():
     try:
         from sentence_transformers import SentenceTransformer
-        _EMBED_MODEL = SentenceTransformer(EMBED_MODEL_NAME)
+        return SentenceTransformer("FinLang/finance-embeddings-investopedia")
     except Exception:
-        _EMBED_MODEL = None
-    return _EMBED_MODEL
-
-def _embed_texts(texts: List[str]) -> np.ndarray:
-    model = _load_embed_model()
-    if model is None: return np.zeros((len(texts), 384), dtype=float)
-    return np.array(model.encode(texts), dtype=float)
+        return None
 
-def _ticker_vec(t: str) -> np.ndarray:
-    t = t.upper().strip()
-    if t in _TICKER_EMBED_CACHE: return _TICKER_EMBED_CACHE[t]
-    v = _embed_texts([f"ticker {t}"])[0]; _TICKER_EMBED_CACHE[t] = v; return v
+def _encode(model, texts: List[str]) -> np.ndarray:
+    if model is None:
+        # Offline fallback: deterministic pseudo-embeddings from hash
+        rng = np.random.default_rng(42)
+        return rng.normal(size=(len(texts), 384)).astype(np.float32)
+    vecs = model.encode(texts, show_progress_bar=False, normalize_embeddings=True)
+    return np.asarray(vecs, dtype=np.float32)
 
 def _portfolio_embedding(tickers: List[str], weights: List[float]) -> np.ndarray:
-    if not tickers: return np.zeros(384, dtype=float)
-    w = np.array(weights, dtype=float); s = float(np.sum(np.abs(w)))
-    w = (np.ones(len(tickers))/len(tickers)) if s<=1e-12 else (w/s)
-    vs = np.stack([_ticker_vec(t) for t in tickers], axis=0)
-    v = (w[:,None]*vs).sum(axis=0); n = float(np.linalg.norm(v))
-    return v/(n if n>1e-12 else 1.0)
+    model = _load_st_model()
+    texts = [f"ticker {t}" for t in tickers]
+    embs = _encode(model, texts)
+    w = np.asarray(weights, dtype=float)
+    s = np.sum(np.abs(w)) or 1.0
+    w = np.abs(w) / s
+    v = (embs * w[:, None]).sum(axis=0, keepdims=False)
+    n = np.linalg.norm(v) or 1.0
+    return (v / n).astype(np.float32)
 
 def _cos_sim(a: np.ndarray, b: np.ndarray) -> float:
-    na = float(np.linalg.norm(a)); nb = float(np.linalg.norm(b))
-    if na<=1e-12 or nb<=1e-12: return 0.0
-    return float(np.dot(a,b)/(na*nb))
-
-def _exposure_similarity(user_map: Dict[str,float], cand_map: Dict[str,float]) -> float:
-    s_user = sum(abs(x) for x in user_map.values()); s_c = sum(abs(x) for x in cand_map.values())
-    if s_user<=1e-12 or s_c<=1e-12: return 0.0
-    u = {k:abs(v)/s_user for k,v in user_map.items()}
-    c = {k:abs(v)/s_c for k,v in cand_map.items()}
-    common = set(u)&set(c); return float(sum(min(u[t],c[t]) for t in common))
-
-def pick_best_in_band(user_df: pd.DataFrame, band_df: pd.DataFrame,
-                      alpha: float = EMBED_ALPHA, top_N: int = 50) -> pd.Series:
-    """
-    Score candidates by alpha*exposure-sim + (1-alpha)*embedding-sim, among top_N by CAPM return.
-    Return the single best row.
-    """
-    if band_df.empty: return pd.Series(dtype="float64")
+    da = float(np.linalg.norm(a)); db = float(np.linalg.norm(b))
+    if da <= 1e-12 or db <= 1e-12: return 0.0
+    return float(np.dot(a, b) / (da * db))
+
+def _exposure_similarity(u: Dict[str, float], c: Dict[str, float]) -> float:
+    # 1 - 0.5*L1 distance over common union; in [0,1]
+    keys = sorted(set(u.keys()) | set(c.keys()))
+    uvec = np.array([u.get(k, 0.0) for k in keys]); uvec = np.abs(uvec) / (np.sum(np.abs(uvec)) or 1.0)
+    cvec = np.array([c.get(k, 0.0) for k in keys]); cvec = np.abs(cvec) / (np.sum(np.abs(cvec)) or 1.0)
+    dist = float(np.sum(np.abs(uvec - cvec)))
+    return float(max(0.0, 1.0 - 0.5 * dist))
+
+def _mmr_select(rows: pd.DataFrame, scores: np.ndarray, topk: int, lam: float) -> List[int]:
+    if len(rows) <= topk:
+        return list(range(len(rows)))
+    chosen = []
+    cand = list(range(len(rows)))
+    sims_cache = {}
+    # precompute embeddings of candidates for diversity
+    embs = []
+    for _, r in rows.iterrows():
+        ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
+        ws = [float(x) for x in str(r["weights"]).split(",")]
+        embs.append(_portfolio_embedding(ts, ws))
+    embs = np.stack(embs, axis=0)
+
+    while len(chosen) < topk and cand:
+        # pick argmax of lam*score - (1-lam)*max_sim_to_chosen
+        best_i = None; best_val = -1e9
+        for i in cand:
+            if not chosen:
+                val = float(scores[i])
+            else:
+                max_sim = max(_cos_sim(embs[i], embs[j]) for j in chosen)
+                val = lam * float(scores[i]) - (1.0 - lam) * float(max_sim)
+            if val > best_val:
+                best_val, best_i = val, i
+        chosen.append(best_i)
+        cand.remove(best_i)
+    return chosen
+
+def pick_best_in_band(user_df: pd.DataFrame,
+                      band_df: pd.DataFrame,
+                      alpha: float = EMBED_ALPHA,
+                      top_N: int = 50) -> pd.Series:
+    if band_df.empty:
+        return pd.Series(dtype="float64")
     try:
-        # restrict to strong candidates by return first
         band_df = band_df.sort_values("mu_capm", ascending=False).head(top_N).reset_index(drop=True)
 
         u_t = user_df["ticker"].astype(str).str.upper().tolist()
@@ -283,27 +403,36 @@ def pick_best_in_band(user_df: pd.DataFrame, band_df: pd.DataFrame,
         for _, r in band_df.iterrows():
             ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
             ws = [float(x) for x in str(r["weights"]).split(",")]
-            s = sum(max(0.0,w) for w in ws) or 1.0
-            ws = [max(0.0,w)/s for w in ws]
-            c_map = {t:w for t,w in zip(ts,ws)}
+            s = sum(max(0.0, w) for w in ws) or 1.0
+            ws = [max(0.0, w) / s for w in ws]
+            c_map = {t: w for t, w in zip(ts, ws)}
             c_embed = _portfolio_embedding(ts, ws)
             expo_sim = _exposure_similarity(u_map, c_map)
             emb_sim = _cos_sim(u_embed, c_embed)
-            scores.append(alpha*expo_sim + (1.0-alpha)*emb_sim)
+            scores.append(alpha * expo_sim + (1.0 - alpha) * emb_sim)
 
-        i_best = int(np.argmax(scores))
-        return band_df.iloc[i_best]
+        # Take the best after MMR top-3 selection (but return only #1)
+        top_idxs = _mmr_select(band_df, np.asarray(scores), topk=3, lam=MMR_LAMBDA)
+        best_idx = top_idxs[0]
+        return band_df.iloc[best_idx]
     except Exception:
         return band_df.iloc[0]
 
 # -------------- UI helpers --------------
-def empty_positions_df(): return pd.DataFrame(columns=["ticker","amount_usd","weight_exposure","beta"])
-def empty_holdings_df(): return pd.DataFrame(columns=["ticker","weight_%","amount_$"])
+def empty_positions_df():
+    return pd.DataFrame(columns=["ticker", "amount_usd", "weight_exposure", "beta"])
+
+def empty_suggestion_df():
+    return pd.DataFrame(columns=["ticker", "weight_%", "amount_$"])
 
 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)
+    y = max(1.0, min(100.0, float(years)))
+    code = fred_series_for_horizon(y)
+    rf = fetch_fred_yield_annual(code)
     global HORIZON_YEARS, RF_CODE, RF_ANN
-    HORIZON_YEARS, RF_CODE, RF_ANN = y, code, rf
+    HORIZON_YEARS = y
+    RF_CODE = code
+    RF_ANN = rf
     return f"Risk-free series {code}. Latest annual rate {rf:.2%}."
 
 def search_tickers_cb(q: str):
@@ -313,50 +442,52 @@ def search_tickers_cb(q: str):
 
 def add_symbol(selection: str, table: Optional[pd.DataFrame]):
     if not selection:
-        return table if isinstance(table,pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "Pick a row in Matches first."
+        return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "Pick a row in Matches first."
     symbol = selection.split("|")[0].strip().upper()
+
     current = []
-    if isinstance(table,pd.DataFrame) and not table.empty:
+    if isinstance(table, pd.DataFrame) and not table.empty:
         current = [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
     tickers = current if symbol in current else current + [symbol]
+
+    # do NOT auto-add MARKET_PROXY; validate uses it only for data fetch
     val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
     tickers = [t for t in tickers if t in val]
+
     amt_map = {}
-    if isinstance(table,pd.DataFrame) and not table.empty:
+    if isinstance(table, pd.DataFrame) and not table.empty:
         for _, r in table.iterrows():
-            t = str(r.get("ticker","")).upper()
+            t = str(r.get("ticker", "")).upper()
             if t in tickers:
-                amt_map[t] = float(pd.to_numeric(r.get("amount_usd",0.0), errors="coerce") or 0.0)
-    new_table = pd.DataFrame({"ticker": tickers, "amount_usd": [amt_map.get(t,0.0) for t in tickers]})
+                amt_map[t] = float(pd.to_numeric(r.get("amount_usd", 0.0), errors="coerce") or 0.0)
+
+    new_table = pd.DataFrame({"ticker": tickers, "amount_usd": [amt_map.get(t, 0.0) for t in tickers]})
     if len(new_table) > MAX_TICKERS:
-        new_table = new_table.iloc[:MAX_TICKERS]; return new_table, f"Reached max of {MAX_TICKERS}."
+        new_table = new_table.iloc[:MAX_TICKERS]
+        return new_table, f"Reached max of {MAX_TICKERS}."
     return new_table, f"Added {symbol}."
 
 def lock_ticker_column(tb: Optional[pd.DataFrame]):
-    if not isinstance(tb,pd.DataFrame) or tb.empty:
-        return pd.DataFrame(columns=["ticker","amount_usd"])
+    if not isinstance(tb, pd.DataFrame) or tb.empty:
+        return pd.DataFrame(columns=["ticker", "amount_usd"])
     tickers = [str(x).upper() for x in tb["ticker"].tolist()]
     amounts = pd.to_numeric(tb["amount_usd"], errors="coerce").fillna(0.0).tolist()
     val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
     tickers = [t for t in tickers if t in val]
-    amounts = amounts[:len(tickers)] + [0.0]*max(0, len(tickers)-len(amounts))
+    amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
     return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
 
-# -------------- compute core --------------
-UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
-
-def _row_to_holdings(row: pd.Series, budget: float) -> pd.DataFrame:
-    if row is None or row.empty: return empty_holdings_df()
-    ts = [t.strip().upper() for t in str(row["tickers"]).split(",")]
-    ws = [float(x) for x in str(row["weights"]).split(",")]
-    s = sum(max(0.0,w) for w in ws) or 1.0
-    ws = [max(0.0,w)/s for w in ws]
-    return pd.DataFrame([{"ticker": t, "weight_%": round(w*100,2), "amount_$": round(w*budget,0)} for t,w in zip(ts,ws)],
-                        columns=["ticker","weight_%","amount_$"])
-
-def compute_all(years_lookback: int, table: Optional[pd.DataFrame]):
-    # sanitize input table
-    df = table.copy() if isinstance(table,pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"])
+# ---- compute all once; then we switch the displayed band without recomputing ----
+def compute_all(
+    years_lookback: int,
+    table: Optional[pd.DataFrame],
+    risk_horizon_years: float
+):
+    # sanitize table
+    if isinstance(table, pd.DataFrame):
+        df = table.copy()
+    else:
+        df = pd.DataFrame(columns=["ticker", "amount_usd"])
     df = df.dropna(how="all")
     if "ticker" not in df.columns: df["ticker"] = []
     if "amount_usd" not in df.columns: df["amount_usd"] = []
@@ -364,54 +495,63 @@ def compute_all(years_lookback: int, table: Optional[pd.DataFrame]):
     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: raise gr.Error("Add at least one ticker.")
-    symbols = validate_tickers(symbols, years_lookback)
-    if len(symbols)==0: raise gr.Error("Could not validate any tickers.")
+    if len(symbols) == 0:
+        return {"error": "Add at least one ticker."}
 
-    global UNIVERSE
-    # Universe is your exact tickers (for suggestions we re-weight SAME tickers)
-    UNIVERSE = list(sorted(set(symbols)))[:MAX_TICKERS]
+    symbols = validate_tickers(symbols, years_lookback)
+    if len(symbols) == 0:
+        return {"error": f"Could not validate any tickers (also need market data for {MARKET_PROXY})."}
 
-    df = df[df["ticker"].isin(symbols)].copy()
-    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
+    amounts = {t: float(df[df["ticker"] == t]["amount_usd"].iloc[0]) for t in symbols}
     rf_ann = RF_ANN
 
+    # Moments vs market proxy
     moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
-    betas, cov_all_ann, erp_ann, sigma_mkt = moms["betas"], moms["cov_all_ann"], moms["erp_ann"], moms["sigma_m_ann"]
+    betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
 
+    # Weights (exposures)
     gross = sum(abs(v) for v in amounts.values())
-    if gross <= 1e-12: raise gr.Error("All amounts are zero.")
-    weights = {k: v/gross for k,v in amounts.items()}
+    if gross <= 1e-12:
+        return {"error": "All amounts are zero."}
+    weights = {k: v / gross for k, v in amounts.items()}
 
-    beta_p, mu_capm, sigma_hist = portfolio_stats(weights, cov_all_ann, betas, rf_ann, erp_ann)
+    # Portfolio CAPM stats
+    beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
 
+    # Efficient alternatives (market/bills)
     a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_hist, rf_ann, erp_ann, sigma_mkt)
     a_mu, b_mu, sigma_eff_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
 
-    # dataset: re-weight EXACT same tickers you entered
-    synth = build_synthetic_dataset_same_tickers(UNIVERSE, cov_all_ann, betas, rf_ann, erp_ann, n_rows=SYNTH_ROWS)
+    # Synthetic dataset & suggestions (universe = user's tickers only)
+    synth = build_synthetic_dataset(symbols, covA, betas, rf_ann, erp_ann, sigma_mkt, n_rows=SYNTH_ROWS)
     csv_path = os.path.join(DATA_DIR, f"investor_profiles_{int(time.time())}.csv")
-    try: synth.to_csv(csv_path, index=False)
-    except Exception: csv_path = None
-
-    # one suggestion per band (best by embedding/exposure score among candidates in band)
-    def best_for_band(band: str) -> pd.Series:
-        lo, hi = _band_bounds_sigma_hist(sigma_mkt, band)
-        band_df = synth[(synth["sigma_hist"]>=lo) & (synth["sigma_hist"]<=hi)].copy()
-        if band_df.empty: band_df = synth.copy()
-        user_df = pd.DataFrame({"ticker": list(weights.keys()), "amount_usd": [amounts[t] for t in weights.keys()]})
-        return pick_best_in_band(user_df, band_df, EMBED_ALPHA, top_N=50)
-
-    best_low = best_for_band("Low")
-    best_med = best_for_band("Medium")
-    best_high = best_for_band("High")
-
-    # derived displays
-    pos_table = pd.DataFrame([{
-        "ticker": t, "amount_usd": amounts.get(t,0.0),
-        "weight_exposure": weights.get(t,0.0),
-        "beta": betas.get(t, np.nan) if t != MARKET_TICKER else 1.0
-    } for t in symbols], columns=["ticker","amount_usd","weight_exposure","beta"])
+    try:
+        synth.to_csv(csv_path, index=False)
+    except Exception:
+        csv_path = None
+
+    # one suggestion per band
+    def best_for_band(band: str):
+        band_df, used_fallback = candidates_for_band(synth, sigma_mkt, band)
+        user_df = pd.DataFrame({"ticker": list(weights.keys()),
+                                "amount_usd": [amounts[t] for t in weights.keys()]})
+        row = pick_best_in_band(user_df, band_df, EMBED_ALPHA, top_N=50)
+        return row, used_fallback
+
+    best_low, low_fb   = best_for_band("Low")
+    best_med, med_fb   = best_for_band("Medium")
+    best_high, high_fb = best_for_band("High")
+
+    # positions table
+    pos_table = pd.DataFrame(
+        [{
+            "ticker": t,
+            "amount_usd": amounts.get(t, 0.0),
+            "weight_exposure": weights.get(t, 0.0),
+            "beta": betas.get(t, np.nan)
+        } for t in symbols],
+        columns=["ticker", "amount_usd", "weight_exposure", "beta"]
+    )
 
     info = "\n".join([
         "### Inputs",
@@ -430,85 +570,155 @@ def compute_all(years_lookback: int, table: Optional[pd.DataFrame]):
         f"- Same σ as your portfolio: Market {a_sigma:.2f}, Bills {b_sigma:.2f} → E[r] {mu_eff_sigma:.2%}",
         f"- Same E[r] as your portfolio: Market {a_mu:.2f}, Bills {b_mu:.2f} → σ {sigma_eff_mu:.2%}",
         "",
-        "_Suggestions are single picks per band, re-weighting **the same tickers you entered**, and are chosen via embeddings + exposure similarity._",
-        "_All points are guaranteed on/under the CML because σ uses the full covariance (incl. market)._"
+        "_All plotted points are on/under the CML; if CAPM E[r] exceeds the CML at a given σ, we clamp to CML for visualization._"
     ])
 
-    uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
-    return dict(rf_ann=rf_ann, erp_ann=erp_ann, sigma_mkt=sigma_mkt,
-                mu_capm=mu_capm, sigma_hist=sigma_hist,
-                mu_eff_same_sigma=mu_eff_sigma, sigma_eff_same_return=sigma_eff_mu,
-                pos_table=pos_table, info=info, uni_msg=uni_msg, csv_path=csv_path,
-                best_low=best_low, best_med=best_med, best_high=best_high,
-                budget=gross)
-
-def render_with_band(years_lookback: int, table: Optional[pd.DataFrame], which_band: str):
-    outs = compute_all(years_lookback, table)
-    # pick which suggestion to highlight
-    row = outs["best_med"]
-    if (which_band or "").lower().startswith("low"): row = outs["best_low"]
-    if (which_band or "").lower().startswith("high"): row = outs["best_high"]
-
-    sugg_mu = None; sugg_sigma_hist = None; holdings = empty_holdings_df()
-    if isinstance(row, pd.Series) and not row.empty:
-        sugg_mu = float(row["mu_capm"]); sugg_sigma_hist = float(row["sigma_hist"])
-        holdings = _row_to_holdings(row, outs["budget"])
-
-    img = plot_cml_hybrid(
-        outs["rf_ann"], outs["erp_ann"], outs["sigma_mkt"],
-        outs["sigma_hist"], outs["mu_capm"],
-        outs["mu_eff_same_sigma"], outs["sigma_eff_same_return"],
-        sugg_mu, sugg_sigma_hist
+    outs = dict(
+        ok=True,
+        rf_ann=rf_ann, erp_ann=erp_ann, sigma_mkt=sigma_mkt,
+        sigma_hist=sigma_hist, mu_capm=mu_capm,
+        same_sigma_mu=mu_eff_sigma, same_mu_sigma=sigma_eff_mu,
+        positions=pos_table, csv_path=csv_path, symbols=symbols,
+        amounts=amounts, weights=weights,
+        best_low=best_low, best_med=best_med, best_high=best_high,
+        low_fb=low_fb, med_fb=med_fb, high_fb=high_fb,
+        budget=gross
+    )
+    return outs
+
+def _row_to_table(row: pd.Series, budget: float) -> pd.DataFrame:
+    if row is None or row.empty:
+        return empty_suggestion_df()
+    ts = [t.strip().upper() for t in str(row["tickers"]).split(",")]
+    ws = [float(x) for x in str(row["weights"]).split(",")]
+    s = sum(max(0.0, w) for w in ws) or 1.0
+    ws = [max(0.0, w) / s for w in ws]
+    return pd.DataFrame(
+        [{"ticker": t, "weight_%": round(w*100.0, 2), "amount_$": round(w*budget, 0)} for t, w in zip(ts, ws)],
+        columns=["ticker", "weight_%", "amount_$"]
+    )
+
+def _band_stats(label: str, s: pd.Series, used_fallback: bool) -> str:
+    if s is None or s.empty:
+        return f"**{label}:** —"
+    tag = " *(fallback)*" if used_fallback else ""
+    return (f"**{label}:** CAPM E[r] {float(s['mu_capm'])*100:.2f}%, "
+            f"σ(h) {float(s['sigma_hist'])*100:.2f}%{tag}")
+
+def render_with_band(outs: dict, band: str):
+    if not outs.get("ok", False):
+        msg = outs.get("error", "Unknown error.")
+        return None, msg, msg, empty_positions_df(), empty_suggestion_df(), None, "—", "—", "—"
+
+    rf_ann, erp_ann, sigma_mkt = outs["rf_ann"], outs["erp_ann"], outs["sigma_mkt"]
+    sigma_hist, mu_capm = outs["sigma_hist"], outs["mu_capm"]
+    same_sigma_mu, same_mu_sigma = outs["same_sigma_mu"], outs["same_mu_sigma"]
+
+    pick = outs["best_low"] if band == "Low" else outs["best_high"] if band == "High" else outs["best_med"]
+    sugg_sigma = float(pick["sigma_hist"]) if (pick is not None and not pick.empty) else None
+    sugg_mu = float(pick["mu_capm"]) if (pick is not None and not pick.empty) else None
+
+    img = plot_cml(
+        rf_ann, erp_ann, sigma_mkt,
+        sigma_hist, mu_capm,
+        same_sigma_mu, same_mu_sigma,
+        sugg_sigma_hist=sugg_sigma, sugg_mu_capm=sugg_mu
     )
 
-    # small stats for each band (single pick)
-    def _band_stats(s: pd.Series) -> str:
-        if s is None or s.empty: return "—"
-        return f"CAPM E[r] {float(s['mu_capm'])*100:.2f}%, σ(h) {float(s['sigma_hist'])*100:.2f}%"
+    low_stats  = _band_stats("Low",    outs["best_low"],  outs["low_fb"])
+    med_stats  = _band_stats("Medium", outs["best_med"],  outs["med_fb"])
+    high_stats = _band_stats("High",   outs["best_high"], outs["high_fb"])
 
-    low_stats = _band_stats(outs["best_low"])
-    med_stats = _band_stats(outs["best_med"])
-    high_stats = _band_stats(outs["best_high"])
+    sugg_table = _row_to_table(pick, outs["budget"])
+    positions = outs["positions"]
+    csv_path = outs["csv_path"]
+
+    # We also show universe status as text
+    uni_msg = f"Universe set to: {', '.join(outs['symbols'])}"
+    summary = "\n" + (render_summary_text := "")  # placeholder so we keep existing 'info' below
+
+    # Use the prebuilt summary string from compute_all for the right panel
+    info_lines = [
+        "### Inputs",
+        f"- Lookback years {int(DEFAULT_LOOKBACK_YEARS)}",
+        f"- Horizon years {int(round(HORIZON_YEARS))}",
+        f"- Risk-free {rf_ann:.2%} from {RF_CODE}",
+        f"- Market ERP {erp_ann:.2%}",
+        f"- Market σ (hist) {sigma_mkt:.2%}",
+        "",
+        "### Your portfolio (CAPM on CML; x=σ_hist, y=CAPM E[r])",
+        f"- CAPM E[r] {mu_capm:.2%}",
+        f"- σ (historical) {sigma_hist:.2%}",
+        "",
+        "### Efficient market/bills mixes",
+        f"- Same σ: E[r] {same_sigma_mu:.2%}",
+        f"- Same E[r]: σ {same_mu_sigma:.2%}",
+    ]
+    info = "\n".join(info_lines)
 
-    return img, outs["info"], outs["uni_msg"], outs["pos_table"], holdings, outs["csv_path"], low_stats, med_stats, high_stats
+    return img, info, uni_msg, positions, sugg_table, csv_path, low_stats, med_stats, high_stats
 
 # -------------- UI --------------
 with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Plot uses **x = historical σ** and **y = CAPM E[r] = rf + β·ERP**. "
-        "Efficient (same σ) and (same E[r]) market/bills points are shown.\n\n"
-        "**Suggestions:** We re-weight the **same tickers you entered** to produce one Low/Medium/High pick. "
-        "Embeddings + exposure similarity select the best pick in each band."
+        "Enter **$ amounts** for your tickers (negatives allowed), set horizon. "
+        "Plot shows your **CAPM point on the CML** using historical σ on the x-axis. "
+        "Suggestions are generated from your tickers only; embeddings + MMR are always on."
     )
+
+    state = gr.State(value=None)  # stores compute_all outputs
+
     with gr.Row():
         with gr.Column(scale=1):
-            q = gr.Textbox(label="Search symbol"); search_note = gr.Markdown()
+            q = gr.Textbox(label="Search symbol")
+            search_note = gr.Markdown()
             matches = gr.Dropdown(choices=[], label="Matches")
-            with gr.Row():
-                search_btn = gr.Button("Search"); add_btn = gr.Button("Add selected to portfolio")
+            search_btn = gr.Button("Search")
+            add_btn = gr.Button("Add selected to portfolio")
+
             gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed)")
-            table = gr.Dataframe(value=pd.DataFrame(columns=["ticker","amount_usd"]), interactive=True)
+            table = gr.Dataframe(
+                headers=["ticker", "amount_usd"],
+                datatype=["str", "number"],
+                row_count=0,
+                col_count=(2, "fixed")
+            )
+
             horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
-            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years")
+            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
 
             gr.Markdown("### Suggestions (one per band)")
             with gr.Row():
-                low_btn  = gr.Button("Show Low")
-                med_btn  = gr.Button("Show Medium")
-                high_btn = gr.Button("Show High")
-            low_txt  = gr.Markdown("Low: —")
-            med_txt  = gr.Markdown("Medium: —")
-            high_txt = gr.Markdown("High: —")
+                btn_low = gr.Button("Show Low")
+                btn_med = gr.Button("Show Medium")
+                btn_high = gr.Button("Show High")
+
+            low_line  = gr.Markdown(value="**Low:** —")
+            med_line  = gr.Markdown(value="**Medium:** —")
+            high_line = gr.Markdown(value="**High:** —")
 
             run_btn = gr.Button("Compute (build dataset & suggest)")
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
             summary = gr.Markdown(label="Inputs & Results")
             universe_msg = gr.Textbox(label="Universe status", interactive=False)
-            positions = gr.Dataframe(value=empty_positions_df(), interactive=False, label="Computed positions")
-            selected_table = gr.Dataframe(value=empty_holdings_df(), interactive=False,
-                                          label="Selected suggestion holdings (% / $)")
+            positions = gr.Dataframe(
+                label="Computed positions",
+                headers=["ticker", "amount_usd", "weight_exposure", "beta"],
+                datatype=["str", "number", "number", "number"],
+                col_count=(4, "fixed"),
+                value=empty_positions_df(),
+                interactive=False
+            )
+            sugg_table = gr.Dataframe(
+                label="Selected suggestion — holdings shown in % and $ (from *your* tickers only)",
+                headers=["ticker", "weight_%", "amount_$"],
+                datatype=["str", "number", "number"],
+                col_count=(3, "fixed"),
+                value=empty_suggestion_df(),
+                interactive=False
+            )
             dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
     # wire search / add / locking / horizon
@@ -517,34 +727,41 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
-    # main compute (defaults to Medium highlighted)
+    # main compute
+    def _compute_and_show(lookback_v, table_v, horizon_v):
+        outs = compute_all(int(lookback_v), table_v, float(horizon_v))
+        if not outs.get("ok", False):
+            err = outs.get("error", "Unable to compute.")
+            # return blank UI + error in summary
+            return (outs, None, f"**Error:** {err}", err,
+                    empty_positions_df(), empty_suggestion_df(), None, "—","—","—")
+        # default show Medium
+        img, info, uni_msg, pos, st, csv_path, low_s, med_s, high_s = render_with_band(outs, "Medium")
+        return (outs, img, info, uni_msg, pos, st, csv_path, low_s, med_s, high_s)
+
     run_btn.click(
-        fn=render_with_band,
-        inputs=[lookback, table, gr.State("Medium")],
-        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
+        fn=_compute_and_show,
+        inputs=[lookback, table, horizon],
+        outputs=[state, plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line]
     )
 
-    # choose band with buttons
-    low_btn.click(
-        fn=render_with_band,
-        inputs=[lookback, table, gr.State("Low")],
-        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
-    )
-    med_btn.click(
-        fn=render_with_band,
-        inputs=[lookback, table, gr.State("Medium")],
-        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
-    )
-    high_btn.click(
-        fn=render_with_band,
-        inputs=[lookback, table, gr.State("High")],
-        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
-    )
+    # band buttons (no recompute; reuse state)
+    def _show_band(outs, band):
+        if outs is None:
+            return None, "Click Compute first.", "", empty_positions_df(), empty_suggestion_df(), None
+        return render_with_band(outs, band)
+
+    btn_low.click(fn=_show_band, inputs=[state, gr.Textbox(value="Low", visible=False)], 
+                  outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
+    btn_med.click(fn=_show_band, inputs=[state, gr.Textbox(value="Medium", visible=False)], 
+                  outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
+    btn_high.click(fn=_show_band, inputs=[state, gr.Textbox(value="High", visible=False)], 
+                   outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
 
 # initialize risk-free at launch
 RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    demo.queue()  # no concurrency_count to keep compatibility with older Gradio
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), show_api=False, share=False)
+    # No concurrency_count here (Gradio 5); let the platform set host/port
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)