Update src/streamlit_app.py

src/streamlit_app.py

@@ -1226,21 +1226,25 @@ def render_rotation_map():
 # TAB 6: COMBINED SCANNER (RRG + Bottom Scanner)
 # =========================================================
 
-# Quality / liquidity constants (applied as-of signal date, no look-ahead)
-PRICE_FLOOR  = 5.0            # min stock price
-MIN_DVOL     = 1_000_000      # min 20-day avg dollar volume
-DEDUP_DAYS   = 63             # cooldown before same ticker can re-flag
-
-def _rrg(price_series: pd.Series, benchmark: pd.Series, window: int) -> pd.DataFrame:
-    """
-    Compute RS-Ratio and RS-Momentum centred at 100.
-    price_series and benchmark must be aligned (same index).
-    """
-    rs        = price_series / (benchmark + 1e-9)
-    rs_ratio  = 100 + ((rs - rs.rolling(window).mean()) /
-                       (rs.rolling(window).std() + 1e-9)) * 5
-    rs_mom    = 100 + ((rs_ratio - rs_ratio.rolling(window).mean()) /
-                       (rs_ratio.rolling(window).std() + 1e-9)) * 5
+# Quality / liquidity constants
+PRICE_FLOOR    = 5.0
+MIN_DVOL       = 1_000_000
+LARGE_CAP_DVOL = 50_000_000
+DEDUP_DAYS     = 63
+
+PRICE_FLOOR = 5.0
+MIN_DVOL    = 1_000_000    # $1M 20-day avg dollar volume — quality gate
+LARGE_CAP_DVOL = 50_000_000  # $50M for large-cap classification
+DEDUP_DAYS  = 63
+
+# ── RRG maths ─────────────────────────────────────────────────────────────────
+
+def _rrg(price: pd.Series, benchmark: pd.Series, window: int) -> pd.DataFrame:
+    rs       = price / (benchmark + 1e-9)
+    rs_ratio = 100 + ((rs - rs.rolling(window).mean()) /
+                      (rs.rolling(window).std() + 1e-9)) * 5
+    rs_mom   = 100 + ((rs_ratio - rs_ratio.rolling(window).mean()) /
+                      (rs_ratio.rolling(window).std() + 1e-9)) * 5
     return pd.DataFrame({"RS_Ratio": rs_ratio, "RS_Momentum": rs_mom})
 
 
@@ -1251,256 +1255,354 @@ def _quadrant(ratio: float, mom: float) -> str:
     else:                              return "Improving"
 
 
-QUAD_COLORS = {
-    "Leading":   "#27ae60",
-    "Weakening": "#e67e22",
-    "Lagging":   "#e74c3c",
-    "Improving": "#2980b9",
-}
+QUAD_COLORS = {"Leading": "#27ae60", "Weakening": "#e67e22",
+               "Lagging": "#e74c3c", "Improving": "#2980b9"}
+QUAD_ICONS  = {"Leading": "🟢", "Weakening": "🟠",
+               "Lagging": "🔴", "Improving": "🔵"}
+
+
+# ── Signal tier classification (core backtest findings) ───────────────────────
+
+def classify_tier(rsi: float, stretch: float, pct_from_52w: float) -> dict:
+    """
+    Returns tier (1=best / 2=good / 3=weak), estimated win%, alpha quality note,
+    and a display label — all calibrated from the 10-year backtest.
+
+    Tiers are only meaningful within LC Weakening + 2d turn entries.
+    pct_from_52w: percentage below 52-week high (negative = below, 0 = at ATH).
+    """
+
+    # ── Step 1: RSI × Stretch grid win rate ──────────────────────────────────
+    if rsi < 40:
+        base_win = 75.3
+        rsi_note = "Deep oversold RSI (<40) — strongest RSI bucket"
+        tier     = 1
+    elif rsi < 55 and stretch < -10:
+        base_win = 80.0
+        rsi_note = "Extreme stretch + moderate RSI  ⚠️ n=50 in backtest, treat carefully"
+        tier     = 1
+    elif rsi < 55 and stretch < -5:
+        base_win = 71.0
+        rsi_note = "Extended below SMA20 — solid historical edge"
+        tier     = 1
+    elif rsi < 55 and 3 <= stretch < 10:
+        base_win = 67.1
+        rsi_note = "RSI 40-55 + moderate positive stretch — strong bucket"
+        tier     = 1
+    elif rsi < 55:
+        base_win = 60.5
+        rsi_note = "RSI 40-55, mild stretch"
+        tier     = 2
+    elif rsi < 65 and stretch >= 10:
+        base_win = 67.6
+        rsi_note = "RSI 55-65 + extended stretch >10% — high momentum"
+        tier     = 1
+    elif rsi < 65 and 3 <= stretch < 10:
+        base_win = 64.7
+        rsi_note = "★ RSI 55-65 + stretch 3-10% — best alpha quality (xs_t -0.48)"
+        tier     = 2
+    elif rsi < 65:
+        base_win = 59.7
+        rsi_note = "RSI 55-65, mild stretch"
+        tier     = 2
+    elif rsi < 80 and stretch >= 10:
+        base_win = 67.9
+        rsi_note = "★★ RSI 65-80 + stretch >10% — only config with positive xs_t (+1.54)"
+        tier     = 1
+    elif rsi < 80 and 3 <= stretch < 10:
+        base_win = 53.9
+        rsi_note = "✗ RSI 65-75 + stretch 3-10% — weakest bucket, near-random"
+        tier     = 3
+    elif rsi < 80:
+        base_win = 57.3
+        rsi_note = "RSI 65-80, mild stretch — below average"
+        tier     = 3
+    else:
+        base_win = 60.8
+        rsi_note = "RSI >80 — overbought territory"
+        tier     = 2
+
+    # ── Step 2: 52-week high proximity adjustment ─────────────────────────────
+    if pct_from_52w > -5:
+        ath_adj  = -4.0   # near ATH historically weak (57% win rate)
+        ath_note = f"⚠️ Within 5% of 52w high — historically {57:.0f}% win (near-random)"
+        tier     = max(tier, 2)   # cannot be tier 1 near ATH
+    elif pct_from_52w > -10:
+        ath_adj  = -2.0
+        ath_note = f"{abs(pct_from_52w):.0f}% below 52w high — slightly below sweet spot"
+    elif pct_from_52w > -20:
+        ath_adj  = +2.0   # 10-20% below ATH: 66.3% sweet spot
+        ath_note = f"✅ {abs(pct_from_52w):.0f}% below 52w high — historical sweet spot (66%)"
+    elif pct_from_52w > -35:
+        ath_adj  = +4.0   # 20-35% below ATH: 69.3%
+        ath_note = f"✅ {abs(pct_from_52w):.0f}% below 52w high — strongest ATH bucket (69%)"
+    else:
+        ath_adj  = +3.0   # >35% below: 68.5%
+        ath_note = f"{abs(pct_from_52w):.0f}% below 52w high — deep drawdown recovery zone"
+
+    estimated_win = round(base_win + ath_adj, 1)
+
+    # Tier label
+    tier_label = {1: "🏆 Tier 1", 2: "✅ Tier 2", 3: "⚠️ Tier 3"}.get(tier, "—")
 
