CI deploy 9dc88d4e

app.py

@@ -88,6 +88,9 @@ def default_state() -> dict:
         "needs_signals": False,
         "log_scale": False, "cvd": False,
         "metric": "OOS Sharpe", "topn": 15,
+        "filters": {"assets": [], "timeframes": [], "strategies": [],
+                    "models": [], "min_trades": 0,
+                    "require_oos": True, "hide_baselines": False},
         "sig_asset": "BTC-USD", "sig_tf": "1d",
         "tab": "compare",   # "compare" | "backtest"
         "user": None,
@@ -181,6 +184,11 @@ def apply_action(st: dict, raw: str) -> tuple[dict, bool]:
             st["topn"] = max(5, min(50, int(v)))
         except ValueError:
             pass
+    elif k == "filter":
+        st = _apply_filter(st, v)
+    elif k == "reset":
+        st["filters"] = default_state()["filters"]
+        st["metric"], st["topn"] = "OOS Sharpe", 15
     elif k == "sigasset" and v in config.ASSETS:
         st["sig_asset"] = v
     elif k == "sigtf" and v in config.TIMEFRAMES:
@@ -197,6 +205,42 @@ def apply_action(st: dict, raw: str) -> tuple[dict, bool]:
     return refresh_context(st), False
 
 
+# Which filter kinds are multi-select lists, and what each is validated against.
+_FILTER_LISTS = {
+    "asset": ("assets", lambda: set(config.ASSETS)),
+    "tf": ("timeframes", lambda: set(config.TIMEFRAMES)),
+    "strategy": ("strategies", lambda: set(catalog.CATALOG_STRATEGIES)),
+    "model": ("models", lambda: set(config.SEED_MODELS)),
+}
+
+
+def _apply_filter(st: dict, value: str) -> dict:
+    """Fold `kind=value` into the filter set. Unknown values are ignored."""
+    kind, val = parse_pair(value)
+    filters = dict(st["filters"])
+
+    if kind in _FILTER_LISTS:
+        key, allowed = _FILTER_LISTS[kind]
+        if val not in allowed():
+            return st
+        chosen = list(filters.get(key, []))
+        # Clicking a selected chip clears it, so "none selected" means all.
+        filters[key] = [x for x in chosen if x != val] if val in chosen \
+            else chosen + [val]
+    elif kind == "min_trades":
+        try:
+            filters["min_trades"] = max(0, min(500, int(val)))
+        except ValueError:
+            return st
+    elif kind in ("require_oos", "hide_baselines"):
+        filters[kind] = not filters.get(kind, False)
+    else:
+        return st
+
+    st["filters"] = filters
+    return st
+
+
 def _set_param(st: dict, name: str, raw: str) -> dict:
     """Set a numeric field, ignoring anything that is not a number."""
     if name in NUMERIC_PARAMS:
@@ -413,7 +457,7 @@ def build_app() -> gr.Blocks:
 
     with gr.Blocks(theme=theme.bit_theme(), css=theme.full_css(),
                    head=BRIDGE_JS, title="Bit · Backtest Lab",
-                   analytics_enabled=False, fill_height=True) as demo:
+                   analytics_enabled=False) as demo:
 
         state = gr.State(boot)
         history = gr.State([])
@@ -431,7 +475,14 @@ def build_app() -> gr.Blocks:
         action_trigger = gr.Button("", elem_id=TRIGGER_ELEMENT_ID,
                                    visible=True, variant="secondary")
 
-        top_html = gr.HTML(render_top(boot, None))
+        # The header is a Row so a real `gr.LoginButton` can sit inside the
+        # bar. That component is also what makes Gradio mount the OAuth routes
+        # at all -- without it, /login/huggingface is a 404.
+        with gr.Row(elem_classes="bit-headerbar"):
+            top_html = gr.HTML(render_top(boot, None))
+            if ON_SPACE:
+                gr.LoginButton(value="Sign in with Hugging Face", size="sm",
+                               elem_classes="bit-login-btn", scale=0)
 
         with gr.Row(elem_classes="bit-zones", equal_height=False):
             # Strategy Builder belongs to the Backtest tab only.
@@ -446,6 +497,7 @@ def build_app() -> gr.Blocks:
                     catalog_meta = gr.HTML("")
                     with gr.Tabs():
                         with gr.Tab("Leaderboard"):
+                            lb_controls = gr.HTML("")
                             podium = gr.HTML("")
                             lb_meta = gr.HTML("")
                             lb_table = gr.HTML("")
