Update src/streamlit_app.py

src/streamlit_app.py

@@ -12,7 +12,7 @@ import matplotlib.pyplot as plt
 import plotly.graph_objects as go
 import plotly.express as px
 from numpy.lib.stride_tricks import sliding_window_view
-from scipy.stats import spearmanr
+from scipy.stats import spearmanr, binom as binom_dist
 from sklearn.ensemble import GradientBoostingClassifier
 from huggingface_hub import HfApi, hf_hub_download
 
@@ -144,8 +144,6 @@ def get_clean_premarket_universe():
 
 @st.cache_data(ttl=3600, show_spinner="Fetching prior-close reference prices...")
 def get_daily_reference_data(tickers_tuple):
-    """Bulk-fetch recent daily bars for previous close + average volume context.
-    Batched at 10 tickers per request — anything larger triggered rate limiting."""
     ref = {}
     batch_size = 10
     total_batches = max(1, (len(tickers_tuple) + batch_size - 1) // batch_size)
@@ -193,7 +191,6 @@ def get_daily_reference_data(tickers_tuple):
 @st.cache_data(ttl=300, show_spinner=False)
 def run_premarket_scan(tickers_tuple, min_gap_pct, direction):
     ref_data = get_daily_reference_data(tickers_tuple)
-
     results = []
     batch_size = 10
     total_batches = max(1, (len(tickers_tuple) + batch_size - 1) // batch_size)
@@ -217,37 +214,30 @@ def run_premarket_scan(tickers_tuple, min_gap_pct, direction):
                 df = raw.dropna(subset=["Close"])
                 if df.empty:
                     continue
-
                 if df.index.tz is not None:
                     df = df.copy()
                     df.index = df.index.tz_convert("America/New_York")
                 else:
                     df = df.copy()
                     df.index = df.index.tz_localize("America/New_York")
-
                 premarket = df[df.index.time < dt_time(9, 30)]
                 if premarket.empty:
                     continue
-
                 ref = ref_data.get(ticker)
                 if not ref or not ref.get("prev_close"):
                     continue
                 prev_close = ref["prev_close"]
-
                 last_price = float(premarket["Close"].iloc[-1])
                 if not prev_close:
                     continue
                 gap_pct = (last_price - prev_close) / prev_close * 100
-
                 if abs(gap_pct) < min_gap_pct:
                     continue
                 if direction == "Up only" and gap_pct <= 0:
                     continue
                 if direction == "Down only" and gap_pct >= 0:
                     continue
-
                 pm_volume = int(premarket["Volume"].sum())
-
                 results.append({
                     "Ticker": ticker,
                     "Prev Close": round(prev_close, 2),
@@ -272,18 +262,14 @@ def render_premarket_scan():
         "close as the signal."
     )
     st.info(
-        "📊 Why price, not volume: checking the data you collected, premarket Volume came back as "
-        "exactly 0 for every ticker, every premarket minute, across all 1,078 names tested. Yahoo's "
-        "free feed updates the price tick during extended hours but doesn't populate real trade "
-        "volume — a data source limit, not a settings problem. So this scan uses premarket price "
-        "gap (which Yahoo does report reliably) instead. Premarket volume is still shown when "
-        "available, just not filtered on."
+        "📊 Why price, not volume: Yahoo's free feed updates the price tick during extended hours "
+        "but doesn't populate real trade volume. This scan uses premarket price gap instead. "
+        "Premarket volume is still shown when available, just not filtered on."
     )
     st.warning(
-        "⚠️ A premarket gap is not a reliable 'buy/short the open' signal by itself — it's exactly the "
-        "setup behind the classic 'gap and fade,' where moves on thin early liquidity often reverse "
-        "once the regular session's full liquidity arrives. Treat a hit here as 'worth checking the "
-        "news on,' not a standalone trade signal."
+        "⚠️ A premarket gap is not a reliable 'buy/short the open' signal by itself — it's exactly "
+        "the setup behind the classic 'gap and fade.' Treat a hit here as 'worth checking the news "
+        "on,' not a standalone trade signal."
     )
 
     with st.sidebar:
@@ -292,15 +278,11 @@ def render_premarket_scan():
         direction = st.radio("Direction", ["Both", "Up only", "Down only"], key="pm_direction")
 
     universe = get_clean_premarket_universe()
-    st.caption(
-        f"Universe: {len(universe)} tickers from your curated list (Trebor1009/clean-premarket-data). "
-        f"Pulled in batches of 10 to stay under Yahoo's rate limit — a run over this many tickers will "
-        f"still take a few minutes."
-    )
+    st.caption(f"Universe: {len(universe)} tickers from Trebor1009/clean-premarket-data.")
 
     if st.button("🔍 Run Premarket Scan", key="pm_scan_btn"):
         if not universe:
-            st.error("No tickers loaded from the curated list — check the dataset is reachable.")
+            st.error("No tickers loaded — check the dataset is reachable.")
         else:
             results_df = run_premarket_scan(tuple(universe), min_gap_pct, direction)
             st.session_state["pm_results"] = results_df
@@ -310,32 +292,22 @@ def render_premarket_scan():
         if results_df.empty:
             st.info("No tickers cleared the gap threshold. Try lowering the minimum %.")
         else:
-            EXTREME_GAP_CUTOFF = 50  # likely a stock split / data artifact, not a real move
+            EXTREME_GAP_CUTOFF = 50
             extreme = results_df[results_df["Gap %"].abs() >= EXTREME_GAP_CUTOFF].copy()
-            normal = results_df[results_df["Gap %"].abs() < EXTREME_GAP_CUTOFF].copy()
-
+            normal  = results_df[results_df["Gap %"].abs() < EXTREME_GAP_CUTOFF].copy()
             sorted_df = normal.reindex(
                 normal["Gap %"].abs().sort_values(ascending=False).index
             ).reset_index(drop=True)
             gainers = sorted_df[sorted_df["Gap %"] > 0].reset_index(drop=True)
-            losers = sorted_df[sorted_df["Gap %"] < 0].reset_index(drop=True)
-
-            st.success(
-                f"{len(sorted_df)} ticker(s) past the gap threshold — "
-                f"{len(gainers)} up, {len(losers)} down."
-            )
+            losers  = sorted_df[sorted_df["Gap %"] < 0].reset_index(drop=True)
+            st.success(f"{len(sorted_df)} ticker(s) past the gap threshold — {len(gainers)} up, {len(losers)} down.")
             st.markdown("### Premarket Gainers")
             st.dataframe(gainers, use_container_width=True, hide_index=True)
             st.markdown("### Premarket Losers")
             st.dataframe(losers, use_container_width=True, hide_index=True)
-
             if not extreme.empty:
                 st.markdown("### ⚠️ Extreme moves — verify before trusting")
-                st.caption(
-                    f"Gaps of {EXTREME_GAP_CUTOFF}%+ are almost always a stock split or other corporate "
-                    f"action causing the prior-close and live-price data to be on different share bases, "
-                    f"not a real overnight move. Check the ticker before reading any meaning into these."
-                )
+                st.caption(f"Gaps of {EXTREME_GAP_CUTOFF}%+ are almost always a stock split or data artefact.")
                 st.dataframe(extreme.reset_index(drop=True), use_container_width=True, hide_index=True)
 
 
@@ -380,22 +352,22 @@ def render_whale_single_ticker():
         return
 
     median_vol = df[df["Volume"] > 0]["Volume"].median()
-    mean_vol = df[df["Volume"] > 0]["Volume"].mean()
+    mean_vol   = df[df["Volume"] > 0]["Volume"].mean()
 
     df["Price_Change"] = df["Close"].diff()
-    df["Pct_Change"] = df["Close"].pct_change() * 100
-    df["Vol_Ratio"] = df["Volume"] / median_vol
-    df["is_notable"] = df["Volume"] > (median_vol * multiplier) if not show_all else True
+    df["Pct_Change"]   = df["Close"].pct_change() * 100
+    df["Vol_Ratio"]    = df["Volume"] / median_vol
+    df["is_notable"]   = df["Volume"] > (median_vol * multiplier) if not show_all else True
 
     df[["Delta", "Sentiment"]] = df.apply(lambda r: pd.Series(get_sentiment(r)), axis=1)
     df["Cum_Delta"] = df["Delta"].cumsum()
-    df["Size"] = df["Volume"].apply(lambda v: classify_size(v, median_vol))
+    df["Size"]      = df["Volume"].apply(lambda v: classify_size(v, median_vol))
 
     st.subheader(f"{symbol} — Session: {last_session.date()}")
     c1, c2, c3, c4 = st.columns(4)
     c1.metric("Median 1-min Volume", f"{median_vol:,.0f}")
-    c2.metric("Mean 1-min Volume", f"{mean_vol:,.0f}")
-    c3.metric("Flag Threshold", f"{median_vol * multiplier:,.0f}")
+    c2.metric("Mean 1-min Volume",   f"{mean_vol:,.0f}")
+    c3.metric("Flag Threshold",      f"{median_vol * multiplier:,.0f}")
     c4.metric(
         "Last Price",
         f"${df['Close'].iloc[-1]:.2f}",
@@ -414,8 +386,7 @@ def render_whale_single_ticker():
             table.style.format(
                 {"Volume": "{:,.0f}", "Vol_Ratio": "{:.1f}x", "Close": "${:.2f}", "Pct_Change": "{:+.2f}%"}
             ),
-            use_container_width=True,
-            height=400,
+            use_container_width=True, height=400,
         )
 
     st.markdown("### Cumulative Buy/Sell Delta")
@@ -423,14 +394,13 @@ def render_whale_single_ticker():
     chart_df.index = chart_df.index.strftime("%H:%M")
     st.line_chart(chart_df)
 
-    total_buy = df[df["Delta"] > 0]["Delta"].sum()
+    total_buy  = df[df["Delta"] > 0]["Delta"].sum()
     total_sell = abs(df[df["Delta"] < 0]["Delta"].sum())
-    net = total_buy - total_sell
-
-    whale_buys = df[(df["Size"] == "WHALE") & (df["Sentiment"] == "BUY")]["Volume"].sum()
+    net        = total_buy - total_sell
+    whale_buys  = df[(df["Size"] == "WHALE") & (df["Sentiment"] == "BUY")]["Volume"].sum()
     whale_sells = df[(df["Size"] == "WHALE") & (df["Sentiment"] == "SELL")]["Volume"].sum()
-    inst_buys = df[(df["Size"].isin(["INSTITUTIONAL", "WHALE"])) & (df["Sentiment"] == "BUY")]["Volume"].sum()
-    inst_sells = df[(df["Size"].isin(["INSTITUTIONAL", "WHALE"])) & (df["Sentiment"] == "SELL")]["Volume"].sum()
+    inst_buys   = df[(df["Size"].isin(["INSTITUTIONAL", "WHALE"])) & (df["Sentiment"] == "BUY")]["Volume"].sum()
+    inst_sells  = df[(df["Size"].isin(["INSTITUTIONAL", "WHALE"])) & (df["Sentiment"] == "SELL")]["Volume"].sum()
 
     st.markdown("### Session Analysis")
     colA, colB, colC = st.columns(3)
@@ -458,9 +428,9 @@ def render_whale_single_ticker():
     rows = []
     total_vol = df["Volume"].sum()
     for size in ["WHALE", "INSTITUTIONAL", "LARGE", "MEDIUM", "RETAIL"]:
-        vol = df[df["Size"] == size]["Volume"].sum()
+        vol   = df[df["Size"] == size]["Volume"].sum()
         count = len(df[df["Size"] == size])
-        pct = (vol / total_vol * 100) if total_vol > 0 else 0
+        pct   = (vol / total_vol * 100) if total_vol > 0 else 0
         rows.append({"Size": size, "Volume": vol, "% of Total": round(pct, 1), "Candles": count})
     st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
 
@@ -504,8 +474,8 @@ def label_peaks(df: pd.DataFrame, target_drop: float, window: int) -> pd.DataFra
 def add_peak_features(df: pd.DataFrame, vol_sensitivity: float) -> pd.DataFrame:
     d = df.copy()
     delta = d["Close"].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(14).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+    gain  = (delta.where(delta > 0, 0)).rolling(14).mean()
+    loss  = (-delta.where(delta < 0, 0)).rolling(14).mean()
     d["RSI"] = 100 - (100 / (1 + (gain / (loss + 1e-9))))
     d["Div_Warning"] = ((d["High"] >= d["High"].shift(1)) & (d["RSI"] < d["RSI"].shift(1))).astype(int)
     d["Vol_Rel"] = d["Volume"] / d["Volume"].rolling(20).mean()
@@ -549,10 +519,10 @@ def render_peak_detector():
     with st.sidebar:
         st.markdown("---")
         st.header("Peak Detector Settings")
-        pd_ticker = st.selectbox("Ticker", DEFAULT_PEAK_TICKERS, index=0, key="pd_ticker")
-        pd_custom = st.text_input("...or enter a custom ticker", value="", key="pd_custom")
-        target_drop = st.slider("Drop % that counts as a peak", 0.03, 0.15, 0.06, 0.01, key="pd_drop")
-        window = st.slider("Forward warning window (days)", 3, 15, 5, 1, key="pd_window")
+        pd_ticker  = st.selectbox("Ticker", DEFAULT_PEAK_TICKERS, index=0, key="pd_ticker")
+        pd_custom  = st.text_input("...or enter a custom ticker", value="", key="pd_custom")
+        target_drop   = st.slider("Drop % that counts as a peak", 0.03, 0.15, 0.06, 0.01, key="pd_drop")
+        window        = st.slider("Forward warning window (days)", 3, 15, 5, 1, key="pd_window")
         vol_sensitivity = st.slider("Volume sensitivity", 0.5, 3.0, 1.0, 0.1, key="pd_vol")
         if st.button("🔄 Retrain model", key="pd_refresh"):
             run_peak_model.clear()
@@ -569,27 +539,23 @@ def render_peak_detector():
 
     st.subheader(f"{ticker}")
     c1, c2, c3 = st.columns(3)
-    c1.metric("Status", status)
-    c2.metric("Risk %", f"{latest['Risk_Pct']:.1f}%")
-    c3.metric("RSI", f"{latest['RSI']:.1f}")
+    c1.metric("Status",  status)
+    c2.metric("Risk %",  f"{latest['Risk_Pct']:.1f}%")
+    c3.metric("RSI",     f"{latest['RSI']:.1f}")
 
     plot_df = data.iloc[-240:].copy()
-    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True, gridspec_kw={"height_ratios": [2.5, 1]})
-
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True,
+                                    gridspec_kw={"height_ratios": [2.5, 1]})
     ax1.plot(plot_df["Date"], plot_df["Close"], color="black", linewidth=1)
     ax1.fill_between(plot_df["Date"], plot_df["Close"], plot_df["RSI_Blowoff_Band"], color="red", alpha=0.1)
-
     risk_days = plot_df[plot_df["Risk_Pct"] > 50]
     ax1.scatter(risk_days["Date"], risk_days["High"] * 1.02, color="red", marker="D", s=50)
     for _, row in risk_days.iterrows():
         ax1.text(row["Date"], row["High"] * 1.03, "!", color="red", fontweight="bold", ha="center")
-
     ax1.set_title(f"{ticker} | Price vs Risk Heatmap")
-
     ax2.fill_between(plot_df["Date"], 0, plot_df["Risk_Pct"], color="purple", alpha=0.4)
     ax2.axhline(50, color="red", linestyle="--", alpha=0.3)
     ax2.set_ylabel("Drop Risk %")
-
     plt.tight_layout()
     st.pyplot(fig)
     plt.close(fig)
@@ -601,43 +567,38 @@ def render_peak_detector():
 
 
 # =========================================================
-# TAB 3: SNIPER SCANNER (historical analog / triple-positive setup scanner)
+# TAB 3: BOTTOM SCANNER
 # =========================================================
 
 def sniper_rsi(series, period=14):
     delta = series.diff()
-    gain = (delta.where(delta > 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
-    loss = (-delta.where(delta < 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
-    rs = gain / (loss + 1e-9)
+    gain  = (delta.where(delta > 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
+    loss  = (-delta.where(delta < 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
+    rs    = gain / (loss + 1e-9)
     return 100 - (100 / (1 + rs))
 
 
 def get_strict_stats(df, rsi, sma, current_stretch, rsi_threshold, strict_window,
                       forward_1d=1, forward_5d=5, forward_3m=63):
-    close = df["Close"].values
+    close    = df["Close"].values
     stretches = ((close - sma.values) / sma.values) * 100
-
-    ret_1d = (pd.Series(close).shift(-forward_1d).values - close) / close
-    ret_5d = (pd.Series(close).shift(-forward_5d).values - close) / close
-    ret_3m = (pd.Series(close).shift(-forward_3m).values - close) / close
-
+    ret_1d   = (pd.Series(close).shift(-forward_1d).values - close) / close
+    ret_5d   = (pd.Series(close).shift(-forward_5d).values - close) / close
+    ret_3m   = (pd.Series(close).shift(-forward_3m).values - close) / close
     mask_stretch_lower = stretches >= current_stretch - strict_window
     mask_stretch_upper = stretches <= current_stretch + strict_window
     mask_rsi_threshold = (rsi < rsi_threshold).values
-
-    mask = mask_stretch_lower & mask_stretch_upper & mask_rsi_threshold
+    mask       = mask_stretch_lower & mask_stretch_upper & mask_rsi_threshold
     valid_mask = mask & (~np.isnan(ret_3m))
     match_indices = np.where(valid_mask)[0]
-
     if len(match_indices) < 10:
         return None
-
     return {
-        "count": len(match_indices),
-        "avg_1d": np.mean(ret_1d[valid_mask]) * 100,
-        "avg_5d": np.mean(ret_5d[valid_mask]) * 100,
-        "avg_3m": np.mean(ret_3m[valid_mask]) * 100,
-        "win_3m": (ret_3m[valid_mask] > 0).mean() * 100,
+        "count":       len(match_indices),
+        "avg_1d":      np.mean(ret_1d[valid_mask]) * 100,
+        "avg_5d":      np.mean(ret_5d[valid_mask]) * 100,
+        "avg_3m":      np.mean(ret_3m[valid_mask]) * 100,
+        "win_3m":      (ret_3m[valid_mask] > 0).mean() * 100,
         "match_dates": df.index[match_indices],
         "match_prices": close[match_indices],
     }
@@ -647,46 +608,35 @@ def analyze_ticker(df, rsi_threshold, stretch_threshold, strict_window, lookback
     df = df.dropna()
     if len(df) < 200:
         return None
-
-    close = df["Close"].astype(float)
-    rsi = sniper_rsi(close)
-    sma20 = close.rolling(20).mean()
-
+    close   = df["Close"].astype(float)
+    rsi     = sniper_rsi(close)
+    sma20   = close.rolling(20).mean()
     current_stretch = ((close.iloc[-1] - sma20.iloc[-1]) / sma20.iloc[-1]) * 100
-
     result = {
-        "rsi": rsi.iloc[-1],
-        "stretch": current_stretch,
-        "price": close.iloc[-1],
-        "stats": None,
-        "fractal_target": None,
-        "df": df,
-        "rsi_series": rsi,
-        "signal_met": False,
+        "rsi": rsi.iloc[-1], "stretch": current_stretch, "price": close.iloc[-1],
+        "stats": None, "fractal_target": None, "df": df,
+        "rsi_series": rsi, "signal_met": False,
     }
-
     try:
         hist = np.squeeze(close.values[:-90])
         if hist.ndim == 1 and len(hist) > lookback:
-            curr = close.values[-lookback:]
+            curr   = close.values[-lookback:]
             curr_n = (curr - np.mean(curr)) / (np.std(curr) + 1e-9)
-            wins = sliding_window_view(hist, lookback)
+            wins   = sliding_window_view(hist, lookback)
             wins_n = (wins - np.mean(wins, axis=1, keepdims=True)) / (np.std(wins, axis=1, keepdims=True) + 1e-9)
-            corrs = np.dot(wins_n, curr_n) / lookback
+            corrs  = np.dot(wins_n, curr_n) / lookback
             top_idx = np.argmax(corrs)
             result["fractal_target"] = close.values[-1] * (
                 close.values[top_idx + lookback] / close.values[top_idx + lookback - 1]
             )
     except Exception:
         pass
-
     if result["rsi"] < rsi_threshold and current_stretch < stretch_threshold:
         stats = get_strict_stats(df, rsi, sma20, current_stretch, rsi_threshold, strict_window)
         result["stats"] = stats
         if stats:
             is_triple_positive = stats["avg_1d"] > 0 and stats["avg_5d"] > 0 and stats["avg_3m"] > 0
             result["signal_met"] = is_triple_positive and stats["win_3m"] >= win_rate_min
-
     return result
 
 
@@ -699,46 +649,23 @@ def get_sniper_ticker_data(ticker: str) -> pd.DataFrame:
     return df.dropna()
 
 
-@st.cache_data(ttl=24 * 3600, show_spinner="Fetching ticker universe...")
-def get_universe_tickers(include_russell: bool, extra_tickers: tuple):
-    tickers = set()
-    try:
-        sp500 = pd.read_csv(
-            "https://raw.githubusercontent.com/datasets/s-and-p-500-companies/master/data/constituents.csv"
-        )["Symbol"].tolist()
-        tickers.update(t.replace(".", "-") for t in sp500)
-    except Exception as e:
-        st.warning(f"Could not fetch S&P 500 list: {e}")
-
-    if include_russell:
-        try:
-            russell = pd.read_csv(
-                "https://raw.githubusercontent.com/ikoniaris/Russell2000/master/russell_2000_components.csv"
-            )["Ticker"].tolist()
-            tickers.update(t.replace(".", "-") for t in russell)
-        except Exception as e:
-            st.warning(f"Could not fetch Russell 2000 list: {e}")
-
-    tickers.update(extra_tickers)
-    return sorted(tickers)
-
-
 @st.cache_data(ttl=12 * 3600, show_spinner=False)
 def run_full_scan(universe_label, extra_tickers_tuple, rsi_threshold, stretch_threshold,
                    strict_window, lookback, win_rate_min, _tickers):
-    results = []
+    results    = []
     batch_size = 10
     total_batches = max(1, (len(_tickers) + batch_size - 1) // batch_size)
-    progress = st.progress(0, text="Starting scan...")
+    progress   = st.progress(0, text="Starting scan...")
 
     for b, i in enumerate(range(0, len(_tickers), batch_size)):
         batch = _tickers[i:i + batch_size]
         try:
-            data = yf.download(batch, period="max", interval="1d", group_by="ticker", progress=False, threads=True)
+            data = yf.download(batch, period="max", interval="1d", group_by="ticker",
+                                progress=False, threads=True)
         except Exception:
-            progress.progress((b + 1) / total_batches, text=f"Batch {b + 1}/{total_batches} failed, continuing...")
+            progress.progress((b + 1) / total_batches,
+                               text=f"Batch {b + 1}/{total_batches} failed, continuing...")
             continue
-
         for ticker in batch:
             try:
                 try:
@@ -748,23 +675,23 @@ def run_full_scan(universe_label, extra_tickers_tuple, rsi_threshold, stretch_th
                 df = raw.dropna()
                 if len(df) < 200:
                     continue
-                result = analyze_ticker(df, rsi_threshold, stretch_threshold, strict_window, lookback, win_rate_min)
+                result = analyze_ticker(df, rsi_threshold, stretch_threshold,
+                                        strict_window, lookback, win_rate_min)
                 if result and result["signal_met"]:
                     stats = result["stats"]
                     results.append({
-                        "Ticker": ticker,
-                        "Price": round(result["price"], 2),
-                        "RSI": round(result["rsi"], 1),
-                        "Stretch %": round(result["stretch"], 2),
-                        "Matches": stats["count"],
-                        "Avg_1D": round(stats["avg_1d"], 2),
-                        "Avg_5D": round(stats["avg_5d"], 2),
-                        "Avg_3M": round(stats["avg_3m"], 2),
+                        "Ticker":     ticker,
+                        "Price":      round(result["price"], 2),
+                        "RSI":        round(result["rsi"], 1),
+                        "Stretch %":  round(result["stretch"], 2),
+                        "Matches":    stats["count"],
+                        "Avg_1D":     round(stats["avg_1d"], 2),
+                        "Avg_5D":     round(stats["avg_5d"], 2),
+                        "Avg_3M":     round(stats["avg_3m"], 2),
                         "WinRate_3M": round(stats["win_3m"], 1),
                     })
             except Exception:
                 continue
-
         progress.progress((b + 1) / total_batches, text=f"Scanned batch {b + 1}/{total_batches}...")
 
     progress.empty()
@@ -772,56 +699,50 @@ def run_full_scan(universe_label, extra_tickers_tuple, rsi_threshold, stretch_th
 
 
 def render_sniper_dashboard(ticker, result):
-    df = result["df"]
+    df         = result["df"]
     rsi_series = result["rsi_series"]
-    stats = result["stats"]
-    target = result["fractal_target"]
+    stats      = result["stats"]
+    target     = result["fractal_target"]
 
     fig = plt.figure(figsize=(12, 8))
-    gs = fig.add_gridspec(2, 2)
-
+    gs  = fig.add_gridspec(2, 2)
     ax1 = fig.add_subplot(gs[0, :])
     ax1.plot(df.index, df["Close"], color="gray", alpha=0.3, label="History")
     recent = df.tail(120)
     ax1.plot(recent.index, recent["Close"], color="black", linewidth=1.5, label="Current Trend")
-
     if stats:
-        ax1.scatter(stats["match_dates"], stats["match_prices"], color="limegreen", s=20, zorder=5,
-                     label="Strict Matches")
+        ax1.scatter(stats["match_dates"], stats["match_prices"],
+                    color="limegreen", s=20, zorder=5, label="Strict Matches")
     if target is not None:
-        ax1.axhline(target, color="blue", ls="--", alpha=0.6, label="Single best-match analog (not a target)")
-
+        ax1.axhline(target, color="blue", ls="--", alpha=0.6,
+                    label="Single best-match analog (not a target)")
     ax1.set_title(f"{ticker}", fontsize=16, fontweight="bold")
     ax1.legend(loc="upper left", fontsize=9)
     ax1.grid(True, alpha=0.1)
-
     if stats:
         stats_text = (
-            f"Historical Matches: {stats['count']}\n"
-            f"Avg Change 1D:  {stats['avg_1d']:+.2f}%\n"
-            f"Avg Change 5D:  {stats['avg_5d']:+.2f}%\n"
-            f"Avg Change 3M:  {stats['avg_3m']:+.2f}%\n"
+            f"Historical Matches: {stats['count']}\\n"
+            f"Avg Change 1D:  {stats['avg_1d']:+.2f}%\\n"
+            f"Avg Change 5D:  {stats['avg_5d']:+.2f}%\\n"
+            f"Avg Change 3M:  {stats['avg_3m']:+.2f}%\\n"
             f"3M Win Rate: {stats['win_3m']:.1f}% (n={stats['count']})"
         )
         ax1.text(0.98, 0.05, stats_text, transform=ax1.transAxes, va="bottom", ha="right",
                   bbox=dict(boxstyle="round", facecolor="white", alpha=0.9, edgecolor="darkgreen"),
                   fontsize=10, family="monospace")
-
     ax2 = fig.add_subplot(gs[1, 0])
     ax2.plot(recent.index, rsi_series.tail(120), color="purple")
     ax2.axhline(result["rsi"], color="orange", ls=":")
     ax2.set_title(f"RSI: {result['rsi']:.1f}")
-
     ax3 = fig.add_subplot(gs[1, 1])
     if stats:
         horizons = ["1D", "5D", "3M"]
-        values = [stats["avg_1d"], stats["avg_5d"], stats["avg_3m"]]
+        values   = [stats["avg_1d"], stats["avg_5d"], stats["avg_3m"]]
         ax3.bar(horizons, values, color="limegreen", alpha=0.8)
         ax3.axhline(0, color="black", linewidth=0.8)
         ax3.set_title("Historical Edge by Horizon")
     else:
         ax3.set_title("No matches to show")
-
     plt.tight_layout()
     st.pyplot(fig)
     plt.close(fig)
@@ -832,12 +753,10 @@ def render_quick_forecast(ticker: str):
     if raw.empty:
         st.error(f"No data for '{ticker}'.")
         return
-
-    anchor_date = raw.index[-1]
-    context = raw[raw.index >= (anchor_date - pd.Timedelta(days=90))]
+    anchor_date   = raw.index[-1]
+    context       = raw[raw.index >= (anchor_date - pd.Timedelta(days=90))]
     current_price = raw["Close"].iloc[-1]
-
-    projection = compute_analog_projection(ticker, str(anchor_date.date()))
+    projection    = compute_analog_projection(ticker, str(anchor_date.date()))
 
     fig, ax = plt.subplots(figsize=(12, 5))
     if not context.empty:
@@ -845,7 +764,6 @@ def render_quick_forecast(ticker: str):
                  marker="o", markersize=2, label="Price")
     ax.axvline(anchor_date, color="red", ls="-", alpha=0.4, label="Today")
     ax.axhline(current_price, color="gray", ls=":", alpha=0.6, label="Current price")
-
     if projection:
         ax.plot(projection["future_dates"], projection["weighted_mean"],
                  color="green", ls="--", linewidth=2, label="Analog-weighted projection")
@@ -854,12 +772,10 @@ def render_quick_forecast(ticker: str):
         st.caption(
             f"Projection built from the {projection['match_count']} most similar non-overlapping "
             f"60-day windows in {ticker}'s own history (robust similarity: "
-            f"{projection['robust_similarity']:.1f}%). Same caveat as the Signal Tracker chart — "
-            f"a handful of historical echoes, not independent confirming evidence."
+            f"{projection['robust_similarity']:.1f}%)."
         )
     else:
         st.info("Not enough history for this ticker to build a projection.")
-
     ax.set_title(f"{ticker} — forecast as of {anchor_date.date()}")
     ax.legend(loc="best", fontsize=9)
     ax.grid(True, alpha=0.1)
@@ -875,25 +791,23 @@ def render_sniper_tab():
         "forward returns and win rate."
     )
     st.warning(
-        "⚠️ Two things worth keeping in mind:\n\n"
+        "⚠️ Two things worth keeping in mind:\\n\\n"
         "1. **Small samples** — many qualifying setups have only 10-30 historical matches. An '80% win rate' "
-        "on 10 matches (8 wins) has a much wider true range than the headline number suggests — treat it as "
-        "a lean, not a precise probability.\n\n"
-        "2. **Full-universe scans test thousands of tickers at once.** With that many independent tests, some "
-        "will clear an 80%+ historical win-rate bar by chance alone, with no real edge behind it. A hit showing "
-        "up in a scan is a reason to look closer, not a standalone signal.\n\n"
-        "The dashed blue line ('best-match analog') is one single closest-matching historical window, shown "
-        "for context — not a statistical price target."
+        "on 10 matches has a much wider true range than the headline number suggests.\\n\\n"
+        "2. **Full-universe scans test thousands of tickers at once.** With that many tests, some will "
+        "clear an 80%+ bar by chance alone. A hit is a reason to look closer, not a standalone signal.\\n\\n"
+        "The dashed blue line ('best-match analog') is one single closest-matching historical window, "
+        "shown for context — not a statistical price target."
     )
 
     with st.sidebar:
         st.markdown("---")
         st.header("Bottom Scanner Settings")
-        rsi_threshold = st.slider("RSI threshold (oversold below this)", 20, 60, 45, 1, key="sn_rsi")
+        rsi_threshold    = st.slider("RSI threshold (oversold below this)", 20, 60, 45, 1, key="sn_rsi")
         stretch_threshold = st.slider("Max SMA20 stretch %", -8.0, 0.0, -2.0, 0.5, key="sn_stretch")
-        strict_window = st.slider("Match strictness (± stretch %)", 0.1, 2.0, 0.5, 0.1, key="sn_window")
-        lookback = st.slider("Fractal lookback (days)", 20, 120, 60, 5, key="sn_lookback")
-        win_rate_min = st.slider("Min 3M win rate to flag (%)", 50, 95, 80, 5, key="sn_winrate")
+        strict_window    = st.slider("Match strictness (± stretch %)", 0.1, 2.0, 0.5, 0.1, key="sn_window")
+        lookback         = st.slider("Fractal lookback (days)", 20, 120, 60, 5, key="sn_lookback")
+        win_rate_min     = st.slider("Min 3M win rate to flag (%)", 50, 95, 80, 5, key="sn_winrate")
 
     settings = {
         "rsi_threshold": rsi_threshold, "stretch_threshold": stretch_threshold,
@@ -901,9 +815,9 @@ def render_sniper_tab():
     }
 
     st.subheader("Analyze a single ticker")
-    single_ticker = st.text_input("Ticker", value="BTC-USD", key="sn_single").strip().upper()
+    single_ticker   = st.text_input("Ticker", value="BTC-USD", key="sn_single").strip().upper()
     col_analyze, col_forecast = st.columns([1, 1])
-    analyze_clicked = col_analyze.button("Analyze", key="sn_analyze_btn")
+    analyze_clicked  = col_analyze.button("Analyze",  key="sn_analyze_btn")
     forecast_clicked = col_forecast.button("Forecast", key="sn_forecast_btn")
 
     if analyze_clicked and single_ticker:
@@ -911,7 +825,8 @@ def render_sniper_tab():
         if raw.empty:
             st.error(f"No data for '{single_ticker}'.")
         else:
-            result = analyze_ticker(raw, rsi_threshold, stretch_threshold, strict_window, lookback, win_rate_min)
+            result = analyze_ticker(raw, rsi_threshold, stretch_threshold,
+                                    strict_window, lookback, win_rate_min)
             if result is None:
                 st.error("Not enough history for this ticker.")
             else:
@@ -919,13 +834,11 @@ def render_sniper_tab():
                 if not entry_met:
                     st.info(
                         f"RSI {result['rsi']:.1f} / Stretch {result['stretch']:.2f}% — entry conditions "
-                        f"(RSI < {rsi_threshold}, stretch < {stretch_threshold}%) not currently met. "
-                        "Showing current state for reference."
+                        f"(RSI < {rsi_threshold}, stretch < {stretch_threshold}%) not currently met."
                     )
                 elif result["stats"] is None:
                     st.info(
-                        f"Entry conditions met (RSI {result['rsi']:.1f}, stretch {result['stretch']:.2f}%) "
-                        "but fewer than 10 historical analogs found — not enough data to score."
+                        f"Entry conditions met but fewer than 10 historical analogs found."
                     )
                 elif result["signal_met"]:
                     st.success(
@@ -936,7 +849,8 @@ def render_sniper_tab():
                         hit_row = pd.DataFrame([{
                             "Ticker": single_ticker, "Price": round(result["price"], 2),
                             "RSI": round(result["rsi"], 1), "Stretch %": round(result["stretch"], 2),
-                            "Matches": result["stats"]["count"], "Avg_1D": round(result["stats"]["avg_1d"], 2),
+                            "Matches": result["stats"]["count"],
+                            "Avg_1D": round(result["stats"]["avg_1d"], 2),
                             "Avg_5D": round(result["stats"]["avg_5d"], 2),
                             "Avg_3M": round(result["stats"]["avg_3m"], 2),
                             "WinRate_3M": round(result["stats"]["win_3m"], 1),
@@ -956,15 +870,14 @@ def render_sniper_tab():
     st.markdown("---")
     st.subheader("Full universe scan")
     st.caption(
-        "Will scan your curated ticker list (Trebor1009/clean-premarket-data — the same list the "
-        "Premarket Scan uses) for setups meeting the full criteria. First run can take several "
-        "minutes — results are cached for 12 hours after that.\n\n"
-        f"{'✅ Hits will be auto-saved to your signal log.' if _log_configured() else '⚠️ Signal log storage not configured — hits will NOT be saved. See the Signal Tracker tab.'}"
+        "Scans your curated ticker list for setups meeting the full criteria. "
+        "First run can take several minutes — results are cached for 12 hours.\\n\\n"
+        f"{'✅ Hits will be auto-saved to your signal log.' if _log_configured() else '⚠️ Signal log storage not configured — hits will NOT be saved.'}"
     )
     if st.button("🔍 Run Full Universe Scan", key="sn_scan_btn"):
         tickers = get_clean_premarket_universe()
         if not tickers:
-            st.error("No tickers loaded from the curated list — check the dataset is reachable.")
+            st.error("No tickers loaded from the curated list.")
         else:
             st.write(f"Scanning {len(tickers)} tickers...")
             results_df = run_full_scan(
@@ -972,7 +885,6 @@ def render_sniper_tab():
                 strict_window, lookback, win_rate_min, tuple(tickers),
             )
             st.session_state["sn_results"] = results_df
-
             if not results_df.empty and _log_configured():
                 if append_hits_to_log(results_df, settings):
                     st.success(f"Logged {len(results_df)} hit(s) to the signal tracker.")
@@ -985,39 +897,37 @@ def render_sniper_tab():
             st.success(f"{len(results_df)} ticker(s) met the criteria.")
             sorted_df = results_df.sort_values("WinRate_3M", ascending=False).reset_index(drop=True)
             st.dataframe(sorted_df, use_container_width=True, hide_index=True)
-
             pick = st.selectbox("View chart for:", sorted_df["Ticker"].tolist(), key="sn_pick")
             if pick:
                 raw = get_sniper_ticker_data(pick)
                 if not raw.empty:
-                    result = analyze_ticker(raw, rsi_threshold, stretch_threshold, strict_window, lookback,
-                                             win_rate_min)
+                    result = analyze_ticker(raw, rsi_threshold, stretch_threshold,
+                                            strict_window, lookback, win_rate_min)
                     if result:
                         render_sniper_dashboard(pick, result)
 
 
 # =========================================================
-# ANALOG PATH PROJECTION (used by the Signal Tracker chart)
+# ANALOG PATH PROJECTION
 # =========================================================
 
-ANALOG_LOOKBACK = 60
-ANALOG_FORWARD = 60
-ANALOG_TOP_N = 5
+ANALOG_LOOKBACK      = 60
+ANALOG_FORWARD       = 60
+ANALOG_TOP_N         = 5
 ANALOG_WEIGHT_STRENGTH = 5
 
 
 def _similarity_matches(close, end_idx, lookback, forward):
     if end_idx - lookback < 0:
         return []
-    recent = close.iloc[end_idx - lookback:end_idx]
+    recent      = close.iloc[end_idx - lookback:end_idx]
     recent_norm = (recent / recent.iloc[0]).values.flatten()
-
-    matches = []
-    max_search = end_idx - lookback - forward
+    matches     = []
+    max_search  = end_idx - lookback - forward
     for i in range(max_search):
-        cand = close.iloc[i:i + lookback]
+        cand      = close.iloc[i:i + lookback]
         cand_norm = (cand / cand.iloc[0]).values.flatten()
-        corr = spearmanr(recent_norm, cand_norm)[0]
+        corr      = spearmanr(recent_norm, cand_norm)[0]
         if not np.isnan(corr):
             matches.append((float(corr), i))
     return matches
@@ -1030,18 +940,15 @@ def compute_analog_projection(ticker: str, flag_date_str: str, lookback=ANALOG_L
     hist = get_sniper_ticker_data(ticker)
     if hist.empty:
         return None
-    close = hist["Close"]
+    close     = hist["Close"]
     flag_date = pd.Timestamp(flag_date_str)
-    end_idx = int(close.index.searchsorted(flag_date))
-    end_idx = min(end_idx, len(close) - 1)
-
+    end_idx   = int(close.index.searchsorted(flag_date))
+    end_idx   = min(end_idx, len(close) - 1)
     if end_idx - lookback - forward < 5:
-        return None  # not enough pre-flag history for this method
-
+        return None
     matches = _similarity_matches(close, end_idx, lookback, forward)
     if not matches:
         return None
-
     matches.sort(key=lambda x: x[0], reverse=True)
     filtered, used = [], []
     for corr, idx in matches:
@@ -1052,37 +959,32 @@ def compute_analog_projection(ticker: str, flag_date_str: str, lookback=ANALOG_L
             break
     if not filtered:
         return None
-
-    corrs = np.array([c for c, _ in filtered])
+    corrs   = np.array([c for c, _ in filtered])
     weights = np.exp(weight_strength * corrs)
     weights /= weights.sum()
-
     anchor_price = close.iloc[end_idx]
-    projections = []
+    projections  = []
     for corr, idx in filtered:
-        fwd = close.iloc[idx + lookback: idx + lookback + forward]
+        fwd      = close.iloc[idx + lookback: idx + lookback + forward]
         fwd_norm = (fwd / fwd.iloc[0]).values.flatten()
         projections.append(fwd_norm * anchor_price)
-    projections = np.vstack(projections)
-
+    projections   = np.vstack(projections)
     weighted_mean = np.average(projections, axis=0, weights=weights)
-    weighted_var = np.average((projections - weighted_mean) ** 2, axis=0, weights=weights)
-    weighted_std = np.sqrt(weighted_var)
-
-    future_dates = pd.bdate_range(start=close.index[end_idx], periods=forward + 1)[1:]
-
+    weighted_var  = np.average((projections - weighted_mean) ** 2, axis=0, weights=weights)
+    weighted_std  = np.sqrt(weighted_var)
+    future_dates  = pd.bdate_range(start=close.index[end_idx], periods=forward + 1)[1:]
     return {
-        "future_dates": future_dates,
-        "weighted_mean": weighted_mean,
-        "upper": weighted_mean + weighted_std,
-        "lower": weighted_mean - weighted_std,
+        "future_dates":      future_dates,
+        "weighted_mean":     weighted_mean,
+        "upper":             weighted_mean + weighted_std,
+        "lower":             weighted_mean - weighted_std,
         "robust_similarity": float(np.sqrt(np.sum(weights * corrs ** 2)) * 100),
-        "match_count": len(filtered),
+        "match_count":       len(filtered),
     }
 
 
 # =========================================================
-# TAB 4: SIGNAL TRACKER (predicted vs. actual, out-of-sample)
+# TAB 4: SIGNAL TRACKER
 # =========================================================
 
 def render_signal_tracker():
@@ -1095,49 +997,43 @@ def render_signal_tracker():
     if not _log_configured():
         st.error(
             "Signal log storage isn't configured. In this Space's Settings, add a Secret named "
-            "`HF_TOKEN` (your Hugging Face write token) and a Variable named `HF_DATASET_REPO` "
-            "(e.g. `your-username/sniper-signal-log`), then restart the Space."
+            "`HF_TOKEN` and a Variable named `HF_DATASET_REPO`, then restart the Space."
         )
         return
 
     log = load_signal_log()
     if log.empty:
-        st.info(
-            "No signals logged yet. Run a Full Universe Scan on the Bottom Scanner tab — qualifying "
-            "hits are saved here automatically."
-        )
+        st.info("No signals logged yet. Run a Full Universe Scan on the Bottom Scanner tab.")
         return
 
-    log["FlagDate"] = pd.to_datetime(log["FlagDate"])
+    log["FlagDate"]      = pd.to_datetime(log["FlagDate"])
     log["DaysSinceFlag"] = (pd.Timestamp.now().normalize() - log["FlagDate"]).dt.days
 
     st.markdown(f"### {len(log)} signals logged across {log['Ticker'].nunique()} tickers")
 
     summary_rows = []
     for _, row in log.iterrows():
-        ticker = row["Ticker"]
-        flag_price = row.get("Price", np.nan)
-        days_elapsed = int(row["DaysSinceFlag"])
+        ticker        = row["Ticker"]
+        flag_price    = row.get("Price", np.nan)
+        days_elapsed  = int(row["DaysSinceFlag"])
         actual_return = np.nan
         try:
             hist = get_sniper_ticker_data(ticker)
             if not hist.empty and pd.notna(flag_price) and flag_price > 0:
-                current_price = hist["Close"].iloc[-1]
-                actual_return = (current_price - flag_price) / flag_price * 100
+                actual_return = (hist["Close"].iloc[-1] - flag_price) / flag_price * 100
         except Exception:
             pass
-
         status = "Complete (90D+)" if days_elapsed >= 90 else f"In progress ({days_elapsed}d/90d)"
         summary_rows.append({
-            "Ticker": ticker,
-            "Flag Date": row["FlagDate"].date(),
-            "Days Elapsed": days_elapsed,
-            "Status": status,
-            "Matches": row.get("Matches", None),
-            "Predicted Avg 3M %": row.get("Avg_3M", np.nan),
-            "Predicted Win Rate %": row.get("WinRate_3M", np.nan),
+            "Ticker":                  ticker,
+            "Flag Date":               row["FlagDate"].date(),
+            "Days Elapsed":            days_elapsed,
+            "Status":                  status,
+            "Matches":                 row.get("Matches", None),
+            "Predicted Avg 3M %":      row.get("Avg_3M", np.nan),
+            "Predicted Win Rate %":    row.get("WinRate_3M", np.nan),
             "Actual Return % (to date)": round(actual_return, 2) if pd.notna(actual_return) else None,
-            "On Track": (actual_return > 0) if pd.notna(actual_return) else None,
+            "On Track":                (actual_return > 0) if pd.notna(actual_return) else None,
         })
 
     summary_df = pd.DataFrame(summary_rows).sort_values("Flag Date", ascending=False)
@@ -1148,36 +1044,33 @@ def render_signal_tracker():
         hit_rate = (completed["On Track"] == True).mean() * 100
         st.metric("Realized hit rate on completed 90-day signals", f"{hit_rate:.0f}% (n={len(completed)})")
     else:
-        st.caption("No signals have reached the full 90-day mark yet — hit rate will appear once some do.")
+        st.caption("No signals have reached the 90-day mark yet.")
 
     st.download_button(
         "⬇️ Download full signal log (CSV)",
         data=log.to_csv(index=False).encode("utf-8"),
-        file_name="signal_log.csv",
-        mime="text/csv",
+        file_name="signal_log.csv", mime="text/csv",
     )
 
     st.markdown("---")
     st.subheader("Chart a specific signal")
     options = [f"{r['Ticker']} — flagged {r['Flag Date']}" for _, r in summary_df.iterrows()]
-    pick = st.selectbox("Pick a logged signal", options, key="st_pick")
+    pick    = st.selectbox("Pick a logged signal", options, key="st_pick")
     if pick:
         ticker, flag_date_str = pick.split(" — flagged ")
         match = log[(log["Ticker"] == ticker) & (log["FlagDate"].dt.date.astype(str) == flag_date_str)]
         if not match.empty:
-            row = match.iloc[0]
-            hist = get_sniper_ticker_data(ticker)
+            row       = match.iloc[0]
+            hist      = get_sniper_ticker_data(ticker)
             if not hist.empty:
                 flag_date = row["FlagDate"]
-                context = hist[hist.index >= (flag_date - pd.Timedelta(days=45))]
+                context   = hist[hist.index >= (flag_date - pd.Timedelta(days=45))]
                 on_or_after = context[context.index >= flag_date]
-                flag_price = row.get("Price", np.nan)
+                flag_price  = row.get("Price", np.nan)
                 if pd.isna(flag_price):
-                    if not on_or_after.empty:
-                        flag_price = on_or_after["Close"].iloc[0]
-                    elif not context.empty:
-                        flag_price = context["Close"].iloc[-1]
-
+                    flag_price = on_or_after["Close"].iloc[0] if not on_or_after.empty else (
+                        context["Close"].iloc[-1] if not context.empty else np.nan
+                    )
                 fig, ax = plt.subplots(figsize=(12, 5))
                 if not context.empty:
                     ax.plot(context.index, context["Close"], color="black", linewidth=1.5,
@@ -1185,7 +1078,6 @@ def render_signal_tracker():
                 ax.axvline(flag_date, color="red", ls="-", alpha=0.4, label="Flagged here")
                 if pd.notna(flag_price):
                     ax.axhline(flag_price, color="gray", ls=":", alpha=0.6, label="Price at flag")
-
                 projection = compute_analog_projection(ticker, str(flag_date.date()))
                 if projection:
                     ax.plot(projection["future_dates"], projection["weighted_mean"],
@@ -1194,12 +1086,9 @@ def render_signal_tracker():
                                      color="green", alpha=0.15, label="Projection band (1σ)")
                     st.caption(
                         f"Projection built from the {projection['match_count']} most similar non-overlapping "
-                        f"60-day windows in {ticker}'s own history, as known on the flag date "
-                        f"(robust similarity: {projection['robust_similarity']:.1f}%). Read this as 'what "
-                        f"comparable past setups did,' not a calibrated forecast — a handful of historical "
-                        f"echoes, not independent confirming evidence."
+                        f"60-day windows in {ticker}'s own history "
+                        f"(robust similarity: {projection['robust_similarity']:.1f}%)."
                     )
-
                 ax.set_title(f"{ticker} — flagged {flag_date.date()}")
                 ax.legend(loc="best", fontsize=9)
                 ax.grid(True, alpha=0.1)
@@ -1208,15 +1097,15 @@ def render_signal_tracker():
 
 
 # =========================================================
-# TAB 5: ROTATION MAP (relative strength / momentum vs benchmark)
+# TAB 5: ROTATION MAP
 # =========================================================
 
-DEFAULT_ROTATION_TICKERS = ["XLK", "XLB", "XLF", "XLE", "XLV", "XLI", "XLU", "XLP", "XLRE", "XLY" , "XLC"]
+DEFAULT_ROTATION_TICKERS = ["XLK", "XLB", "XLF", "XLE", "XLV", "XLI", "XLU", "XLP", "XLRE", "XLY", "XLC"]
 
 
 @st.cache_data(ttl=4 * 3600, show_spinner="Building rotation map...")
 def compute_rotation_data(tickers_tuple, benchmark, lookback_years, window):
-    symbols = list(tickers_tuple) + [benchmark]
+    symbols    = list(tickers_tuple) + [benchmark]
     start_date = (pd.Timestamp.now() - pd.DateOffset(years=lookback_years)).strftime("%Y-%m-%d")
     try:
         data = yf.download(symbols, start=start_date, progress=False)["Close"]
@@ -1224,43 +1113,33 @@ def compute_rotation_data(tickers_tuple, benchmark, lookback_years, window):
         return None, list(tickers_tuple)
     if isinstance(data, pd.Series):
         data = data.to_frame()
-
-    weekly = data.resample("W-FRI").last()
-
+    weekly  = data.resample("W-FRI").last()
     missing = [t for t in tickers_tuple if t not in weekly.columns or weekly[t].dropna().empty]
     valid_tickers = [t for t in tickers_tuple if t not in missing]
-
     if benchmark not in weekly.columns or weekly[benchmark].dropna().empty or not valid_tickers:
         return None, missing
-
-    rs_df = weekly[valid_tickers].div(weekly[benchmark], axis=0)
-    rs_ratio = 100 + ((rs_df - rs_df.rolling(window).mean()) / rs_df.rolling(window).std()) * 5
-    rs_momentum = 100 + ((rs_ratio - rs_ratio.rolling(window).mean()) / rs_ratio.rolling(window).std()) * 5
-
-    rs_ratio = rs_ratio.dropna()
-    rs_momentum = rs_momentum.dropna()
-
+    rs_df        = weekly[valid_tickers].div(weekly[benchmark], axis=0)
+    rs_ratio     = 100 + ((rs_df - rs_df.rolling(window).mean()) / rs_df.rolling(window).std()) * 5
+    rs_momentum  = 100 + ((rs_ratio - rs_ratio.rolling(window).mean()) / rs_ratio.rolling(window).std()) * 5
+    rs_ratio     = rs_ratio.dropna()
+    rs_momentum  = rs_momentum.dropna()
     return {"rs_ratio": rs_ratio, "rs_momentum": rs_momentum, "valid_tickers": valid_tickers}, missing
 
 
 def render_rotation_map():
-    st.title("\U0001F9ED Rotation Map")
+    st.title("🧭 Rotation Map")
     st.caption(
         "Plots relative strength and momentum versus a benchmark for a basket of tickers, showing "
         "which quadrant each one currently sits in and how it's been moving over recent weeks."
     )
     st.info(
-        "\U0001F4D0 How to read it: this is RELATIVE positioning vs the benchmark, not absolute "
-        "performance — a ticker can sit in 'Leading' while still being down in absolute terms, just "
-        "falling less than the benchmark. Quadrants: Leading (strong + improving), Weakening (strong "
-        "but losing steam), Lagging (weak + still losing ground), Improving (weak but starting to turn)."
+        "📐 How to read it: this is RELATIVE positioning vs the benchmark, not absolute "
+        "performance. Quadrants: Leading (strong + improving), Weakening (strong but losing steam), "
+        "Lagging (weak + still losing ground), Improving (weak but starting to turn)."
     )
     st.warning(
-        "⚠️ One honest note on the math: 'momentum' here is a z-score of the relative-strength ratio "
-        "itself, not a true rate-of-change — it measures how unusual the current ratio is versus its "
-        "own recent history, which behaves similarly but isn't textbook RRG momentum. Also worth "
-        "knowing: small/thinly-traded names will naturally show noisier, more dramatic-looking loops "
-        "than large liquid sector ETFs simply because their relative-strength ratio is more volatile — "
+        "⚠️ 'Momentum' here is a z-score of the relative-strength ratio itself, not a true "
+        "rate-of-change. Small/thinly-traded names show noisier loops than large liquid ETFs — "
         "a big swing on a small-cap isn't necessarily more meaningful than a small swing on XLK."
     )
 
@@ -1269,14 +1148,13 @@ def render_rotation_map():
         st.header("Rotation Map Settings")
         tickers_input = st.text_area(
             "Tickers (comma-separated)",
-            value=", ".join(DEFAULT_ROTATION_TICKERS),
-            key="rm_tickers",
+            value=", ".join(DEFAULT_ROTATION_TICKERS), key="rm_tickers",
         )
-        benchmark = st.text_input("Benchmark", value="RSP", key="rm_benchmark").strip().upper()
-        trail_weeks = st.slider("Trail length (weeks)", 2, 12, 6, 1, key="rm_trail")
+        benchmark     = st.text_input("Benchmark", value="RSP", key="rm_benchmark").strip().upper()
+        trail_weeks   = st.slider("Trail length (weeks)", 2, 12, 6, 1, key="rm_trail")
         lookback_years = st.slider("History to fetch (years)", 1, 5, 2, 1, key="rm_lookback")
-        window = st.slider("Z-score window (weeks)", 8, 52, 21, 1, key="rm_window")
-        if st.button("\U0001F504 Refresh data", key="rm_refresh"):
+        window        = st.slider("Z-score window (weeks)", 8, 52, 21, 1, key="rm_window")
+        if st.button("🔄 Refresh data", key="rm_refresh"):
             compute_rotation_data.clear()
 
     tickers = tuple(t.strip().upper() for t in tickers_input.split(",") if t.strip())
@@ -1291,18 +1169,17 @@ def render_rotation_map():
         st.error("Not enough data to build the rotation map. Check the benchmark and ticker symbols.")
         return
 
-    rs_ratio = result["rs_ratio"]
-    rs_momentum = result["rs_momentum"]
+    rs_ratio      = result["rs_ratio"]
+    rs_momentum   = result["rs_momentum"]
     valid_tickers = result["valid_tickers"]
-
-    tail_ratio = rs_ratio.tail(trail_weeks)
-    tail_mom = rs_momentum.tail(trail_weeks)
+    tail_ratio    = rs_ratio.tail(trail_weeks)
+    tail_mom      = rs_momentum.tail(trail_weeks)
 
     if tail_ratio.empty:
         st.error("Not enough history after the rolling window — try a shorter window or longer lookback.")
         return
 
-    fig = go.Figure()
+    fig    = go.Figure()
     colors = px.colors.qualitative.Dark24
 
     for i, ticker in enumerate(valid_tickers):
@@ -1310,15 +1187,14 @@ def render_rotation_map():
             continue
         x_data = tail_ratio[ticker].dropna().tolist()
         y_data = tail_mom[ticker].dropna().tolist() if ticker in tail_mom.columns else []
-        n = min(len(x_data), len(y_data))
+        n      = min(len(x_data), len(y_data))
         if n == 0:
             continue
         x_data, y_data = x_data[-n:], y_data[-n:]
         color = colors[i % len(colors)]
         fig.add_trace(go.Scatter(
             x=x_data, y=y_data, mode="lines+markers+text", name=ticker,
-            text=[""] * (n - 1) + [ticker],
-            textposition="top center",
+            text=[""] * (n - 1) + [ticker], textposition="top center",
             textfont=dict(size=12, color=color),
             marker=dict(size=[6] * (n - 1) + [16], color=color, symbol="circle"),
             line=dict(width=2, color=color, shape="spline"),
@@ -1326,44 +1202,47 @@ def render_rotation_map():
 
     fig.add_hline(y=100, line_dash="dash", line_color="gray", opacity=0.5)
     fig.add_vline(x=100, line_dash="dash", line_color="gray", opacity=0.5)
-
-    quadrants = [
-        (105, 105, "LEADING", "green"),
-        (105, 95, "WEAKENING", "orange"),
-        (95, 95, "LAGGING", "red"),
-        (95, 105, "IMPROVING", "blue"),
-    ]
-    for x, y, text, color in quadrants:
-        fig.add_annotation(
-            x=x, y=y, text=text, showarrow=False,
-            font=dict(size=20, color=color), xref="x", yref="y", opacity=0.15,
-        )
+    for x, y, text, color in [(105,105,"LEADING","green"),(105,95,"WEAKENING","orange"),
+                               (95,95,"LAGGING","red"),(95,105,"IMPROVING","blue")]:
+        fig.add_annotation(x=x, y=y, text=text, showarrow=False,
+                           font=dict(size=20, color=color), xref="x", yref="y", opacity=0.15)
 
     fig.update_layout(
-        title=f"Momentum & Rotation Map vs {benchmark} (Last {trail_weeks} Weeks)",
+        title=f"Rotation Map vs {benchmark} (Last {trail_weeks} Weeks)",
         xaxis_title="Relative Strength (RS-Ratio)",
         yaxis_title="Momentum (RS-Momentum)",
-        height=700,
-        template="plotly_white",
-        hovermode="closest",
-        showlegend=False,
+        height=700, template="plotly_white", hovermode="closest", showlegend=False,
     )
-
     st.plotly_chart(fig, use_container_width=True)
     st.caption(
         "Tip: a Bottom Scanner hit sitting deep in Lagging with its tail starting to curl toward "
-        "Improving is a nice visual echo of the same 'oversold, maybe turning' idea the scanner tests "
-        "for numerically — worth treating as two tools corroborating each other, not independent proof."
+        "Improving is worth cross-referencing with the Combined Scanner (Tab 6) to check whether "
+        "the daily RRG turn has started yet."
     )
 
+"""
+
+# Append the combined scanner functions (Tab 6)
+app += "\n\n# =========================================================\n"
+app += "# TAB 6: COMBINED SCANNER (RRG + Bottom Scanner)\n"
+app += "# =========================================================\n\n"
+app += cs_body
+
+# Append the main layout with 6 tabs
+app += """
 
 # =========================================================
 # MAIN LAYOUT
 # =========================================================
 
-tab1, tab2, tab3, tab4, tab5 = st.tabs(
-    ["🐋 Whale Monitor", "📈 Peak Detector", "📉 Bottom Scanner", "🗒️ Signal Tracker", "🧭 Rotation Map"]
-)
+tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
+    "🐋 Whale Monitor",
+    "📈 Peak Detector",
+    "📉 Bottom Scanner",
+    "🗒️ Signal Tracker",
+    "🧭 Rotation Map",
+    "🎯 Combined Scanner",
+])
 
 with tab1:
     render_whale_monitor()
@@ -1378,4 +1257,7 @@ with tab4:
     render_signal_tracker()
 
 with tab5:
-    render_rotation_map()
+    render_rotation_map()
+
+with tab6:
+    render_combined_scanner()