-QUAD_ICONS = {
-    "Leading": "🟢", "Weakening": "🟠", "Lagging": "🔴", "Improving": "🔵"
-}
+    return {
+        "tier":           tier,
+        "tier_label":     tier_label,
+        "estimated_win":  estimated_win,
+        "rsi_note":       rsi_note,
+        "ath_note":       ath_note,
+        "base_win":       base_win,
+        "ath_adj":        ath_adj,
+    }
 
 
-# ── per-ticker analysis ────────────────────────────────────────────────────────
+# ── Per-ticker analysis ────────────────────────────────────────────────────────
 
 def analyze_combined(
-    ticker: str,
-    daily_df: pd.DataFrame,
-    benchmark_daily: pd.DataFrame,
+    ticker:        str,
+    daily_df:      pd.DataFrame,
+    benchmark_bm:  pd.Series,
     weekly_window: int = 13,
     daily_window:  int = 63,
-    require_weakening_only: bool = False,
+    target_quads:  list = None,
 ) -> dict | None:
     """
-    Returns a dict of signals or None if data is insufficient.
-
-    Parameters
-    ----------
-    ticker            : ticker symbol (for labels)
-    daily_df          : OHLCV DataFrame (daily, from yfinance), indexed by Date
-    benchmark_daily   : close-price Series for the benchmark (same date range)
-    weekly_window     : z-score window in weeks (default 13 ≈ 1 quarter)
-    daily_window      : z-score window in days  (default 63 ≈ 1 quarter)
-    require_weakening_only : if True, only flag Weakening (not Lagging); closer to Gemini's
-                             79.6% win-rate config but far fewer signals
+    Returns signal dict or None if data insufficient.
+    target_quads: list of weekly quadrants to accept, default ['Weakening'].
     """
-    if daily_df is None or len(daily_df) < max(weekly_window * 5, daily_window) + 5:
+    if target_quads is None:
+        target_quads = ["Weakening"]
+
+    if daily_df is None or len(daily_df) < max(weekly_window * 5, daily_window, 252) + 5:
         return None
 
-    close = daily_df["Close"].astype(float).dropna()
-    vol   = daily_df["Volume"].astype(float)
+    close  = daily_df["Close"].astype(float).dropna()
+    volume = daily_df["Volume"].astype(float)
 
-    # ── quality gate ────────────────────────────────────────────────────────
+    # ── Quality gate ─────────────────────────────────────────────────────────
     current_price = float(close.iloc[-1])
-    dvol_20 = float(close.iloc[-20:].mean() * vol.iloc[-20:].mean()) if len(close) >= 20 else 0.0
-    quality_ok = current_price >= PRICE_FLOOR and dvol_20 >= MIN_DVOL
-
-    # ── large-cap flag (proxy: 20D avg dollar vol ≥ $50M) ──────────────────
-    large_cap = dvol_20 >= 50_000_000
+    dvol_20       = float(close.iloc[-20:].mean() * volume.iloc[-20:].mean()) if len(close) >= 20 else 0.0
+    quality_ok    = current_price >= PRICE_FLOOR and dvol_20 >= MIN_DVOL
+    large_cap     = dvol_20 >= LARGE_CAP_DVOL
+
+    # ── 52-week high proximity ────────────────────────────────────────────────
+    if len(close) >= 252:
+        high_52w    = float(close.iloc[-252:].max())
+    elif len(close) >= 126:
+        high_52w    = float(close.iloc[-126:].max())
+    else:
+        high_52w    = float(close.max())
+    pct_from_52w = (current_price / high_52w - 1) * 100  # 0 = at ATH, -20 = 20% below
 
-    # ── align benchmark ──────────────────────────────────────────────────────
-    bm = benchmark_daily.reindex(close.index, method="ffill").astype(float)
+    # ── Benchmark alignment ───────────────────────────────────────────────────
+    bm = benchmark_bm.reindex(close.index, method="ffill").astype(float)
     if bm.isna().all():
         return None
 
-    # ── DAILY RRG ───────────────────────────────────────────────────────────
-    rrg_d  = _rrg(close, bm, daily_window)
-    dx     = rrg_d["RS_Ratio"].diff()
-    dy     = rrg_d["RS_Momentum"].diff()
+    # ── Daily RRG ─────────────────────────────────────────────────────────────
+    rrg_d = _rrg(close, bm, daily_window)
+    dx    = rrg_d["RS_Ratio"].diff()
+    dy    = rrg_d["RS_Momentum"].diff()
     turn_2d = bool(
+        len(dx) >= 2 and
         dx.iloc[-1] > 0 and dy.iloc[-1] > 0 and
         dx.iloc[-2] > 0 and dy.iloc[-2] > 0
     )
 
-    # history of daily direction for the trail chart
-    daily_trail = rrg_d.tail(10).copy()
-    daily_trail["dx"] = dx.tail(10)
-    daily_trail["dy"] = dy.tail(10)
-
-    # ── WEEKLY RRG ──────────────────────────────────────────────────────────
-    close_w  = close.resample("W-FRI").last().dropna()
-    bm_w     = bm.resample("W-FRI").last().reindex(close_w.index, method="ffill")
+    # ── Weekly RRG ────────────────────────────────────────────────────────────
+    close_w = close.resample("W-FRI").last().dropna()
+    bm_w    = bm.resample("W-FRI").last().reindex(close_w.index, method="ffill")
     if len(close_w) < weekly_window + 2:
         return None
     rrg_w   = _rrg(close_w, bm_w, weekly_window)
     w_ratio = float(rrg_w["RS_Ratio"].iloc[-1])
     w_mom   = float(rrg_w["RS_Momentum"].iloc[-1])
-    weekly_quad = _quadrant(w_ratio, w_mom)
+    weekly_quad      = _quadrant(w_ratio, w_mom)
     prev_weekly_quad = _quadrant(
         float(rrg_w["RS_Ratio"].iloc[-2]),
         float(rrg_w["RS_Momentum"].iloc[-2]),
     )
 
-    # ── SIGNAL LOGIC ─────────────────────────────────────────────────────────
-    # Backtest best configs:
-    #   "Lagging or Weakening" + 2d turn  →  54.5% win (all-cap)
-    #   "Weakening only"       + 2d turn  →  60.7% win (all-cap), 79.6% large-cap
-    target_quads = ["Weakening"] if require_weakening_only else ["Lagging", "Weakening"]
-    rrg_entry    = weekly_quad in target_quads and turn_2d
-
-    # ── OPTIONAL: combine with oversold RSI / SMA stretch ────────────────────
-    sma20   = close.rolling(20).mean()
-    delta   = close.diff()
-    gain    = delta.where(delta > 0, 0).ewm(alpha=1/14, adjust=False).mean()
-    loss    = (-delta.where(delta < 0, 0)).ewm(alpha=1/14, adjust=False).mean()
-    rsi     = float(100 - 100 / (1 + gain.iloc[-1] / (loss.iloc[-1] + 1e-9)))
+    # ── RSI + Stretch ─────────────────────────────────────────────────────────
+    sma20  = close.rolling(20).mean()
+    delta  = close.diff()
+    gain   = delta.where(delta > 0, 0).ewm(alpha=1/14, adjust=False).mean()
+    loss   = (-delta.where(delta < 0, 0)).ewm(alpha=1/14, adjust=False).mean()
+    rsi    = float(100 - 100 / (1 + gain.iloc[-1] / (loss.iloc[-1] + 1e-9)))
     stretch = float((close.iloc[-1] - sma20.iloc[-1]) / (sma20.iloc[-1] + 1e-9) * 100)
 