@@ -509,6 +561,7 @@ def build_app() -> gr.Blocks:
                         stat_html = gr.HTML("")
                         with gr.Tabs():
                             with gr.Tab("Overview"):
+                                chart_opts = gr.HTML("")
                                 equity_plot = gr.Plot()
                                 regime_plot = gr.Plot()
                                 with gr.Row():
@@ -540,7 +593,8 @@ def build_app() -> gr.Blocks:
 
         overview_out = [equity_plot, regime_plot, underwater_plot, rolling_plot,
                         price_plot, pnl_plot, hold_plot, mae_plot, costs_note]
-        compare_out = [podium, lb_table, lb_overlay, lb_scatter, lb_meta]
+        compare_out = [lb_controls, podium, lb_table, lb_overlay,
+                       lb_scatter, lb_meta]
         view_out = [left_col, compare_view, backtest_view, empty_html, results_view]
 
         def views(st, rec):
@@ -556,13 +610,23 @@ def build_app() -> gr.Blocks:
             )
 
         def compare_views(st):
+            f = st["filters"]
             pod, table_df, overlay, scatter, meta = CT.build_leaderboard_view(
-                runtime.get_store(), assets=None, timeframes=None,
-                strategies_=None, models=None, metric_label=st["metric"],
-                min_trades=0, hide_baselines=False, require_oos=True,
-                top_n=st["topn"])
-            return (pod, render_table(table_df, align_right=range(4, 15),
-                                      empty="catalog not generated yet"),
+                runtime.get_store(),
+                assets=f["assets"] or None, timeframes=f["timeframes"] or None,
+                strategies_=f["strategies"] or None, models=f["models"] or None,
+                metric_label=st["metric"], min_trades=f["min_trades"],
+                hide_baselines=f["hide_baselines"],
+                require_oos=f["require_oos"], top_n=st["topn"])
+            controls = shell.compare_controls(
+                st, metrics=list(CT.RANK_METRICS),
+                assets=runtime.available_assets(),
+                timeframes=list(config.TIMEFRAMES),
+                strategies_=list(catalog.CATALOG_STRATEGIES),
+                models=sorted(config.SEED_MODELS))
+            return (controls, pod,
+                    render_table(table_df, align_right=range(4, 15),
+                                 empty="catalog not generated yet"),
                     overlay, scatter, meta)
 
         def on_action(raw, st, hist, rec, progress=gr.Progress()):
@@ -571,7 +635,8 @@ def build_app() -> gr.Blocks:
 
             if not should_run:
                 return (st, hist, rec, render_left(st), render_top(st, rec),
-                        gr.update(), *(gr.update(),) * 9, gr.update(),
+                        gr.update(), shell.chart_controls(st),
+                        *(gr.update(),) * 9, gr.update(),
                         gr.update(), gr.update(), gr.update(),
                         *compare_views(st), *views(st, rec))
 
@@ -587,6 +652,7 @@ def build_app() -> gr.Blocks:
                                       tab="backtest", glossary=GLOSSARY,
                                       user=st.get("user"), on_space=ON_SPACE),
                         shell.note(esc(str(exc)), danger=True),
+                        shell.chart_controls(st),
                         *(gr.update(),) * 9, gr.update(), gr.update(),
                         gr.update(), gr.update(),
                         *compare_views(st), *views(st, None))
@@ -595,7 +661,7 @@ def build_app() -> gr.Blocks:
             hist = ([rec] + list(hist))[:40]
             return (
                 st, hist, rec, render_left(st), render_top(st, rec),
-                render_stat_band(rec),
+                render_stat_band(rec), shell.chart_controls(st),
                 *build_overview(rec, log_scale=st["log_scale"], cvd=st["cvd"]),
                 shell.micro(f"{len(rec.result.trades)} total · costs paid "
                             f"{money(rec.result.costs_paid)} · fills at next bar open"),
@@ -608,6 +674,7 @@ def build_app() -> gr.Blocks:
             )
 
         action_out = [state, history, current, left_html, top_html, stat_html,
+                      chart_opts,
                       *overview_out, trades_head, trades_html, report_md,
                       report_equity, *compare_out, *view_out]
 