-    # weekly RRG trail (last 6 weeks for the mini chart)
-    weekly_trail = rrg_w.tail(7).copy()
+    # ── Signal classification ─────────────────────────────────────────────────
+    rrg_entry  = weekly_quad in target_quads and turn_2d
+    signal_met = rrg_entry and quality_ok
+
+    tier_info = classify_tier(rsi, stretch, pct_from_52w) if signal_met else None
 
     return {
-        "ticker":          ticker,
-        "price":           round(current_price, 2),
-        "dvol_20m":        round(dvol_20 / 1e6, 1),
-        "quality_ok":      quality_ok,
-        "large_cap":       large_cap,
-        "rsi":             round(rsi, 1),
-        "stretch":         round(stretch, 2),
+        "ticker":           ticker,
+        "price":            round(current_price, 2),
+        "dvol_20m":         round(dvol_20 / 1e6, 1),
+        "quality_ok":       quality_ok,
+        "large_cap":        large_cap,
+        "rsi":              round(rsi, 1),
+        "stretch":          round(stretch, 2),
+        "pct_from_52w":     round(pct_from_52w, 1),
+        "high_52w":         round(high_52w, 2),
         # weekly RRG
-        "weekly_quad":     weekly_quad,
-        "prev_weekly_quad":prev_weekly_quad,
-        "w_ratio":         round(w_ratio, 2),
-        "w_mom":           round(w_mom, 2),
+        "weekly_quad":      weekly_quad,
+        "prev_weekly_quad": prev_weekly_quad,
+        "w_ratio":          round(w_ratio, 2),
+        "w_mom":            round(w_mom, 2),
         # daily RRG
-        "d_ratio":         round(float(rrg_d["RS_Ratio"].iloc[-1]), 2),
-        "d_mom":           round(float(rrg_d["RS_Momentum"].iloc[-1]), 2),
-        "dx_today":        round(float(dx.iloc[-1]), 3),
-        "dy_today":        round(float(dy.iloc[-1]), 3),
-        "turn_2d":         turn_2d,
-        # combined
-        "rrg_entry":       rrg_entry,
-        "signal_met":      rrg_entry and quality_ok,
-        # trail data for charts
-        "daily_trail":     daily_trail,
-        "weekly_trail":    weekly_trail,
-        "rrg_w_full":      rrg_w,
-        "rrg_d_full":      rrg_d,
-        "close":           close,
+        "d_ratio":          round(float(rrg_d["RS_Ratio"].iloc[-1]), 2),
+        "d_mom":            round(float(rrg_d["RS_Momentum"].iloc[-1]), 2),
+        "dx_today":         round(float(dx.iloc[-1]), 3),
+        "dy_today":         round(float(dy.iloc[-1]), 3),
+        "turn_2d":          turn_2d,
+        # signal
+        "rrg_entry":        rrg_entry,
+        "signal_met":       signal_met,
+        "tier_info":        tier_info,
+        # chart data
+        "daily_trail":      rrg_d.tail(10).copy(),
+        "weekly_trail":     rrg_w.tail(7).copy(),
+        "rrg_w_full":       rrg_w,
+        "rrg_d_full":       rrg_d,
+        "close":            close,
+        "sma20":            sma20,
     }
 
 
-# ── mini RRG chart (plotly, matches the Rotation Map tab style) ──────────────
+# ── Mini RRG chart (Plotly) ───────────────────────────────────────────────────
 
 def mini_rrg_chart(result: dict, ticker: str) -> go.Figure:
-    wt  = result["weekly_trail"]
-    dt  = result["daily_trail"]
+    wt = result["weekly_trail"]
+    dt = result["daily_trail"]
+    ti = result.get("tier_info") or {}
 
     fig = go.Figure()
 
-    # background quadrant shading
-    for x0, x1, y0, y1, color, label in [
-        (100, 112, 100, 112, "rgba(39,174,96,0.08)",  "Leading"),
-        (100, 112, 88,  100, "rgba(230,126,34,0.08)", "Weakening"),
-        (88,  100, 88,  100, "rgba(231,76,60,0.08)",  "Lagging"),
-        (88,  100, 100, 112, "rgba(41,128,185,0.08)", "Improving"),
+    # Quadrant shading
+    for x0,x1,y0,y1,color,label in [
+        (100,112,100,112,"rgba(39,174,96,0.08)",  "Leading"),
+        (100,112,88, 100,"rgba(230,126,34,0.08)", "Weakening"),
+        (88, 100,88, 100,"rgba(231,76,60,0.08)",  "Lagging"),
+        (88, 100,100,112,"rgba(41,128,185,0.08)", "Improving"),
     ]:
-        fig.add_shape(type="rect", x0=x0, x1=x1, y0=y0, y1=y1,
-                      fillcolor=color, line_width=0, layer="below")
-        fig.add_annotation(x=(x0+x1)/2, y=(y0+y1)/2, text=label,
-                           font=dict(size=10, color=color.replace("0.08","0.35")),
+        fig.add_shape(type="rect",x0=x0,x1=x1,y0=y0,y1=y1,
+                      fillcolor=color,line_width=0,layer="below")
+        fig.add_annotation(x=(x0+x1)/2,y=(y0+y1)/2,text=label,
+                           font=dict(size=10,color=color.replace("0.08","0.4")),
                            showarrow=False)
 
-    # weekly trail
+    # Weekly trail
     fig.add_trace(go.Scatter(
         x=wt["RS_Ratio"].tolist(), y=wt["RS_Momentum"].tolist(),
-        mode="lines+markers", name="Weekly RRG (6w)",
-        line=dict(color="#1f77b4", width=2),
-        marker=dict(size=[6]*len(wt), color=["#1f77b4"]*len(wt)),
+        mode="lines+markers", name="Weekly (6w)",
+        line=dict(color="#1f77b4",width=2),
+        marker=dict(size=6,color="#1f77b4"),
         text=[str(d.date()) for d in wt.index],
     ))
-    # highlight latest weekly point
+    # Latest weekly point
+    wq_color = QUAD_COLORS.get(result["weekly_quad"], "gray")
     fig.add_trace(go.Scatter(
         x=[wt["RS_Ratio"].iloc[-1]], y=[wt["RS_Momentum"].iloc[-1]],
-        mode="markers+text", name=f"Weekly now ({result['weekly_quad']})",
-        marker=dict(size=14, color=QUAD_COLORS.get(result["weekly_quad"], "gray"),
-                    symbol="diamond"),
+        mode="markers+text",
+        name=f"Weekly now ({result['weekly_quad']})",
+        marker=dict(size=14, color=wq_color, symbol="diamond"),
         text=[ticker], textposition="top center", textfont=dict(size=11),
     ))
-
-    # daily trail (last 10 bars, smaller)
+    # Daily trail
     fig.add_trace(go.Scatter(
         x=dt["RS_Ratio"].tolist(), y=dt["RS_Momentum"].tolist(),
-        mode="lines+markers", name="Daily RRG (10d)",
-        line=dict(color="orange", width=1.5, dash="dot"),
-        marker=dict(size=5, color="orange"),
+        mode="lines+markers", name="Daily (10d)",
+        line=dict(color="orange",width=1.5,dash="dot"),
+        marker=dict(size=5,color="orange"),
     ))
 
-    fig.add_hline(y=100, line_dash="dash", line_color="gray", opacity=0.4)
-    fig.add_vline(x=100, line_dash="dash", line_color="gray", opacity=0.4)
+    fig.add_hline(y=100,line_dash="dash",line_color="gray",opacity=0.4)
+    fig.add_vline(x=100,line_dash="dash",line_color="gray",opacity=0.4)
+
+    tier_label = ti.get("tier_label","")
+    est_win    = ti.get("estimated_win","")
+    subtitle   = f"{tier_label}  •  Est. {est_win}% win  •  {result['pct_from_52w']:.1f}% from 52w high" if ti else ""
 
     fig.update_layout(
-        title=f"{ticker} — Dual-TF RRG  (weekly: {result['weekly_quad']})",
+        title=f"{ticker} — Dual-TF RRG (weekly: {result['weekly_quad']})<br>"
+              f"<sup>{subtitle}</sup>",
         xaxis_title="RS-Ratio",
         yaxis_title="RS-Momentum",
-        height=380,
+        height=390,
         template="plotly_white",
-        legend=dict(orientation="h", yanchor="bottom", y=1.02),
-        margin=dict(l=40, r=20, t=60, b=40),
+        legend=dict(orientation="h",yanchor="bottom",y=1.02),
+        margin=dict(l=40,r=20,t=80,b=40),
     )
     return fig
 
 
-# ── single-ticker detailed chart (matplotlib) ────────────────────────────────
+# ── Detail chart (Matplotlib) ─────────────────────────────────────────────────
 
 def detail_chart(result: dict, ticker: str):
-    close      = result["close"]
-    rrg_d      = result["rrg_d_full"]
-    dx         = rrg_d["RS_Ratio"].diff()
-    dy         = rrg_d["RS_Momentum"].diff()
-
-    fig, axes = plt.subplots(3, 1, figsize=(13, 10), sharex=False,
-                              gridspec_kw={"height_ratios": [2.5, 1, 1]})
-
-    # Panel 1: price + 20-day SMA
+    close  = result["close"]
+    rrg_d  = result["rrg_d_full"]
+    sma20  = result["sma20"]
+    dx     = rrg_d["RS_Ratio"].diff()
+    dy     = rrg_d["RS_Momentum"].diff()
     recent = close.iloc[-120:]
-    sma20  = close.rolling(20).mean().iloc[-120:]
-    axes[0].plot(recent.index, recent.values, color="black", lw=1.5, label="Price")
-    axes[0].plot(recent.index, sma20.values, color="blue", lw=0.9, alpha=0.6, label="SMA20")
-    axes[0].set_title(f"{ticker}  |  Price + RRG Signals", fontweight="bold", fontsize=13)
-    axes[0].legend(fontsize=9); axes[0].grid(True, alpha=0.15)
+    sma_r  = sma20.iloc[-120:]
+
+    fig, axes = plt.subplots(3,1,figsize=(13,10),sharex=False,
+                              gridspec_kw={"height_ratios":[2.5,1,1]})
 
-    # shade last 2 bars green if turn_2d
+    # Price
+    axes[0].plot(recent.index,recent.values,color="black",lw=1.5,label="Price")
+    axes[0].plot(recent.index,sma_r.values,color="blue",lw=0.9,alpha=0.6,label="SMA20")
+    if result.get("high_52w"):
+        axes[0].axhline(result["high_52w"],color="gold",ls="--",lw=1,
+                        alpha=0.7,label=f"52w high ${result['high_52w']:.2f}")
     if result["turn_2d"]:
-        axes[0].axvspan(recent.index[-2], recent.index[-1],
-                        color="limegreen", alpha=0.18, label="2-day turn")
+        axes[0].axvspan(recent.index[-2],recent.index[-1],
+                        color="limegreen",alpha=0.18,label="2-day turn")
 
-    # Panel 2: daily RS-Ratio with direction markers
+    ti = result.get("tier_info") or {}
+    title_extra = f"  |  {ti.get('tier_label','')}  Est. {ti.get('estimated_win','')}% win  {result['pct_from_52w']:.1f}% from 52w high" if ti else ""
+    axes[0].set_title(f"{ticker}{title_extra}",fontweight="bold",fontsize=12)
+    axes[0].legend(fontsize=8); axes[0].grid(True,alpha=0.15)
+
+    # Daily RS-Ratio
     rd = rrg_d["RS_Ratio"].iloc[-120:]
-    axes[1].plot(rd.index, rd.values, color="#1f77b4", lw=1.5)
-    axes[1].axhline(100, color="gray", ls="--", lw=0.8)
     pos_d = dx.iloc[-120:] > 0
-    axes[1].fill_between(rd.index, rd.values, 100,
-                          where=pos_d.values, alpha=0.2, color="green", label="RS-Ratio > yesterday")
-    axes[1].fill_between(rd.index, rd.values, 100,
-                          where=~pos_d.values, alpha=0.15, color="red", label="RS-Ratio < yesterday")
-    axes[1].set_title("Daily RS-Ratio  (green = gaining vs benchmark, red = losing)", fontsize=10)
-    axes[1].legend(fontsize=8); axes[1].grid(True, alpha=0.15)
-
-    # Panel 3: daily RS-Momentum
+    axes[1].plot(rd.index,rd.values,color="#1f77b4",lw=1.5)
+    axes[1].axhline(100,color="gray",ls="--",lw=0.8)
+    axes[1].fill_between(rd.index,rd.values,100,where=pos_d.values,
+                          alpha=0.2,color="green",label="Gaining vs RSP")
+    axes[1].fill_between(rd.index,rd.values,100,where=~pos_d.values,
+                          alpha=0.15,color="red",label="Losing vs RSP")
+    axes[1].set_title("Daily RS-Ratio vs RSP",fontsize=10)
+    axes[1].legend(fontsize=8); axes[1].grid(True,alpha=0.15)
+
+    # Daily RS-Momentum
     rm = rrg_d["RS_Momentum"].iloc[-120:]
     pos_m = dy.iloc[-120:] > 0
-    axes[2].plot(rm.index, rm.values, color="purple", lw=1.5)
-    axes[2].axhline(100, color="gray", ls="--", lw=0.8)
-    axes[2].fill_between(rm.index, rm.values, 100,
-                          where=pos_m.values, alpha=0.2, color="green", label="Momentum rising")
-    axes[2].fill_between(rm.index, rm.values, 100,
-                          where=~pos_m.values, alpha=0.15, color="red", label="Momentum falling")
-    axes[2].set_title("Daily RS-Momentum  (green = 2d+ both rising = entry signal)", fontsize=10)
-    axes[2].legend(fontsize=8); axes[2].grid(True, alpha=0.15)
+    axes[2].plot(rm.index,rm.values,color="purple",lw=1.5)
+    axes[2].axhline(100,color="gray",ls="--",lw=0.8)
+    axes[2].fill_between(rm.index,rm.values,100,where=pos_m.values,
+                          alpha=0.2,color="green",label="Momentum rising")
+    axes[2].fill_between(rm.index,rm.values,100,where=~pos_m.values,
+                          alpha=0.15,color="red",label="Momentum falling")
+    axes[2].set_title("Daily RS-Momentum  (entry = 2 consecutive green bars both panels)",
+                       fontsize=10)
+    axes[2].legend(fontsize=8); axes[2].grid(True,alpha=0.15)
 
     plt.tight_layout()
     st.pyplot(fig)
     plt.close(fig)
 
 
-# ── cached data helpers ───────────────────────────────────────────────────────
+# ── Data fetchers ─────────────────────────────────────────────────────────────
 
 @st.cache_data(ttl=4 * 3600, show_spinner=False)
-def _fetch_benchmark(benchmark_ticker: str) -> pd.Series:
-    raw = yf.download(benchmark_ticker, period="5y", interval="1d", progress=False)
+def _fetch_benchmark(bm_ticker: str) -> pd.Series:
+    raw = yf.download(bm_ticker, period="5y", interval="1d", progress=False)
     if isinstance(raw.columns, pd.MultiIndex):
         raw.columns = raw.columns.get_level_values(0)
     return raw["Close"].dropna().astype(float)
@@ -1514,273 +1616,296 @@ def _fetch_ticker(ticker: str) -> pd.DataFrame:
     return raw.dropna()
 
 
+# ── Full universe scan ────────────────────────────────────────────────────────
+
 @st.cache_data(ttl=12 * 3600, show_spinner=False)
 def run_combined_scan(
-    tickers_tuple: tuple,
+    tickers_tuple:  tuple,
     benchmark_ticker: str,
-    weekly_window: int,
-    daily_window: int,
-    require_weakening: bool,
-    require_bs: bool,
-    rsi_thresh: float,
-    stretch_thresh: float,
+    weekly_window:  int,
+    daily_window:   int,
+    target_quads:   tuple,
+    min_tier:       int,
     require_large_cap: bool,
 ) -> pd.DataFrame:
-    bm = _fetch_benchmark(benchmark_ticker)
+    bm      = _fetch_benchmark(benchmark_ticker)
     results = []
-    batch_size = 10
-    n_batches  = max(1, (len(tickers_tuple) + batch_size - 1) // batch_size)
-    progress   = st.progress(0, text="Scanning…")
+    seen    = {}
+    batch   = 10
+    n_batch = max(1,(len(tickers_tuple)+batch-1)//batch)
+    prog    = st.progress(0, text="Scanning…")
 
-    for b, i in enumerate(range(0, len(tickers_tuple), batch_size)):
-        batch = list(tickers_tuple[i:i + batch_size])
+    for b, i in enumerate(range(0, len(tickers_tuple), batch)):
+        batch_t = list(tickers_tuple[i:i+batch])
         try:
-            data = yf.download(batch, period="5y", interval="1d",
+            data = yf.download(batch_t, period="5y", interval="1d",
                                group_by="ticker", progress=False, threads=True)
         except Exception:
-            progress.progress((b+1)/n_batches)
-            continue
+            prog.progress((b+1)/n_batch); continue
 
-        for ticker in batch:
+        for ticker in batch_t:
             try:
                 raw = data[ticker] if isinstance(data.columns, pd.MultiIndex) else data
                 df  = raw.dropna()
-                r   = analyze_combined(ticker, df, bm, weekly_window, daily_window,
-                                       require_weakening)
+                r   = analyze_combined(ticker, df, bm, weekly_window,
+                                       daily_window, list(target_quads))
                 if r is None or not r["signal_met"]:
                     continue
                 if require_large_cap and not r["large_cap"]:
                     continue
-                if require_bs and (r["rsi"] >= rsi_thresh or r["stretch"] >= stretch_thresh):
+                ti = r["tier_info"]
+                if ti and ti["tier"] > min_tier:
+                    continue
+                # dedup
+                today = pd.Timestamp.now().normalize()
+                last  = seen.get(ticker)
+                if last and (today - last).days < DEDUP_DAYS:
                     continue
+                seen[ticker] = today
+
                 results.append({
-                    "Ticker":        ticker,
-                    "Price":         r["price"],
-                    "20D $vol (M)":  r["dvol_20m"],
-                    "Large Cap":     "✅" if r["large_cap"] else "—",
-                    "RSI":           r["rsi"],
-                    "Stretch %":     r["stretch"],
-                    "Wk Quad":       QUAD_ICONS.get(r["weekly_quad"],"") + " " + r["weekly_quad"],
-                    "Prev Wk Quad":  QUAD_ICONS.get(r["prev_weekly_quad"],"") + " " + r["prev_weekly_quad"],
-                    "W RS-Ratio":    r["w_ratio"],
-                    "W RS-Mom":      r["w_mom"],
-                    "D RS-Ratio":    r["d_ratio"],
-                    "D RS-Mom":      r["d_mom"],
-                    "dx today":      r["dx_today"],
-                    "dy today":      r["dy_today"],
-                    "2d Turn":       "✅" if r["turn_2d"] else "❌",
+                    "Tier":           ti["tier_label"] if ti else "—",
+                    "Est. Win%":      ti["estimated_win"] if ti else "—",
+                    "Ticker":         ticker,
+                    "Price":          r["price"],
+                    "$Vol 20D (M)":   r["dvol_20m"],
+                    "Large Cap":      "✅" if r["large_cap"] else "—",
+                    "RSI":            r["rsi"],
+                    "Stretch %":      r["stretch"],
+                    "% from 52w H":   r["pct_from_52w"],
+                    "Wk Quad":        QUAD_ICONS.get(r["weekly_quad"],"") + " " + r["weekly_quad"],
+                    "Prev Wk Quad":   QUAD_ICONS.get(r["prev_weekly_quad"],"") + " " + r["prev_weekly_quad"],
+                    "W RS-Ratio":     r["w_ratio"],
+                    "W RS-Mom":       r["w_mom"],
+                    "dx today":       r["dx_today"],
+                    "dy today":       r["dy_today"],
+                    "RSI note":       ti["rsi_note"] if ti else "",
+                    "ATH note":       ti["ath_note"] if ti else "",
                 })
             except Exception:
                 continue
 
-        progress.progress((b+1)/n_batches, text=f"Batch {b+1}/{n_batches}…")
+        prog.progress((b+1)/n_batch, text=f"Batch {b+1}/{n_batch}…")
 
-    progress.empty()
-    return pd.DataFrame(results)
+    prog.empty()
+    if not results:
+        return pd.DataFrame()
+
+    df_out = pd.DataFrame(results)
+    # Sort: tier asc, est win% desc
+    df_out["_tier_num"] = df_out["Tier"].map({"🏆 Tier 1":1,"✅ Tier 2":2,"⚠️ Tier 3":3}).fillna(9)
+    df_out = (df_out.sort_values(["_tier_num","Est. Win%"], ascending=[True,False])
+                    .drop(columns=["_tier_num"])
+                    .reset_index(drop=True))
+    return df_out
 
 
-# ── MAIN RENDER FUNCTION ──────────────────────────────────────────────────────
+# ── MAIN RENDER ───────────────────────────────────────────────────────────────
 
 def render_combined_scanner():
-    st.title("🎯 Combined Scanner — RRG + Bottom Scanner")
+    st.title("🎯 Combined Scanner v2 — RRG + Backtest-Calibrated Tiers")
 
-    # ── BACKTEST SUMMARY CALLOUT ─────────────────────────────────────────────
-    with st.expander("📊 Backtest findings (10-year, 2,266 tickers)", expanded=True):
+    # ── Backtest findings callout ─────────────────────────────────────────────
+    with st.expander("📊 Backtest findings — what actually drives the win rate", expanded=False):
         st.markdown("""
-**How this signal was developed:** Gemini backtested the RRG scanner on the XL? sector
-ETFs and found ~75% win rate at 6 months when the weekly RRG was in Weakening/Lagging
-AND the daily RRG showed 2 consecutive days of positive RS-Ratio AND RS-Momentum movement.
-This tab reproduces and extends that finding on 2,266 individual stocks.
-
-| Signal | n trades | 63D win% | 63D mean | xs t-stat | CAGR | Sharpe |
-|--------|----------|----------|----------|-----------|------|--------|
-| EW Buy & Hold | — | — | — | — | **31.8%** | **0.79** |
-| RRG only (Lag/Weak + 2d turn) | 46,528 | 54.5% | +3.1% | −12.1 | 20.3% | 0.65 |
-| Bottom Scanner only | 30,527 | 55.1% | +3.3% | −10.2 | 14.0% | 0.51 |
-| **COMBINED (all-cap)** | 15,617 | 55.1% | +4.0% | **−5.2** | 3.8% | 0.23 |
-| **COMBINED (large-cap ≥$50M $vol)** | 4,841 | **60.5%** | +5.8% | **+0.3 ✓** | 8.1% | 0.37 |
-| **BS + Weakening only (large-cap)** | 228 | **79.6%** | +14.8% | −1.2 | 5.1% | 0.55 |
-
-**How to use this:** The combined signal is best used as a **high-conviction watchlist**,
-not a systematic buy-everything strategy. The large-cap Weakening+BS combo (79.6% win rate)
-is the closest to Gemini's XL-ETF finding — but n=228 over 10 years means only ~20–25 
-trades per year, each with CI [73.9%–84.4%] so treat it as a lean, not a certainty.
-
-**Why it still underperforms B&H in CAGR:** the signal is relatively rare (it selects 
-~10–15% of signals vs B&H which holds everything). Idle capital earns 0% in the simulation.
-The real use is as a *filter on top of an existing watchlist*, not a standalone system.
+**10-year backtest, 3,800 large-cap Weakening + 2d turn entries (2016–2026)**
+
+The blanket "79.6% win rate" figure from v1 required the Bottom Scanner oversold filter
+(RSI<35). Today's scan hits typically have RSI 55-65 — the correct win rate for those
+is **61-65%**, not 79.6%. This version shows the calibrated figure per entry.
+
+| Configuration | Win% | Mean 63D | xs_t | Notes |
+|---|---|---|---|---|
+| RSI <40, any stretch | **75.3%** | +10.2% | — | Strongest RSI bucket |
+| Stretch <-10% | **80%** | +20.1% | — | n=50 only, treat carefully |
+| Stretch -10 to -5% | **71%** | +8.0% | — | Extended below SMA20 |
+| RSI 40-55 + stretch 3-10% | **67.1%** | +8.3% | -2.92 | Strong bucket |
+| RSI 55-65 + stretch >10% | **67.6%** | +11.4% | -1.23 | High momentum |
+| RSI 65-80 + stretch >10% | **67.9%** | +13.1% | **+1.54** | ★★ Only positive xs_t |
+| RSI 55-65 + stretch 3-10% | **64.7%** | +7.7% | **-0.48** | ★ Best alpha quality |
+| Within 5% of 52w high | 57.3% | +2.5% | — | ⚠️ Near-random, avoid |
+| RSI 65-75 + stretch 3-10% | 53.9% | +1.2% | -5.04 | ✗ Weakest bucket |
+
+**52-week high proximity is the biggest single filter:**
+- Within 5% of ATH → 57% win (near-random regardless of RSI/stretch)
+- 10-20% below ATH → 66% win
+- 20-35% below ATH → 69% win ← sweet spot
+
+**Default benchmark changed from SPY → RSP (equal-weight S&P 500).**
+SPY's 35% mega-cap weighting inflates relative strength for non-tech names,
+producing Weakening signals that are actually just "not as good as Nvidia."
+RSP asks the correct question: is this stock beating the average company?
         """)
 
-    # ── SIDEBAR ──────────────────────────────────────────────────────────────
+    # ── Sidebar ───────────────────────────────────────────────────────────────
     with st.sidebar:
         st.markdown("---")
-        st.header("Combined Scanner")
-        benchmark_sym = st.text_input("Benchmark", value="SPY", key="cs_bm").strip().upper()
-        weekly_win = st.slider("Weekly z-score window (weeks)", 8, 26, 13, 1, key="cs_ww")
-        daily_win  = st.slider("Daily z-score window (days)",  21, 126, 63, 1, key="cs_dw")
-        st.markdown("**RRG filters**")
-        require_wk = st.checkbox("Weakening only (stricter, closer to Gemini's 75%)",
-                                  value=False, key="cs_wk")
-        st.markdown("**Bottom Scanner overlay (optional)**")
-        use_bs      = st.checkbox("Require oversold RSI + stretch", value=False, key="cs_bs")
-        rsi_thr     = st.slider("RSI threshold", 20, 50, 35, 1, key="cs_rsi") if use_bs else 35
-        stretch_thr = st.slider("Stretch %", -10.0, 0.0, -4.0, 0.5, key="cs_str") if use_bs else -4.0
-        lc_only     = st.checkbox("Large-cap only (≥$50M 20D $vol)", value=False, key="cs_lc")
-        st.caption(
-            "✅ Large-cap filter strongly recommended: all-cap COMBINED xs t=-5.2 vs "
-            "large-cap xs t=+0.3 (the only marginally positive alpha configuration)"
-        )
-
-    # ── SINGLE TICKER ────────────────────────────────────────────────────────
+        st.header("Combined Scanner v2")
+        benchmark_sym = st.text_input("Benchmark", value="RSP", key="cs2_bm").strip().upper()
+        st.caption("RSP = equal-weight S&P 500 — recommended over SPY (see backtest notes)")
+        weekly_win = st.slider("Weekly z-score window (weeks)", 8, 26, 13, 1, key="cs2_ww")
+        daily_win  = st.slider("Daily z-score window (days)", 21, 126, 63, 1, key="cs2_dw")
+        st.markdown("**Quadrant filter**")
+        weak_only = st.checkbox("Weakening only (excludes Lagging)", value=True, key="cs2_wk")
+        target_quads = ("Weakening",) if weak_only else ("Weakening","Lagging")
+        st.markdown("**Quality filters**")
+        min_tier      = st.radio("Minimum tier", [1, 2, 3],
+                                  format_func=lambda x: {1:"🏆 Tier 1 only (≥67% est.)",
+                                                          2:"✅ Tier 1+2 (≥60%)",
+                                                          3:"⚠️ All tiers"}[x],
+                                  index=1, key="cs2_tier")
+        require_lc    = st.checkbox("Large cap only (≥$50M 20D $vol)", value=True, key="cs2_lc")
+        st.caption("Large-cap filter strongly recommended: all-cap xs_t = -5 vs large-cap xs_t closer to 0")
+
+    # ── Single ticker ─────────────────────────────────────────────────────────
     st.subheader("Analyze a single ticker")
-    col_a, col_b = st.columns([2, 1])
-    single = col_a.text_input("Ticker", value="XLF", key="cs_single").strip().upper()
-    analyze_btn = col_b.button("Analyze", key="cs_analyze")
+    col_a, col_b = st.columns([2,1])
+    single = col_a.text_input("Ticker", value="AAPL", key="cs2_single").strip().upper()
+    go_btn = col_b.button("Analyze", key="cs2_analyze")
 
-    if analyze_btn and single:
+    if go_btn and single:
         with st.spinner(f"Fetching {single} + {benchmark_sym}…"):
-            bm  = _fetch_benchmark(benchmark_sym)
-            df  = _fetch_ticker(single)
+            bm = _fetch_benchmark(benchmark_sym)
+            df = _fetch_ticker(single)
 
-        r = analyze_combined(single, df, bm, weekly_win, daily_win, require_wk)
+        r = analyze_combined(single, df, bm, weekly_win, daily_win, list(target_quads))
 
         if r is None:
-            st.error("Not enough data (need 5y of daily bars).")
+            st.error("Not enough data (need ≥5y daily bars for 52w high calculation).")
         else:
-            # metric cards
-            c1, c2, c3, c4, c5, c6 = st.columns(6)
-            c1.metric("Price", f"${r['price']}")
-            c2.metric("Quality", "✅" if r["quality_ok"] else "❌ Fail")
-            c3.metric("Large Cap", "✅" if r["large_cap"] else "—")
-            c4.metric("Weekly Quad",
-                      QUAD_ICONS.get(r["weekly_quad"],"") + " " + r["weekly_quad"])
-            c5.metric("2-day Turn", "✅ YES" if r["turn_2d"] else "❌ NO",
+            ti = r.get("tier_info")
+
+            # Metric row
+            c1,c2,c3,c4,c5,c6 = st.columns(6)
+            c1.metric("Price",        f"${r['price']}")
+            c2.metric("RSI",          f"{r['rsi']}")
+            c3.metric("Stretch",      f"{r['stretch']:.1f}%")
+            c4.metric("vs 52w High",  f"{r['pct_from_52w']:.1f}%")
+            c5.metric("Weekly Quad",  QUAD_ICONS.get(r["weekly_quad"],"") + " " + r["weekly_quad"])
+            c6.metric("2-day Turn",   "✅ YES" if r["turn_2d"] else "❌ NO",
                       delta=f"dx={r['dx_today']:+.2f} dy={r['dy_today']:+.2f}")
-            c6.metric("Signal", "🎯 ACTIVE" if r["signal_met"] else "⬜ inactive")
-
-            if r["signal_met"]:
-                wq = r["weekly_quad"]
-                # Show the relevant backtest win rate
-                if r["large_cap"] and wq == "Weakening":
-                    wr_note = "**79.6% historical 63D win rate** (large-cap + Weakening, n=228, CI 73.9–84.4%) — closest to Gemini's 75% XL-ETF finding."
-                elif r["large_cap"]:
-                    wr_note = "**60.5% historical 63D win rate** (large-cap COMBINED, n=4,841, CI 59.1–61.9%)."
+
+            if not r["quality_ok"]:
+                st.warning(f"⚠️ Quality gate failed — price ${r['price']} or liquidity "
+                           f"(${r['dvol_20m']:.1f}M 20D $vol < ${MIN_DVOL/1e6:.0f}M min)")
+
+            if r["signal_met"] and ti:
+                col = {"🏆 Tier 1":"success","✅ Tier 2":"info","⚠️ Tier 3":"warning"}.get(ti["tier_label"],"info")
+                msg = (f"{ti['tier_label']}  |  **Estimated {ti['estimated_win']:.1f}% win rate**\n\n"
+                       f"RSI: {ti['rsi_note']}\n\n"
+                       f"ATH: {ti['ath_note']}")
+                if col == "success":
+                    st.success(msg)
+                elif col == "warning":
+                    st.warning(msg)
                 else:
-                    wr_note = "**55.1% historical 63D win rate** (all-cap COMBINED, n=15,617, CI 54.3–55.9%)."
-                st.success(f"🎯 Signal active — {wq} quadrant with 2-day daily turn. {wr_note}")
-            else:
+                    st.info(msg)
+            elif not r["rrg_entry"]:
                 reasons = []
-                if not r["quality_ok"]:       reasons.append("quality gate (price/liquidity)")
-                if r["weekly_quad"] not in (["Weakening"] if require_wk else ["Lagging","Weakening"]):
-                    reasons.append(f"weekly quadrant is {r['weekly_quad']} (need {'Weakening' if require_wk else 'Lagging or Weakening'})")
-                if not r["turn_2d"]:          reasons.append("no 2-day daily turn yet")
-                st.info("Signal not active: " + " | ".join(reasons) if reasons else "Conditions not met.")
+                if r["weekly_quad"] not in list(target_quads):
+                    reasons.append(f"weekly quad is {r['weekly_quad']} (need {'/'.join(target_quads)})")
+                if not r["turn_2d"]:
+                    reasons.append("no 2-day positive daily turn")
+                st.info("Signal not active: " + " | ".join(reasons))
+            elif not r["quality_ok"]:
+                st.warning("Signal fires but quality gate failed — treat with caution.")
 
-            # RSI / stretch context
-            st.caption(f"RSI {r['rsi']} | SMA20 stretch {r['stretch']}% | "
-                       f"20D $vol ${r['dvol_20m']:.1f}M")
-
-            # mini RRG chart
             st.plotly_chart(mini_rrg_chart(r, single), use_container_width=True)
-
-            # detail chart
             with st.expander("📈 Detailed price + daily RRG panels"):
                 detail_chart(r, single)
 
-    # ── FULL SCAN ────────────────────────────────────────────────────────────
+    # ── Full scan ─────────────────────────────────────────────────────────────
     st.markdown("---")
     st.subheader("Full universe scan")
 
     universe = get_clean_premarket_universe()
 
+    quad_str = " or ".join(target_quads)
+    tier_str = {1:"Tier 1 only",2:"Tier 1+2",3:"All tiers"}.get(min_tier,"")
+    lc_str   = "large-cap " if require_lc else ""
     st.caption(
-        f"Universe: {len(universe)} tickers. Each ticker fetches 5y of daily data — "
-        "this scan takes 5–10 minutes on first run, then cached 12 hours. "
-        "The large-cap filter (sidebar) cuts runtime ~75% and gives the best signal quality."
+        f"Universe: {len(universe)} tickers | Benchmark: {benchmark_sym} | "
+        f"Quadrant: {quad_str} | Filter: {lc_str}{tier_str} | Cached 12h"
     )
 
-    if st.button("🔍 Run Combined Scan", key="cs_scan"):
+    if st.button("🔍 Run Scan", key="cs2_scan"):
         if not universe:
             st.error("No tickers loaded.")
         else:
-            results_df = run_combined_scan(
+            df_r = run_combined_scan(
                 tuple(universe), benchmark_sym, weekly_win, daily_win,
-                require_wk, use_bs, rsi_thr, stretch_thr, lc_only,
+                target_quads, min_tier, require_lc,
             )
-            st.session_state["cs_results"] = results_df
+            st.session_state["cs2_results"] = df_r
 
-    if "cs_results" in st.session_state:
-        df = st.session_state["cs_results"]
-        if df.empty:
-            st.info("No tickers cleared all filters. Try relaxing the settings.")
+    if "cs2_results" in st.session_state:
+        df_r = st.session_state["cs2_results"]
+        if df_r.empty:
+            st.info("No tickers cleared all filters. Try relaxing Tier or large-cap settings.")
         else:
-            st.success(f"{len(df)} ticker(s) met all conditions.")
-
-            # tag with expected win rate
-            def expected_wr(row):
-                lc = row.get("Large Cap") == "✅"
-                wk = "Weakening" in str(row.get("Wk Quad",""))
-                if lc and wk:
-                    return "~79.6% (LC+Weak)"
-                elif lc:
-                    return "~60.5% (LC+Combo)"
-                else:
-                    return "~55.1% (All-cap)"
-            df["Expected Win%"] = df.apply(expected_wr, axis=1)
+            st.success(f"{len(df_r)} ticker(s) — sorted by Tier then Est. Win%")
+
+            # Highlight tier 1 rows
+            def row_style(row):
+                if "Tier 1" in str(row.get("Tier","")):
+                    return ["background-color: #d4edda"] * len(row)
+                elif "Tier 3" in str(row.get("Tier","")):
+                    return ["background-color: #f8d7da"] * len(row)
+                return [""] * len(row)
+
+            display_cols = ["Tier","Est. Win%","Ticker","Price","RSI","Stretch %",
+                            "% from 52w H","Wk Quad","Prev Wk Quad","Large Cap",
+                            "$Vol 20D (M)","RSI note","ATH note"]
+            display_cols = [c for c in display_cols if c in df_r.columns]
 
             st.dataframe(
-                df.sort_values("20D $vol (M)", ascending=False).reset_index(drop=True),
+                df_r[display_cols].style.apply(row_style, axis=1),
                 use_container_width=True, hide_index=True,
             )
 
-            # chart picker
-            pick = st.selectbox("View RRG chart for:", df["Ticker"].tolist(), key="cs_pick")
+            pick = st.selectbox("View chart for:", df_r["Ticker"].tolist(), key="cs2_pick")
             if pick:
                 with st.spinner(f"Fetching {pick}…"):
                     bm  = _fetch_benchmark(benchmark_sym)
                     dfp = _fetch_ticker(pick)
-                rp = analyze_combined(pick, dfp, bm, weekly_win, daily_win, require_wk)
+                rp = analyze_combined(pick, dfp, bm, weekly_win, daily_win, list(target_quads))
                 if rp:
+                    ti = rp.get("tier_info")
+                    if ti:
+                        st.info(f"{ti['tier_label']}  •  Est. {ti['estimated_win']:.1f}% win\n\n"
+                                f"{ti['rsi_note']}\n\n{ti['ath_note']}")
                     st.plotly_chart(mini_rrg_chart(rp, pick), use_container_width=True)
                     with st.expander("📈 Detailed panels"):
                         detail_chart(rp, pick)
 
-    # ── HOW TO USE THIS WITH THE ROTATION MAP ────────────────────────────────
+    # ── Workflow guide ────────────────────────────────────────────────────────
     st.markdown("---")
-    with st.expander("💡 How to use Combined Scanner with the Rotation Map tab"):
-        st.markdown("""
-**Workflow (the 'watchlist funnel' approach):**
-
-1. **Rotation Map tab** → set your sector ETF basket → note which ETFs sit in **Weakening** 
-   with their tail starting to curl toward Improving. These are the *sectors* with 
-   potential rotation setups.
-
-2. **Bottom Scanner tab** → run a scan of the holdings within those sectors. Hits 
-   give you a shortlist of oversold individual names inside a potentially-turning sector.
-
-3. **Combined Scanner tab** → paste those tickers into single-ticker mode here and 
-   check the dual-TF RRG. You're looking for:
-   - Weekly: **Weakening** (strong but losing steam) or **Lagging** (weak but starting to turn)
-   - Daily: **2 consecutive days with positive dx AND dy** (the early rotation signal)
-
-4. **Check the Rotation Map's own trail for those stocks** (add them to the custom ticker 
-   list in Rotation Map) — does the tail show the same early curl from Weakening → Improving?
-
-**Why this combination matters:**
-- Bottom Scanner alone: xs t-stat ≈ −10 (signal underperforms peers)
-- RRG alone:            xs t-stat ≈ −12 (worse — very broad signal)
-- Combined large-cap:   xs t-stat ≈ **+0.3** (the only config with marginal positive alpha)
-- The intersection removes most of the "falling knives" the BS alone catches
-- Adding the large-cap / Weakening filter brings win rates to 60–79%, matching 
-  Gemini's XL-ETF observation on individual stocks too
-
-**Honest caveat:** even at 79.6% (large-cap Weakening+BS, n=228 over 10 years), 
-the 95% CI is [73.9%–84.4%]. The equity-curve CAGR (5.1%) still underperforms 
-the equal-weight benchmark (31.8%) because active holding periods are sparse. 
-Use as a filter, not a standalone system.
+    with st.expander("💡 How to read the tiers + DCA workflow"):
+        st.markdown(f"""
+**Tier 1 🏆** — Est. win rate ≥67%. Best historical outcomes within the signal.
+Look for RSI<40, deep negative stretch, or RSI 65-80 with stretch >10%. Position is
+10-35% below its 52-week high. These are the clearest mean-reversion setups.
+
+**Tier 2 ✅** — Est. win rate 60-66%. Solid signal, majority of scan hits will be here.
+RSI 55-65 + stretch 3-10% is the sweet spot for alpha quality (xs_t closest to 0).
+The six positions in the live test portfolio are Tier 2 entries.
+
+**Tier 3 ⚠️** — Est. win rate <61%, near-random. RSI 65-75 with moderate stretch, or
+within 5% of the 52-week high. The scanner flags these so you can see them but they
+carry no statistically meaningful edge over just buying the benchmark.
+
+**DCA workflow:**
+1. Watchlist conviction first (macro thesis, fundamentals)
+2. Combined Scanner fires → Tranche 1 (⅓ position) if Tier 1 or 2
+3. If signal re-fires within 63 days → Tranche 2 (lowers average cost)
+4. Peak Detector >50% risk → hold / re-evaluate exit
+5. RRG rolls out of Weakening/Leading back to Lagging → consider exit
+
+**Stop losses: the backtest says don't.** 91% of entries (including winners) touch -5%
+intraperiod. Mean intraperiod drawdown is -14.3% even for winning trades.
+The edge is mean-reversion — cutting at -5% destroys it.
         """)
 
-
 # =========================================================
 # MAIN LAYOUT
 # =========================================================