@@ -674,7 +741,7 @@ def build_app() -> gr.Blocks:
             saved = catalog.load_saved_runs(store)
 
             return (st, render_top(st, None), render_left(st), meta_html,
-                    *compare_views(st),
+                    shell.chart_controls(st), *compare_views(st),
                     note, acc, cal, bars,
                     render_table(score_df, align_right=range(3, 10),
                                  empty="no scorecard rows"),
@@ -685,7 +752,8 @@ def build_app() -> gr.Blocks:
                     extension.status_html())
 
         demo.load(on_load, [state],
-                  [state, top_html, left_html, catalog_meta, *compare_out,
+                  [state, top_html, left_html, catalog_meta, chart_opts,
+                   *compare_out,
                    models_note, acc_plot, cal_plot, model_bars, score_table,
                    sig_panel, runs_table, coverage_kpis, coverage_html,
                    extend_panel])

src/store.py

@@ -20,6 +20,7 @@ Space (see `attach_scheduler`).
 from __future__ import annotations
 
 import json
+import logging
 import os
 import threading
 from dataclasses import dataclass, field, asdict
@@ -31,6 +32,8 @@ import pandas as pd
 
 from . import config
 
+log = logging.getLogger("bit.store")
+
 # --------------------------------------------------------------------------
 # Errors
 # --------------------------------------------------------------------------
@@ -583,13 +586,44 @@ class SignalStore:
 
     # -- writes -----------------------------------------------------------
 
-    def _merge_year(self, repo_path: str, new: pd.DataFrame) -> pd.DataFrame:
-        """Append-only merge: existing rows win on a ts collision."""
+    def _merge_year(self, repo_path: str, new: pd.DataFrame,
+                    supersede_on: str | None = None) -> pd.DataFrame:
+        """Merge a slice into a year file.
+
+        Re-writing the *same* thing is idempotent: existing rows win on a
+        timestamp collision, so a repeated seed or extension changes nothing.
+
+        `supersede_on` names a column that identifies which computation produced
+        a row -- `inference_version` for signals. When the incoming rows carry a
+        different value there, they are a *different* computation and must
+        replace what is stored.
+
+        This matters because the parquet path is keyed on model slug, not model
+        revision, while the manifest is keyed on both. Without superseding, a
+        second revision would be recorded in the manifest while the file still
+        held the first revision's numbers -- and a PLACEHOLDER slice would
+        shadow real output permanently.
+        """
         existing = self.read_parquet(repo_path)
         if existing is None or not len(existing):
             return new.sort_values("ts").reset_index(drop=True)
+
         existing = existing.copy()
         existing["ts"] = existing["ts"].map(_utc)
+
+        if supersede_on and supersede_on in existing.columns \
+                and supersede_on in new.columns and len(new):
+            incoming_version = new[supersede_on].iloc[0]
+            # Drop stored rows that this write supersedes at the same instant.
+            superseded = (existing["ts"].isin(set(new["ts"]))
+                          & (existing[supersede_on] != incoming_version))
+            if superseded.any():
+                log.info("superseding %d row(s) in %s (%s -> %s)",
+                         int(superseded.sum()), repo_path,
+                         existing.loc[superseded, supersede_on].iloc[0],
+                         incoming_version)
+                existing = existing[~superseded]
+
         merged = pd.concat([existing, new], ignore_index=True)
         merged = merged.drop_duplicates(subset="ts", keep="first")
         return merged.sort_values("ts").reset_index(drop=True)
@@ -612,10 +646,22 @@ class SignalStore:
         if frame.empty:
             raise StoreError("refusing to write an empty signal frame")
 
+        # The caller passes `inference_version` *and* the frame carries a column
+        # of the same name. If those disagree, the manifest records one version
+        # while the rows claim another -- and supersede compares the wrong
+        # value, silently keeping stale numbers. One of them has to win, and it
+        # is the argument, because that is what the manifest entry records.
+        stamped = set(frame["inference_version"].unique())
+        if stamped != {inference_version}:
+            log.debug("stamping inference_version %s over %s",
+                      inference_version, sorted(stamped))
+            frame = frame.copy()
+            frame["inference_version"] = inference_version
+
         total_rows = 0
         for year, part in frame.groupby(frame["ts"].dt.year):
             path = self.signal_path(model_slug, asset, timeframe, int(year))
-            merged = self._merge_year(path, part)
+            merged = self._merge_year(path, part, supersede_on="inference_version")
             self._stage(path, lambda p, m=merged: m.to_parquet(p, index=False))
             total_rows += len(merged)
 

src/ui/shell.py

@@ -176,11 +176,11 @@ def glossary_tooltip(items):
 
 
 def login_control(user=None, on_space=True):
-    """Sign-in link, or the signed-in handle.
+    """Signed-in handle, or a note when there is no OAuth to reach.
 
-    Rendered as markup rather than `gr.LoginButton` so it can live inside the
-    design's header. It points at the same OAuth route the Gradio component
-    uses. Off-Space there is no OAuth to reach, so it says so instead.
+    The sign-in *button* is a real `gr.LoginButton` placed beside this markup:
+    Gradio only mounts `/login/huggingface` when it sees that component in the
+    app, so hand-rolling an anchor points at a route that returns 404.
     """
     if user:
         return (
@@ -193,16 +193,10 @@ def login_control(user=None, on_space=True):
             f'<span class="mono-data" style="font-size:var(--text-2xs);'
             f"color:var(--text-tertiary);padding:3px 8px;"
             f'border:1px solid var(--border-default)" '
-            f'title="Sign-in is available when running on a Hugging Face Space. '
-            f'Reading and backtesting work without an account.">SIGN IN &#183; ON SPACE</span>'
+            f'title="Sign-in needs a Hugging Face Space. Reading and '
+            f'backtesting work without an account.">SIGN IN &#183; ON SPACE</span>'
         )
-    return (
-        f'<a href="/login/huggingface" class="mono-data" '
-        f'style="font-size:var(--text-2xs);color:var(--stone-950);'
-        f"background:var(--accent-amber);padding:3px 8px;"
-        f'border:1px solid var(--accent-amber);text-decoration:none;'
-        f'white-space:nowrap">SIGN IN WITH HUGGING FACE</a>'
-    )
+    return ""   # the real LoginButton renders here
 
 
 def top_bar(context="", status="NO RUN LOADED", tone="idle", elapsed="",
@@ -499,3 +493,58 @@ def frame_to_rows(df, limit=200):
     rows = [[esc("" if v is None else v) for v in rec]
             for rec in sub.itertuples(index=False, name=None)]
     return headers, rows
+
+
+# --------------------------------------------------------------------------
+# Compare view controls
+# --------------------------------------------------------------------------
+
+
+def compare_controls(st, *, metrics, assets, timeframes, strategies_, models):
+    """How the leaderboard is ranked, filtered and plotted.
+
+    Rendered as the design's chips rather than dropdowns so the controls read
+    as part of the board rather than a form sitting above it. Filters are
+    multi-select: clicking a chip toggles it, and none selected means all.
+    """
+    sel = st.get("filters", {})
+
+    def toggle_row(label, kind, options, active):
+        chips = [chip(o, emit("filter", f"{kind}={o}"), active=(o in active))
+                 for o in options]
+        return field(label, chips)
+
+    rank = field("Rank by", [
+        chip(m, emit("metric", m), active=(m == st["metric"])) for m in metrics])
+    top = field("Show top", [
+        chip(str(n), emit("topn", str(n)), active=(int(st["topn"]) == n))
+        for n in (10, 15, 25, 50)])
+    minimum = field("Min trades", [
+        chip(str(n), emit("filter", f"min_trades={n}"),
+             active=int(sel.get("min_trades", 0)) == n)
+        for n in (0, 20, 50)])
+    flags = field("Show", [
+        chip("Out-of-sample only", emit("filter", "require_oos=toggle"),
+             active=bool(sel.get("require_oos", True))),
+        chip("Hide baselines", emit("filter", "hide_baselines=toggle"),
+             active=bool(sel.get("hide_baselines", False))),
+        chip("Reset", emit("reset"), active=False),
+    ])
+
+    body = (
+        f'<div style="display:flex;flex-wrap:wrap;gap:16px">{rank}{top}{minimum}'
+        f"{flags}</div>"
+        + toggle_row("Assets", "asset", assets, sel.get("assets", []))
+        + toggle_row("Timeframes", "tf", timeframes, sel.get("timeframes", []))
+        + toggle_row("Strategies", "strategy", strategies_, sel.get("strategies", []))
+        + toggle_row("Models", "model", models, sel.get("models", []))
+    )
+    return panel("View", body, meta="CLICK TO FILTER · NONE SELECTED = ALL")
+
+
+def chart_controls(st):
+    """Plot options for the Backtest overview."""
+    return row([
+        chip("Log scale", emit("logscale"), active=bool(st.get("log_scale"))),
+        chip("Colorblind-safe", emit("cvd"), active=bool(st.get("cvd"))),
+    ], gap="6px")

src/ui/theme.py

@@ -447,6 +447,43 @@ input:focus, select:focus, textarea:focus{
 .bit-footer-right{ white-space:nowrap; }
 
 
+/* ================= page height =================
+   Gradio's fill_height wrapper sets `min-height:100%` on a child of a parent
+   whose own height comes from its content. That is circular: the child asks
+   for the parent's height, the parent grows to fit the child, repeat. Plotly's
+   ResizeObserver then feeds the loop and the page grows as you scroll.
+   This is a content-height dashboard, so the chain is cut instead. */
+html, body{ height:auto !important; min-height:0 !important; }
+.gradio-container, gradio-app{ height:auto !important; min-height:0 !important; }
+.gradio-container main, .gradio-container .wrap, .gradio-container .contain{
+  height:auto !important; min-height:0 !important;
+}
+.gradio-container main.fillable{ min-height:0 !important; }
+/* A plot must never be able to grow its own container. */
+.gradio-container .js-plotly-plot, .gradio-container .plot-container{
+  max-height:560px !important;
+}
+
+/* The header is a Gradio Row wrapping the design's <header> plus the real
+   LoginButton, so it must not add spacing of its own. */
+.bit-headerbar{
+  position:sticky; top:0; z-index:var(--z-header);
+  gap:0 !important; align-items:stretch !important; flex-wrap:nowrap !important;
+  background:var(--bg-panel); border-bottom:1px solid var(--border-default);
+}
+.bit-headerbar > *:first-child{ flex:1 1 auto; min-width:0; }
+.bit-headerbar header{ position:static !important; border-bottom:0 !important; }
+.bit-login-btn{
+  align-self:center; margin-right:12px !important; flex:0 0 auto !important;
+  background:var(--accent-amber) !important; color:var(--stone-950) !important;
+  border:1px solid var(--accent-amber) !important;
+  font-family:var(--font-mono) !important; font-size:var(--text-2xs) !important;
+  padding:3px 8px !important; white-space:nowrap;
+}
+.bit-login-btn:hover{
+  background:var(--stone-950) !important; color:var(--accent-amber) !important;
+}
+
 /* ================= header help tooltip =================
    The metrics glossary lives behind a `?` in the header. Pure CSS hover/focus,
    so there is no state to keep in sync and it works without JS. */
@@ -496,7 +533,7 @@ input:focus, select:focus, textarea:focus{
 .bit-zone-center{
   flex:1 1 auto !important; min-width:0 !important; padding:0 12px !important;
 }
-.bit-zone-left > *{ height:100%; }
+.bit-zone-left > *{ height:auto; }
 /* The bridge target and trigger must stay in the DOM to receive events, but
    never show. `visible=False` would remove them from the DOM entirely. */
 #bit-action, #bit-trigger{

tests/test_store.py

@@ -359,3 +359,93 @@ def test_price_write_is_idempotent(store):
     cov = store.write_prices("BTC-USD", "1d", df)
     assert cov.rows == 40
     assert len(store.get_prices("BTC-USD", "1d")) == 40
+
+
+# --------------------------------------------------------------------------
+# Redundant / interfering data
+#
+# The parquet path is keyed on model slug but the manifest is keyed on slug AND
+# revision, so two revisions share one file. Without superseding, the manifest
+# would record the new revision while the file still held the old numbers.
+# --------------------------------------------------------------------------
+
+
+def test_rewriting_the_same_version_is_idempotent(store):
+    """A repeated seed or extension must change nothing at all."""
+    store.write_signals("m", "org/m", "revA", "BTC-USD", "1d",
+                        make_signals(base=100.0), inference_version="1.0.0")
+    before = store.get_signals("m", "BTC-USD", "1d")["q50"].tolist()
+    store.write_signals("m", "org/m", "revA", "BTC-USD", "1d",
+                        make_signals(base=100.0), inference_version="1.0.0")
+    after = store.get_signals("m", "BTC-USD", "1d")
+    assert after["q50"].tolist() == before
+    assert len(after) == 30
+
+
+def test_a_new_revision_supersedes_the_old_numbers(store):
+    store.write_signals("m", "org/m", "revA", "BTC-USD", "1d",
+                        make_signals(base=100.0), inference_version="1.0.0")
+    store.write_signals("m", "org/m", "revB", "BTC-USD", "1d",
+                        make_signals(base=999.0), inference_version="2.0.0")
+
+    got = store.get_signals("m", "BTC-USD", "1d")
+    assert got["q50"].iloc[0] == 999.0, "manifest would claim revB but hold revA"
+    assert set(got["inference_version"]) == {"2.0.0"}
+    assert not got.index.duplicated().any()
+
+
+def test_real_output_supersedes_a_placeholder_slice(store):
+    """A PLACEHOLDER slice must never shadow real inference forever."""
+    store.write_signals("p", "org/p", "PLACEHOLDER", "BTC-USD", "1d",
+                        make_signals(base=1.0),
+                        inference_version=config.PLACEHOLDER_VERSION)
+    store.write_signals("p", "org/p", "revReal", "BTC-USD", "1d",
+                        make_signals(base=500.0), inference_version="1.0.0")
+
+    got = store.get_signals("p", "BTC-USD", "1d")
+    assert got["q50"].iloc[0] == 500.0
+    assert config.PLACEHOLDER_VERSION not in set(got["inference_version"])
+
+
+def test_the_written_version_is_authoritative_over_the_frame(store):
+    """The kwarg and the frame column can disagree; the kwarg records the
+    manifest entry, so it has to win or supersede compares the wrong value."""
+    df = make_signals(base=7.0)
+    df["inference_version"] = "stale-value-from-the-caller"
+    store.write_signals("m", "org/m", "revA", "BTC-USD", "1d", df,
+                        inference_version="1.0.0")
+
+    got = store.get_signals("m", "BTC-USD", "1d")
+    assert set(got["inference_version"]) == {"1.0.0"}
+
+
+def test_superseding_leaves_untouched_timestamps_alone(store):
+    """Only the overlapping instants are replaced, not the whole file."""
+    store.write_signals("m", "org/m", "revA", "BTC-USD", "1d",
+                        make_signals(n=30, start="2024-01-01", base=100.0),
+                        inference_version="1.0.0")
+    # A newer version covering only the first 10 bars.
+    store.write_signals("m", "org/m", "revB", "BTC-USD", "1d",
+                        make_signals(n=10, start="2024-01-01", base=999.0),
+                        inference_version="2.0.0")
+
+    got = store.get_signals("m", "BTC-USD", "1d")
+    assert len(got) == 30, "non-overlapping rows must survive"
+    assert got["q50"].iloc[0] == 999.0
+    assert got["inference_version"].iloc[0] == "2.0.0"
+    assert got["inference_version"].iloc[-1] == "1.0.0"
+
+
+def test_price_rows_keep_first_source_on_collision(store):
+    """Prices have no version to compare, so first-writer-wins stands. Two
+    providers disagreeing about one bar is ambiguous, not a supersede."""
+    a = make_prices(n=10)
+    a["source"] = "binance"
+    b = make_prices(n=10, base=500.0)
+    b["source"] = "coinbase"
+    store.write_prices("BTC-USD", "1d", a)
+    store.write_prices("BTC-USD", "1d", b)
+
+    got = store.get_prices("BTC-USD", "1d")
+    assert len(got) == 10
+    assert set(got["source"]) == {"binance"}

tests/test_ui.py

@@ -630,24 +630,31 @@ def test_header_carries_nav_login_and_glossary():
     html = shell.top_bar(tab="backtest", glossary=bitapp.GLOSSARY, on_space=True)
     assert 'data-bit="tab:compare"' in html
     assert 'data-bit="tab:backtest"' in html
-    assert "/login/huggingface" in html, "sign-in link missing from the header"
     assert "bit-help" in html, "glossary tooltip missing from the header"
 
 
-def test_signed_in_header_shows_the_handle_not_a_login_link():
+def test_signed_in_header_shows_the_handle():
     from src.ui import shell
 
-    html = shell.top_bar(user="alice", on_space=True)
-    assert "@alice" in html
-    assert "/login/huggingface" not in html
+    assert "@alice" in shell.top_bar(user="alice", on_space=True)
+
+
+def test_sign_in_uses_a_real_login_button_not_a_handrolled_link():
+    """Gradio only mounts /login/huggingface when it sees a LoginButton in the
+    app. A hand-rolled anchor points at a route that returns 404."""
+    import inspect
+    from src.ui import shell
+
+    src = inspect.getsource(bitapp.build_app)
+    assert "gr.LoginButton" in src, "no LoginButton, so OAuth routes never mount"
+    # and the markup must not fake one
+    assert "/login/huggingface" not in shell.top_bar(on_space=True)
 
 
 def test_off_space_header_explains_sign_in_is_unavailable():
     from src.ui import shell
 
-    html = shell.top_bar(on_space=False)
-    assert "/login/huggingface" not in html
-    assert "SIGN IN" in html
+    assert "SIGN IN" in shell.top_bar(on_space=False)
 
 
 def test_context_chip_only_appears_on_the_backtest_tab():