finished!!

AGENTS.md

@@ -49,16 +49,20 @@ survives only as the fallback layer in `ui/_compat.py`.
 ## Deploying to HF Spaces
 
 - The Space `lucashudsn/wavereader` (public) *is* this repo — remote
-  `space`. Ship with `git push space v2:main`, then `git push origin v2`
-  to keep GitHub in sync. The Space builds from the pushed commit; watch
-  *Logs → Build* on the Space page or poll
+  `space`. Ship with `scripts/deploy_space.sh` (builds a throwaway commit
+  that prepends `space-config.yaml` to `README.md` and pushes it to
+  `space:main` — Spaces need YAML frontmatter, GitHub doesn't have to see
+  it), then `git push origin v2` to keep GitHub in sync. The Space builds
+  from the pushed commit; watch *Logs → Build* on the Space page or poll
   `HfApi().get_space_runtime("lucashudsn/wavereader")` until `RUNNING`.
-- The YAML block at the top of `README.md` is the Space config. Keep
+- `space-config.yaml` is the Space config. Keep
   `sdk_version` in lockstep with the gradio pin in `requirements.txt`
   (regenerate that file only via `uv export --no-hashes
   --format requirements-txt --no-dev -o requirements.txt` — other
   invocations can leave stray progress lines that break pip), and
   `python_version` in lockstep with `pyproject.toml`'s `requires-python`.
+  If you change Space settings via the web UI, HF rewrites the Space's
+  `README.md` — mirror anything you care about back into the yaml.
 - `HF_TOKEN` is a Space secret (set once via *Settings → Variables and
   secrets* or `HfApi().add_space_secret`); `WR_*` overrides can be added
   the same way. `.cache/` is ephemeral on the Space and rebuilds lazily —

README.md

@@ -1,17 +1,3 @@
----
-title: wave~reader
-emoji: 🏄
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.26.0
-python_version: "3.14"
-app_file: app.py
-license: mit
-pinned: false
-short_description: Surf-forecast world model for the Australian coast
----
-
 # wave~reader
 
 **A surf-forecasting world model for the Australian coast: 238 breaks, 168
@@ -130,21 +116,26 @@ is session-only and never logged.
 ## Deploying to HF Spaces
 
 The app is live at [huggingface.co/spaces/lucashudsn/wavereader](https://huggingface.co/spaces/lucashudsn/wavereader).
-The Space *is* this git repo — the `space` remote points at it — and the
-YAML block at the top of this README is the Space config: `sdk_version`
-must match the gradio pin in `requirements.txt`, and `app_file` is `app.py`.
+The Space _is_ this git repo — the `space` remote points at it. Spaces
+read their config from YAML frontmatter at the top of `README.md`, but
+GitHub renders that block as an ugly metadata table, so it lives in
+`space-config.yaml` instead and `deploy_space.sh` prepends it in a
+throwaway commit at push time. Keep `sdk_version` in lockstep with the
+gradio pin in `requirements.txt`. If you change Space settings through
+the web UI, HF commits them into the Space's `README.md` — mirror
+anything you care about back into `space-config.yaml`.
 
 ```sh
-git push space v2:main   # ship whatever is committed on v2
-git push origin v2       # keep GitHub in sync
+scripts/deploy_space.sh   # ship what's committed on v2 (pass a ref to override)
+git push origin branch_name        # keep GitHub in sync
 ```
 
 The push asks for credentials: username `lucashudsn`, password = an HF
 token with write access (https://huggingface.co/settings/tokens). The
-build takes a few minutes; watch it under the Space's *Logs → Build* tab
+build takes a few minutes; watch it under the Space's _Logs → Build_ tab
 or poll `HfApi().get_space_runtime("lucashudsn/wavereader")`.
 
-Secrets live in the Space's *Settings → Variables and secrets* —
+Secrets live in the Space's _Settings → Variables and secrets_ —
 `HF_TOKEN` is already set, which is what lets the agent and narrator work
 for visitors. `WR_MODEL` / `WR_PROVIDER` / `WR_BASE_URL` can be added the
 same way if you ever want to reroute the LLM. Caches under `.cache/` are

scripts/deploy_space.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# Ship a committed ref to the HF Space without keeping the Space's YAML
+# frontmatter in the repo copy of README.md (GitHub renders that block as
+# an ugly metadata table). Builds a throwaway commit that prepends
+# space-config.yaml to the README, pushes it to the `space` remote, then
+# removes the worktree. The repo README stays clean; HF gets its config.
+#
+#   scripts/deploy_space.sh [ref] [remote]   # defaults: v2, space
+set -euo pipefail
+
+ref="${1:-v2}"
+remote="${2:-space}"
+root="$(git rev-parse --show-toplevel)"
+config="$root/space-config.yaml"
+tmp="$(mktemp -d)"
+trap 'git worktree remove --force "$tmp" >/dev/null 2>&1 || rm -rf "$tmp"' EXIT
+
+[ -f "$config" ] || { echo "missing $config" >&2; exit 1; }
+
+git worktree add --quiet --detach "$tmp" "$ref"
+{ printf -- '---\n'; cat "$config"; printf -- '---\n\n'; cat "$tmp/README.md"; } > "$tmp/README.md.next"
+mv "$tmp/README.md.next" "$tmp/README.md"
+
+git -C "$tmp" add README.md
+git -C "$tmp" commit --quiet -m "deploy: prepend Space config to README (from $ref)"
+# Deploys are throwaway commits, so the Space's main is rewritten every
+# time — only the tip (the tree) matters to the build.
+git -C "$tmp" push --force "$remote" HEAD:refs/heads/main
+
+echo "pushed $ref (+ Space config) to $remote:main — watch the Space's Logs → Build tab"

space-config.yaml

@@ -0,0 +1,11 @@
+title: wave~reader
+emoji: 🏄
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.26.0
+python_version: "3.14"
+app_file: app.py
+license: mit
+pinned: false
+short_description: Surf-forecast world model for the Australian coast

tests/test_agent_viz.py

@@ -27,29 +27,32 @@ CHATBOT = contracts.AGENT_KEYS.index("chatbot")
 _BELLS_ARGS = {"spot_name": "Bells Beach", "region": "Victoria"}
 
 
-def _fake_stream(obs, tool_name: str, args: dict, final: str):
+def _tool_events(name: str, args: dict, obs) -> list[tuple]:
+    return [("tool_call", {"name": name, "arguments": args}),
+            ("tool_result", {"name": name, "arguments": args,
+                             "observation": obs, "summary": "ok",
+                             "ms": 1.0, "preview": ""})]
+
+
+def _run(monkeypatch, events: list[tuple], final: str, query: str):
     def stream(message, **kwargs):
         yield ("step", {"n": 1})
-        yield ("tool_call", {"name": tool_name, "arguments": args})
-        yield ("tool_result", {"name": tool_name, "arguments": args,
-                               "observation": obs, "summary": "ok",
-                               "ms": 1.0, "preview": ""})
+        yield from events
         yield ("final", final)
-        yield ("usage", {"steps": 1, "tool_calls": {tool_name: 1},
-                         "profile": "standard"})
-    return stream
-
-
-def _last_emit(monkeypatch, obs, tool_name: str, args: dict,
-               final: str = "**Best: Bells Beach @ Sat am — 6/10.**"):
-    monkeypatch.setattr(C, "agent_run_stream",
-                        _fake_stream(obs, tool_name, args, final))
+        yield ("usage", {"steps": 1, "profile": "standard"})
+    monkeypatch.setattr(C, "agent_run_stream", stream)
     records = C.list_breaks()
     selected = C.find_break(records, "Bells Beach")
     assert selected is not None, "Bells Beach must resolve from the catalogue"
-    outs = list(agent_panel.chat_fn(
-        "test question", [], "intermediate", "", selected,
-        agent_panel.fresh_store(), "standard", "auto", records))
+    return list(agent_panel.chat_fn(
+        query, [], "intermediate", "", selected,
+        agent_panel.fresh_store(), "standard", C.ALL, C.ALL, records))
+
+
+def _last_emit(monkeypatch, obs, tool_name: str, args: dict,
+               final: str = "**Best: Bells Beach @ Sat am — 6/10.**",
+               query: str = "test question"):
+    outs = _run(monkeypatch, _tool_events(tool_name, args, obs), final, query)
     return outs, outs[-1]
 
 
@@ -160,3 +163,86 @@ def test_scored_turn_still_charts_strip_midway(monkeypatch):
     charted = [o[strip] for o in outs if isinstance(o[strip], go.Figure)]
     assert charted, "mid-turn week strip never rendered"
     assert not isinstance(last[strip], go.Figure) or charted[-1] is last[strip]
+
+
+def _scored_obs(spot_name: str, region: str, score: float) -> dict:
+    hours = [{"time": f"2026-09-09T{h:02d}:00", "score": score - (h % 3) * 0.5,
+              "wave_height_m": 1.2, "wave_period_s": 9.0,
+              "wind_speed_kt": 7.0, "wind_direction_deg": 220,
+              "daylight": True} for h in range(6, 18)]
+    return {"spot": {"name": spot_name, "region": region},
+            "skill": "intermediate", "scored": hours,
+            "daily": [], "best": hours[0], "stub": True}
+
+
+def test_where_query_sweeps_region_when_agent_didnt_rank(monkeypatch):
+    # A recommendation question the agent answered without a rank sweep
+    # still closes on the recommended-scores leaderboard: the panel runs a
+    # deterministic engine sweep of the region named in the question
+    # (NSW -> New South Wales), never the viewed spot's unrelated week.
+    sweep = {"region": "New South Wales", "skill": "intermediate", "count": 2,
+             "spots": [
+                 {"name": "Bondi Beach", "region": "Sydney",
+                  "best_score": 6.5, "best_time": "2026-09-12T07:00"},
+                 {"name": "Byron Bay", "region": "Northern Rivers",
+                  "best_score": 5.5, "best_time": "2026-09-12T08:00"},
+             ]}
+    monkeypatch.setattr(C, "api_rank_region_week",
+                        lambda region, skill="intermediate", limit=10: sweep)
+    monkeypatch.setattr(C, "get_scored_week", lambda *a, **k: (_ for _ in ()).throw(
+        AssertionError("viewed-spot fallback must not run when the sweep hits")))
+    obs = _tools.get_spot_knowledge(**_BELLS_ARGS)
+    assert "error" not in obs
+    _outs, last = _last_emit(
+        monkeypatch, obs, "get_spot_knowledge", _BELLS_ARGS,
+        query="Where should I surf in NSW this weekend as a beginner?")
+    fig = last[AGENT_STRIP]
+    assert isinstance(fig, go.Figure)
+    assert any(getattr(t, "orientation", None) == "h" for t in fig.data)
+    assert "recommended breaks — New South Wales" in last[CHATBOT][-1]["content"]
+
+
+def test_seafloor_query_prefers_depth_map_over_leaderboard(monkeypatch):
+    # When the question asks about the seafloor, the depth map wins even
+    # with a rank sweep payload on the table — the chart matches the
+    # question, not the tool order.
+    rank_obs = {"region": "Victoria", "skill": "intermediate", "count": 1,
+                "spots": [{"name": "Bells Beach", "region": "Surf Coast",
+                           "best_score": 7.5, "best_time": "2026-09-12T06:00"}]}
+    seafloor_obs = _tools.get_seafloor_profile(**_BELLS_ARGS)
+    assert "error" not in seafloor_obs
+    grid = {"lats": [-38.31, -38.30, -38.29], "lngs": [144.29, 144.30, 144.31],
+            "elev": [-20.0, -12.0, -6.0, -14.0, -8.0, -4.0,
+                     -10.0, -5.0, -1.0],
+            "n": 3, "center": {"lat": -38.30, "lng": 144.30}}
+    monkeypatch.setattr(C, "get_seafloor",
+                        lambda br, radius_km=1.2: {"grid": grid, "analysis": "",
+                                                   "stats": {}})
+    events = _tool_events("rank_region_week", {"region": "Victoria"}, rank_obs)
+    events += _tool_events("get_seafloor_profile", _BELLS_ARGS, seafloor_obs)
+    outs = _run(monkeypatch, events,
+                "**Best: Bells Beach @ Sat am — 6/10.**",
+                "What's the seafloor like at Bells Beach?")
+    fig = outs[-1][AGENT_STRIP]
+    assert isinstance(fig, go.Figure)
+    assert any(t.type == "heatmap" for t in fig.data)
+    assert not any(getattr(t, "orientation", None) == "h" for t in fig.data)
+
+
+def test_compare_query_charts_multi_spot_scores(monkeypatch):
+    # Two score_week calls in one turn -> the turn closes on the
+    # side-by-side best-score compare, not just the last spot's strip.
+    events = []
+    for name, region, score in (("Bells Beach", "Victoria", 7.0),
+                                ("Snapper Rocks", "Queensland", 5.0)):
+        args = {"spot_name": name, "region": region}
+        events += _tool_events("score_week", args,
+                               _scored_obs(name, region, score))
+    outs = _run(monkeypatch, events,
+                "**Best: Bells Beach @ Sun am — 7/10.**",
+                "Compare Bells Beach and Snapper Rocks this weekend.")
+    last = outs[-1]
+    fig = last[AGENT_STRIP]
+    assert isinstance(fig, go.Figure)
+    assert any(getattr(t, "orientation", None) == "h" for t in fig.data)
+    assert "best-score compare (2 spots)" in last[CHATBOT][-1]["content"]

ui/app.py

@@ -2,7 +2,7 @@
 
 No tabs. One shared ``selected`` spot drives everything: picking it in
 the search box (or the load default) re-tells the whole page — badges,
-week strip, world model, climatology, break details — then auto-fetches
+week strip, world model, climatology — then auto-fetches
 the staged forecast, and the agent reads the same context. Exactly three
 session states: the shared pick, the scored payload, the agent store.
 Filters are one-way only.
@@ -64,8 +64,9 @@ def build() -> gr.Blocks:
             with gr.Row(elem_classes=["hero-row"]):
                 with gr.Column(scale=5, min_width=220):
                     gr.Markdown("# wave~reader", elem_classes=["hero-title"])
-                    gr.Markdown("one page from *where* to *when* — browse the map, "
-                                "pick a spot, read the week.", elem_classes=["hero-sub"])
+                    gr.Markdown("smart forecasting for australia's coast — 238 breaks scored "
+                                "hour by hour (0–10) from live marine data, real seafloor and "
+                                "each spot's ideal conditions.", elem_classes=["hero-sub"])
                 with gr.Column(scale=2, min_width=280, elem_classes=["hero-right"]):
                     mode_toggle = gr.Radio(
                         [_MODE_FORECAST, _MODE_AGENT], value=_MODE_FORECAST,
@@ -94,6 +95,11 @@ def build() -> gr.Blocks:
 
         a = agent_panel.build_agent(selected, agent_store, records, vocab, visible=False)
 
+        # Footer: the machinery line — feed/scorer/world-model latencies —
+        # lives below the fold, in both modes (outside the swapped columns).
+        with gr.Column(elem_classes=["page-foot"]):
+            f = story_panel.build_footer()
+
         def _switch_mode(mode: str):
             agentic = mode == _MODE_AGENT
             return gr.update(visible=not agentic), gr.update(visible=agentic)
@@ -104,7 +110,7 @@ def build() -> gr.Blocks:
         # Internal listeners stay off the API/MCP surface — only the three
         # typed ``gr.api`` tools (score_week / rank_region_week /
         # explain_score) are exposed.
-        comp = {**b, **s, **i, **a,
+        comp = {**b, **s, **i, **a, **f,
                 "selected": selected, "scored": scored, "agent_store": agent_store}
         select_outputs = [comp[k] for k in SELECT_KEYS]
         fetch_outputs = [comp[k] for k in FETCH_KEYS]
@@ -151,7 +157,12 @@ def build() -> gr.Blocks:
             s["fetch_forecast"], inputs=[selected, b["skill_dd"]], outputs=fetch_outputs,
             show_progress="minimal", api_name=False,
         )
-        s["narrate_btn"].click(s["narrate"], inputs=scored, outputs=s["report_md"],
+        # -- intel rail: pill tabs swap the three feature columns --
+        i["tab_picker"].change(i["pick"], inputs=i["tab_picker"],
+                               outputs=[i["report_col"], i["world_col"], i["climate_col"]],
+                               api_name=False)
+        # the report button lives in the intel rail; its handler stays story-side
+        i["narrate_btn"].click(s["narrate"], inputs=scored, outputs=i["report_md"],
                                show_progress="minimal", api_name=False)
         # -- agent: chat streams trace cards + meter + verdict + charts --
         chat_inputs = [a["msg"], a["chatbot"], b["skill_dd"], a["token_box"],

ui/contracts.py

@@ -11,8 +11,8 @@ from __future__ import annotations
 
 # Picking a spot (search box / default on load): static story + intel.
 SELECT_KEYS = (
-    "search_dd", "map_plot", "spot_header", "badges_md", "rose_plot",
-    "year_plot", "months_md", "details_df", "selected",
+    "search_dd", "map_plot", "spot_header", "badges_md", "description_md",
+    "rose_plot", "year_plot", "months_md", "selected",
 )
 
 # The staged forecast fetch: status, hero, strip, world model, state.

ui/panels/agent.py

@@ -8,11 +8,13 @@ preview. The budget meter ticks live (steps / tool calls / score_week cap /
 ≈tokens) against the slider-chosen tool budget, and the final answer's
 "Best: …" contract line is lifted into a verdict banner. Any ``score_week``
 payload in a tool result is charted straight into the week strip (the LLM
-never owns numbers), and **every answered turn ends with a visualisation**:
-turns without scored hours render the region-sweep leaderboard, climate
-rose, seafloor depth map, similarity bars or the explained-hour component
-split from their tool payloads, falling back to the viewed spot's own
-scored week.
+never owns numbers), and **every answered turn ends with a visualisation
+matched to the question**: recommendation questions close on the
+recommended-scores chart — a region-sweep leaderboard, or a side-by-side
+compare when several spots were scored this turn (a deterministic engine
+sweep fills in when the agent never ranked); climate / seafloor / similar /
+explain questions get their rose, depth map, similarity bars or component
+split; anything else falls back to the viewed spot's own scored week.
 
 User controls in the bar: a "max tool calls" slider (the per-turn step
 budget; token + score_week caps scale with it) and chained State → Region
@@ -50,6 +52,37 @@ _TOOL_ICONS = {
 _MEDALS = ["🥇", "🥈", "🥉"]
 _VERDICT_RE = re.compile(r"Best:\s*(.+)", re.IGNORECASE)
 
+# Query intent (deterministic, on the user's text only): which end-of-turn
+# chart matches the question. Scores charts are the house default; the
+# specialties jump the queue only when the question asks for them.
+_REC_RE = re.compile(
+    r"\bwhere\s+(?:should|to|can|shall|could)\b"
+    r"|\bbest\s+(?:spots?|breaks?|beaches?|places?)\b"
+    r"|\brecommend|\brank\w*|\btop\s*\d+"
+    r"|\bcompare|\bversus\b|\bvs\b"
+    r"|\bshould\s+i\s+(?:surf|go|paddle)\b", re.IGNORECASE)
+_CLIMATE_RE = re.compile(
+    r"\bclimate\b|\bmonthly\b|\bmonths?\b|winter|summer|autumn|spring\b"
+    r"|\bswell\s+direction\b|\bwhen\s+to\s+go\b", re.IGNORECASE)
+_SEAFLOOR_RE = re.compile(
+    r"\bseafloor\b|\bsea\s?floor\b|\bsea\s?bed\b|\bbathymetry\b|\bdepths?\b"
+    r"|\bstructure\b|\bsandbar\b|\breef\b", re.IGNORECASE)
+_SIMILAR_RE = re.compile(
+    r"\b(?:spots?|breaks?|beaches?)\s+like\b|\bsimilar\s+to\b"
+    r"|\balternatives?\s+to\b|\bquieter\b", re.IGNORECASE)
+_EXPLAIN_RE = re.compile(
+    r"\bwhy\b|\bexplain\w*|\bcomponent\w*|\bbreakdown\b", re.IGNORECASE)
+_SPECIALTY_RE = (
+    ("get_climate_profile", _CLIMATE_RE),
+    ("get_seafloor_profile", _SEAFLOOR_RE),
+    ("find_similar_spots", _SIMILAR_RE),
+    ("explain_score", _EXPLAIN_RE),
+)
+_STATE_CODES = {
+    "NSW": "New South Wales", "QLD": "Queensland", "VIC": "Victoria",
+    "WA": "Western Australia", "SA": "South Australia", "TAS": "Tasmania",
+}
+
 _EMPTY_TRACE = ("<div class='trace-empty'>tool calls land here live — "
                 "watch the engines work…</div>")
 _EMPTY_RANK_HTML = ("<div class='rank-empty'>leaderboard — ask "
@@ -226,23 +259,164 @@ def _viz_spot(args: dict, obs) -> tuple[str, str]:
     return str(name), str(region)
 
 
+def _specialty_tool(query: str) -> str | None:
+    """The tool whose chart the question explicitly asks for, if any."""
+    for tool_name, rx in _SPECIALTY_RE:
+        if rx.search(query or ""):
+            return tool_name
+    return None
+
+
+def _rose_chart(entry: tuple[dict, object], records: list[dict]):
+    _a, obs = entry
+    if not isinstance(obs, dict):
+        return None, ""
+    rose = (obs.get("climate") or {}).get("direction_rose_pct") or {}
+    try:
+        if not any(float(v or 0) > 0 for v in rose.values()):
+            return None, ""
+    except (TypeError, ValueError):
+        return None, ""
+    name, _region = _viz_spot(_a, obs)
+    rec = C.find_break(records, name)
+    ideal = (((rec or {}).get("idealSwell") or {}).get("direction")
+             if rec else None)
+    fig = climate_chart.build_rose_fig({"rose": rose}, name=name,
+                                       ideal_dirs=ideal)
+    return fig, f"swell climate — {name} (5-yr ERA5 rose)"
+
+
+def _depth_chart(entry: tuple[dict, object], records: list[dict]):
+    _a, obs = entry
+    if not isinstance(obs, dict):
+        return None, ""
+    name, _region = _viz_spot(_a, obs)
+    rec = C.find_break(records, name)
+    if not rec:
+        return None, ""
+    try:
+        grid = (C.get_seafloor(rec) or {}).get("grid") or {}
+        return seafloor_chart.build_depth_fig(grid, name), \
+            f"seafloor depth map — {name}"
+    except Exception:  # noqa: BLE001 — fall through to the next viz
+        return None, ""
+
+
+def _similarity_chart(entry: tuple[dict, object], records: list[dict]):
+    _a, obs = entry
+    if (isinstance(obs, list) and obs and isinstance(obs[0], dict)
+            and "similarity" in obs[0]):
+        ref = str(_a.get("spot_name") or "")
+        return (score_chart.build_similarity_fig(obs, ref),
+                f"{len(obs)} spots like {ref} — similarity")
+    return None, ""
+
+
+def _components_chart(entry: tuple[dict, object], records: list[dict]):
+    _a, obs = entry
+    if (isinstance(obs, dict) and isinstance(obs.get("components"), dict)
+            and obs["components"]):
+        name, _region = _viz_spot(_a, obs)
+        when = str(obs.get("time") or "")
+        fig = score_chart.build_component_fig(obs["components"], spot=name,
+                                              when=when, score=obs.get("score"))
+        return fig, f"component split — {name} @ {when}"
+    return None, ""
+
+
+def _specialty_figure(by_name: dict[str, tuple[dict, object]],
+                      records: list[dict],
+                      prefer: str | None = None):
+    """First buildable question-specific chart from the tool payloads.
+
+    Scans climate rose → seafloor depth map → similarity bars → component
+    split; a question-matched tool (``prefer``) is scanned first so e.g. a
+    seafloor question wins its depth map even when a rose payload exists.
+    Returns (figure, markdown note) or (None, "").
+    """
+    checks = (
+        ("get_climate_profile", _rose_chart),
+        ("get_seafloor_profile", _depth_chart),
+        ("find_similar_spots", _similarity_chart),
+        ("explain_score", _components_chart),
+    )
+    if prefer:
+        checks = tuple(sorted(checks, key=lambda c: c[0] != prefer))
+    for _tool_name, build in checks:
+        fig, note = build(by_name.get(_tool_name, ({}, None)), records)
+        if fig is not None:
+            return fig, note
+    return None, ""
+
+
+def _scored_compare_fig(scored: list[dict]):
+    """Side-by-side best-score bars for a multi-spot scored turn."""
+    rows = []
+    for s in scored or []:
+        best = score_chart.best_window(s.get("hours") or [])
+        if not best:
+            continue
+        rows.append({"name": str(s.get("label") or "?"),
+                     "region": str(s.get("region") or ""),
+                     "best_score": best.get("score"),
+                     "best_time": best.get("time")})
+    if len(rows) < 2:
+        return None, ""
+    names = " vs ".join(r["name"].split(" (")[0] for r in rows[:2])
+    fig = score_chart.build_compare_fig(
+        rows, "name", "best_score", "recommended breaks — best score this week",
+        sub_keys=("region", "best_time"))
+    return fig, f"{names} — best-score compare ({len(rows)} spots)"
+
+
+def _query_region(query: str, records: list[dict]) -> str | None:
+    """A canonical state/region named in the query (codes expanded), or None."""
+    text = f" {query or ''} ".lower()
+    vocab = sorted({str(r.get("state") or "") for r in records}
+                   | {str(r.get("region") or "") for r in records},
+                   key=len, reverse=True)
+    for name in vocab:
+        if name and re.search(rf"(?<![a-z]){re.escape(name.lower())}(?![a-z])",
+                              text):
+            return name
+    for code, name in _STATE_CODES.items():
+        if re.search(rf"(?<![a-z]){code.lower()}(?![a-z])", text):
+            return name
+    return None
+
+
 def _turn_figure(viz: list[tuple[str, dict, object]], selected: dict | None,
-                 skill: str, records: list[dict]):
-    """Pick + build a chart for a turn that scored no hours.
-
-    Every agent answer ends with a visualisation. When no score_week /
-    find_best_windows payload was charted mid-turn, render one from the
-    other deterministic tool payloads — region-sweep leaderboard, climate
-    rose, seafloor depth map, similarity bars, explained-hour component
-    split — falling back to the viewed spot's own scored week. Numbers
-    come from tool/engine output only, never from the answer text.
+                 skill: str, records: list[dict], query: str = "",
+                 focus: str | None = None, scored: list[dict] | None = None,
+                 charted: bool = False):
+    """Pick + build the end-of-turn chart, matched to the question.
+
+    The house chart is the recommended-surf-break-scores view: a
+    region-sweep leaderboard, or a side-by-side compare when several spots
+    were scored this turn. Question-specific charts (climate rose, seafloor
+    depth map, similarity bars, component split) jump the queue only when
+    the question asks for them. A recommendation question the agent answered
+    without any sweep still closes on one: a deterministic engine sweep of
+    the region named in the question (or the page's State/Region focus).
+    Numbers come from tool/engine output only, never from the answer text.
     Returns (figure, markdown note) or (None, "") when nothing chartable.
     """
     by_name: dict[str, tuple[dict, object]] = {}
     for name, args, obs in viz:
         by_name.setdefault(str(name), (args if isinstance(args, dict) else {}, obs))
-
-    # 1. region sweep → leaderboard bars
+    q = str(query or "")
+    recommend = bool(_REC_RE.search(q))
+    prefer = _specialty_tool(q)
+    special = _specialty_figure(by_name, records, prefer)
+
+    if charted:
+        # Multi-spot scored turn: week strips already ran mid-turn — close
+        # on the side-by-side scores, never an unrelated refetch.
+        return _scored_compare_fig(scored or [])
+    if not recommend and prefer and special[0] is not None:
+        return special
+
+    # scores first: the sweep leaderboard, then this turn's scored spots
     _a, obs = by_name.get("rank_region_week", ({}, None))
     rows = _coerce_rank_rows(obs)
     if rows:
@@ -253,56 +427,27 @@ def _turn_figure(viz: list[tuple[str, dict, object]], selected: dict | None,
         note = (f"region sweep{region_bit} — top pick "
                 f"**{top.get('name')}** ({top.get('best_score')}/10)")
         return score_chart.build_rank_fig(rows, region), note
+    compare = _scored_compare_fig(scored or [])
+    if compare[0] is not None:
+        return compare
 
-    # 2. climate → 5-yr swell rose
-    _a, obs = by_name.get("get_climate_profile", ({}, None))
-    if isinstance(obs, dict):
-        rose = (obs.get("climate") or {}).get("direction_rose_pct") or {}
-        try:
-            has_rose = any(float(v or 0) > 0 for v in rose.values())
-        except (TypeError, ValueError):
-            has_rose = False
-        if has_rose:
-            name, _region = _viz_spot(_a, obs)
-            rec = C.find_break(records, name)
-            ideal = (((rec or {}).get("idealSwell") or {}).get("direction")
-                     if rec else None)
-            fig = climate_chart.build_rose_fig({"rose": rose}, name=name,
-                                               ideal_dirs=ideal)
-            return fig, f"swell climate — {name} (5-yr ERA5 rose)"
-
-    # 3. seafloor → depth map from the world model
-    _a, obs = by_name.get("get_seafloor_profile", ({}, None))
-    if isinstance(obs, dict):
-        name, _region = _viz_spot(_a, obs)
-        rec = C.find_break(records, name)
-        if rec:
+    if recommend:
+        region = _query_region(q, records) or (str(focus) if focus else None)
+        if region:
             try:
-                grid = (C.get_seafloor(rec) or {}).get("grid") or {}
-                fig = seafloor_chart.build_depth_fig(grid, name)
-                return fig, f"seafloor depth map — {name}"
-            except Exception:  # noqa: BLE001 — fall through to the next viz
-                pass
-
-    # 4. similar spots → similarity bars
-    _a, obs = by_name.get("find_similar_spots", ({}, None))
-    if (isinstance(obs, list) and obs and isinstance(obs[0], dict)
-            and "similarity" in obs[0]):
-        ref = str(_a.get("spot_name") or "")
-        return (score_chart.build_similarity_fig(obs, ref),
-                f"{len(obs)} spots like {ref} — similarity")
-
-    # 5. explain_score → component split
-    _a, obs = by_name.get("explain_score", ({}, None))
-    if (isinstance(obs, dict) and isinstance(obs.get("components"), dict)
-            and obs["components"]):
-        name, _region = _viz_spot(_a, obs)
-        when = str(obs.get("time") or "")
-        fig = score_chart.build_component_fig(obs["components"], spot=name,
-                                              when=when, score=obs.get("score"))
-        return fig, f"component split — {name} @ {when}"
+                rows = _coerce_rank_rows(
+                    C.api_rank_region_week(region, skill=skill))
+            except Exception:  # noqa: BLE001 — chart fallbacks never raise
+                rows = None
+            if rows:
+                top = rows[0]
+                return (score_chart.build_rank_fig(rows, region),
+                        f"recommended breaks — {region} — top pick "
+                        f"**{top.get('name')}** ({top.get('best_score')}/10)")
+
+    if special[0] is not None:
+        return special
 
-    # 6. nothing tool-chartable → the viewed spot's own scored week
     sel = selected or {}
     if sel.get("name"):
         payload = C.get_scored_week(sel, skill=skill, days=7)
@@ -415,7 +560,9 @@ def chat_fn(message: str, history: list[dict] | None, skill: str,
                     entry_skill = skill
                     if isinstance(obs, dict) and obs.get("skill"):
                         entry_skill = obs["skill"]
-                    spots.append({"label": label, "hours": hours, "skill": entry_skill})
+                    spots.append({"label": label, "hours": hours,
+                                  "skill": entry_skill,
+                                  "region": str(region_arg or "")})
                     # Dedupe repeated chart labels at append time ("#2", "#3", …).
                     counts: dict[str, int] = {}
                     for s in spots:
@@ -483,15 +630,21 @@ def chat_fn(message: str, history: list[dict] | None, skill: str,
         yield emit(f"❌ Agent run failed: {e}")
         return
 
-    # Every answered turn ends with a visualisation. When nothing was
-    # charted mid-turn, build one from the recorded tool payloads (or the
-    # viewed spot's week) — the status is yielded first so a slow first
-    # fetch reads as a staged spin-up, never a hang.
+    # Every answered turn ends with a visualisation matched to the question,
+    # scores first. Multi-spot scored turns close on the side-by-side
+    # compare; otherwise the chain runs only when nothing was charted
+    # mid-turn. The status is yielded first so a slow fetch (e.g. a make-up
+    # region sweep) reads as a staged spin-up, never a hang.
     fallback_fig = None
-    if not turn_charted:
+    viz_note = ""
+    if (not turn_charted) or len(spots) > 1:
         yield emit("📊 assembling this turn's chart…")
         try:
-            fallback_fig, viz_note = _turn_figure(viz, selected, skill, records)
+            fallback_fig, viz_note = _turn_figure(viz, selected, skill, records,
+                                                  query=text,
+                                                  focus=_region_hint(state, region),
+                                                  scored=spots,
+                                                  charted=turn_charted)
         except Exception:  # noqa: BLE001 — a chart must never break the answer
             fallback_fig, viz_note = None, ""
         if fallback_fig is not None:
@@ -582,8 +735,9 @@ def build_agent(selected, store, records: list[dict], vocab: dict | None,
         gr.Markdown("### 💬 ask the agent — engines compute, the llm narrates")
         gr.Markdown("the agent calls ⚙ scoring, 🪨 the gebco world model, 🌡 era5 climate "
                     "and 📡 open-meteo directly; nemotron 3 ultra only narrates their "
-                    "numbers. every answer lands with a chart — week strip, rose, "
-                    "depth map, leaderboard or component split.")
+                    "numbers. every answer lands with a question-matched chart — "
+                    "recommended-scores leaderboard, week strip, rose, depth map, "
+                    "similarity bars or component split.")
         ctx_md = gr.Markdown("", elem_classes=["ctx-line"])
         with gr.Row():
             with gr.Column(scale=1):
@@ -595,7 +749,8 @@ def build_agent(selected, store, records: list[dict], vocab: dict | None,
                     steps_slider = gr.Slider(1, 12, step=1,
                                              value=_DEFAULT_STEPS,
                                              label="max calls", scale=2,
-                                             min_width=180)
+                                             min_width=180,
+                                             elem_classes=["steps-slider"])
                 token_box = gr.Textbox(label="HF token (optional, session-only)", type="password",
                                        placeholder="Defaults to the Space secret — never logged or saved.")
                 chatbot = gr.Chatbot(label="Surf agent", height=460)

ui/panels/intel.py

@@ -1,19 +1,32 @@
-"""Intel rail: the world model + the when-to-go climatology.
+"""Intel rail: three click-through tabs on the right edge of the page.
 
-Static panels — components only. Their inputs arrive through the shared
-contracts: world-model figs come from the staged fetch (FETCH_KEYS),
-climatology from the spot pick (SELECT_KEYS). Break details live in the
-lens column, directly under the map.
+**surf report** (the LLM-narrated write-up, generated on demand),
+**world model** (GEBCO bathymetry) and **when to go** (ERA5 climatology)
+hang off one pill tab row — the header mode-toggle pattern: a Radio
+swaps three stacked columns. (Gradio's native Tabs park overflow tabs in
+a "⋯" menu at this column width; the rail keeps its own switcher
+instead.) Components only — their inputs arrive through the shared
+contracts: the report button wires in ``ui/app.py``, world-model figs
+come from the staged fetch (FETCH_KEYS), climatology from the spot pick
+(SELECT_KEYS).
 """
 
 from __future__ import annotations
 
 import gradio as gr
 
+_TABS = ["report", "topography", "season"]
+
 
 def build_intel():
     """Build the intel rail (inside an existing Column). Returns components."""
-    with gr.Accordion("🌍 world model — gebco 2020", open=True):
+    tab_picker = gr.Radio(_TABS, value=_TABS[0], show_label=False,
+                          container=False, elem_classes=["intel-tabs"])
+    with gr.Column(visible=True) as report_col:
+        narrate_btn = gr.Button("get surf report ✨", variant="secondary")
+        report_md = gr.Markdown(
+            "_no report yet — pick a spot, then get the surf report._")
+    with gr.Column(visible=False) as world_col:
         gr.Markdown("bathymetry around the takeoff zone (blue = deep, green = land, "
                     "★ = break). the 3D view carries an **animated swell layer** that "
                     "rides the forecast's dominant period — press ▶ swell.")
@@ -22,12 +35,21 @@ def build_intel():
         with gr.Accordion("depth + transects", open=False):
             depth_plot = gr.Plot(label="Depth map")
             transect_plot = gr.Plot(label="Transects")
-    with gr.Accordion("📅 when to go — era5 5-yr climatology", open=True):
+    with gr.Column(visible=False) as climate_col:
         year_plot = gr.Plot(label="When to go")
         months_md = gr.Markdown("_pick a spot — its climatology lands here._")
         rose_plot = gr.Plot(label="Swell climate rose")
 
+    def pick(tab: str):
+        """Tab switch: show the picked feature column, hide the others."""
+        return (gr.update(visible=tab == _TABS[0]),
+                gr.update(visible=tab == _TABS[1]),
+                gr.update(visible=tab == _TABS[2]))
+
     return {
+        "tab_picker": tab_picker, "pick": pick,
+        "report_col": report_col, "world_col": world_col, "climate_col": climate_col,
+        "narrate_btn": narrate_btn, "report_md": report_md,
         "surface_plot": surface_plot, "depth_plot": depth_plot,
         "transect_plot": transect_plot, "seafloor_md": seafloor_md,
         "year_plot": year_plot, "months_md": months_md, "rose_plot": rose_plot,

ui/panels/lens.py

@@ -9,8 +9,6 @@ records, so no extra session state is needed here.
 
 from __future__ import annotations
 
-import pandas as pd
-
 import gradio as gr
 
 from ui import _compat as C
@@ -19,44 +17,6 @@ from ui.charts import map as map_chart
 from ui.contracts import SELECT_KEYS, fill
 
 
-def _join(value) -> str:
-    if isinstance(value, list):
-        return ", ".join(str(v) for v in value)
-    return "" if value is None else str(value)
-
-
-def break_to_table(break_: dict) -> pd.DataFrame:
-    """Flatten one break record into a Field/Value table."""
-    loc = (break_ or {}).get("location", {}) or {}
-    coords = loc.get("coordinates", {}) or {}
-    swell = (break_ or {}).get("idealSwell", {}) or {}
-    swell_size = swell.get("sizeRangeFt", {}) or {}
-    wind = (break_ or {}).get("idealWind", {}) or {}
-    tide = (break_ or {}).get("idealTide", {}) or {}
-    rows = [
-        ("Name", break_.get("name", "")),
-        ("State", break_.get("state", "")),
-        ("Region", break_.get("region", "")),
-        ("Description", break_.get("description", "")),
-        ("Skill level", break_.get("skillLevel", "")),
-        ("Break type", break_.get("breakType", "")),
-        ("Peak type", break_.get("peakType", "")),
-        ("Latitude", coords.get("lat", "")),
-        ("Longitude", coords.get("lng", "")),
-        ("Ideal swell", _join(swell.get("direction", ""))),
-        ("Swell size (ft)", f"{swell_size.get('min', '?')}–{swell_size.get('max', '?')}"),
-        ("Ideal wind", f"{_join(wind.get('direction', ''))} ({wind.get('type', '')})"),
-        ("Ideal tide", _join(tide.get("stage", ""))),
-        ("Best season", _join(break_.get("bestSeason", ""))),
-        ("Hazards", _join(break_.get("hazards", ""))),
-        ("Crowd", break_.get("crowdFactor", "")),
-    ]
-    return pd.DataFrame(rows, columns=["Field", "Value"])
-
-
-_EMPTY_DETAILS = pd.DataFrame(columns=["Field", "Value"])
-
-
 def build_lens(records: list[dict], vocab: dict, selected):
     """Build the lens column. Returns component/handler dict for wiring."""
     states = vocab["states"]
@@ -79,8 +39,6 @@ def build_lens(records: list[dict], vocab: dict, selected):
         )
         map_plot = gr.Plot(map_chart.build_map(records, default_view=True))
         gr.HTML(map_chart.skill_legend_html())
-        with gr.Accordion("📖 break details", open=False):
-            details_df = gr.Dataframe(headers=["Field", "Value"], wrap=True)
 
     def state_regions(state: str) -> dict:
         regions = regions_by_state.get(state, all_regions) if state != C.ALL else all_regions
@@ -111,7 +69,7 @@ def build_lens(records: list[dict], vocab: dict, selected):
             profile = {}  # the stub rose would be fabricated data — stay honest
         monthly = C.get_climate_monthly(record)
         cam = C.get_surf_cam(record)
-        from ui.panels.story import format_badges
+        from ui.panels.story import format_badges, format_description
 
         fly_fig = (map_chart.build_map(filtered or [record], selected=record)
                    if fly else gr.skip())
@@ -121,6 +79,7 @@ def build_lens(records: list[dict], vocab: dict, selected):
             map_plot=fly_fig,
             spot_header=header,
             badges_md=format_badges(record, cam),
+            description_md=format_description(record),
             rose_plot=climate_chart.build_rose_fig(
                 profile, name,
                 ideal_dirs=(record.get("idealSwell") or {}).get("direction"),
@@ -129,7 +88,6 @@ def build_lens(records: list[dict], vocab: dict, selected):
                 monthly, name, window_label=profile.get("window_ft", ""),
             ),
             months_md=C.format_month_hint(monthly, profile),
-            details_df=break_to_table(record),
             selected=record,
         )
 
@@ -143,7 +101,7 @@ def build_lens(records: list[dict], vocab: dict, selected):
 
     return {
         "search_dd": search_dd, "state_dd": state_dd, "region_dd": region_dd,
-        "skill_dd": skill_dd, "map_plot": map_plot, "details_df": details_df,
+        "skill_dd": skill_dd, "map_plot": map_plot,
         "state_regions": state_regions, "filter_changed": filter_changed,
         "pick_by_name": pick_by_name, "select_spot": select_spot,
     }

ui/panels/story.py

@@ -1,11 +1,11 @@
-"""Story panel: the selected spot's week — chips, strip, report.
+"""Story panel: the selected spot's week — chips, strip (report is intel-side).
 
 ``fetch_forecast`` stays a *staged generator* so the spin-up reads as
 engines working, not a spinner: stage 1 lands the Open-Meteo fetch +
 week strip immediately (~ms warm), while the GEBCO world model resolves
 in a parallel thread and streams in as stage 2. Stage timings (feed,
-scorer, world model) land in the status line — the LLM never owns the
-numbers.
+scorer, world model) land in the page footer's status line — the LLM
+never owns the numbers.
 """
 
 from __future__ import annotations
@@ -34,7 +34,7 @@ def _join(value) -> str:
 
 
 def format_badges(record: dict | None, cam: dict | None = None) -> str:
-    """Spot identity as lo-fi chips: skill, type, tide, crowd, hazards, cam."""
+    """Spot identity as lo-fi chips: every break detail but the description."""
     b = record or {}
     if not b:
         return ""
@@ -49,10 +49,22 @@ def format_badges(record: dict | None, cam: dict | None = None) -> str:
     tide = _join((b.get("idealTide") or {}).get("stage"))
     if tide:
         parts.append(f'<span class="badge-chip">🌊 tide: {esc(tide)}</span>')
-    swell = (b.get("idealSwell") or {}).get("sizeRangeFt") or {}
-    if swell.get("min") is not None:
-        parts.append(f'<span class="badge-chip">📏 likes {swell.get("min", "?")}–'
-                     f'{swell.get("max", "?")} ft</span>')
+    swell = b.get("idealSwell") or {}
+    swell_dir = _join(swell.get("direction"))
+    if swell_dir:
+        parts.append(f'<span class="badge-chip">🧭 swell dir: {esc(swell_dir)}</span>')
+    size = swell.get("sizeRangeFt") or {}
+    if size.get("min") is not None:
+        parts.append(f'<span class="badge-chip">📏 likes {size.get("min", "?")}–'
+                     f'{size.get("max", "?")} ft</span>')
+    wind = b.get("idealWind") or {}
+    wind_bits = [_ for _ in (_join(wind.get("direction")), str(wind.get("type") or "")) if _]
+    if wind_bits:
+        parts.append(f'<span class="badge-chip">🌬 wind: {esc(", ".join(wind_bits))}</span>')
+    coords = (b.get("location") or {}).get("coordinates") or {}
+    if coords.get("lat") is not None and coords.get("lng") is not None:
+        parts.append(f'<span class="badge-chip">📍 {coords["lat"]:.3f}, '
+                     f'{coords["lng"]:.3f}</span>')
     if b.get("crowdFactor"):
         parts.append(f'<span class="badge-chip">👥 {esc(str(b["crowdFactor"]))}</span>')
     if b.get("bestSeason"):
@@ -66,6 +78,14 @@ def format_badges(record: dict | None, cam: dict | None = None) -> str:
     return '<div class="badge-row">' + " ".join(parts) + "</div>"
 
 
+def format_description(record: dict | None) -> str:
+    """The break's own words, as a quiet paragraph under the badges."""
+    desc = html.escape((record or {}).get("description") or "").strip()
+    if not desc:
+        return "<div class='spot-desc spot-desc-empty'>no description on file for this spot</div>"
+    return f"<div class='spot-desc'>{desc}</div>"
+
+
 def _empty_seafloor():
     blank = seafloor_chart._empty_fig()
     return blank, blank, blank
@@ -198,12 +218,18 @@ def narrate(payload: dict | None):
 
 
 def build_story(selected, scored):
-    """Build the story column. Returns component dict for wiring."""
+    """Build the story column. Returns component dict for wiring.
+
+    The story column leads with the break itself: name, description,
+    then the detail chips and the daily ratings. The surf-report
+    feature lives in the intel
+    tabs (``ui/panels/intel.py``); the ``narrate`` handler stays here —
+    the wiring points the intel tab's button at it.
+    """
     with gr.Column(scale=4):
         spot_header = gr.Markdown("### pick a spot — search above or filter the map")
+        description_md = gr.Markdown()
         badges_md = gr.Markdown()
-        status_box = gr.Textbox(label="engines", interactive=False,
-                                placeholder="the spin-up line — feed, scorer, world model — lands here…")
         hero_md = gr.Markdown("_the week summary lands here._")
         with gr.Tabs():
             with gr.Tab("score"):
@@ -213,13 +239,23 @@ def build_story(selected, scored):
             with gr.Tab("wind"):
                 wind_plot = gr.Plot(label="wind — speed + direction")
         gr.Markdown(f"<div class='strip-caption'>{strip_chart.CAPTION}</div>")
-        narrate_btn = gr.Button("get surf report ✨", variant="secondary")
-        report_md = gr.Markdown("_no report yet — pick a spot, then get the surf report._")
 
     return {
-        "spot_header": spot_header, "badges_md": badges_md, "status_box": status_box,
-        "hero_md": hero_md, "score_plot": score_plot, "swell_plot": swell_plot,
+        "spot_header": spot_header, "badges_md": badges_md,
+        "description_md": description_md, "hero_md": hero_md,
+        "score_plot": score_plot, "swell_plot": swell_plot,
         "wind_plot": wind_plot,
-        "narrate_btn": narrate_btn, "report_md": report_md,
         "fetch_forecast": fetch_forecast, "narrate": narrate,
     }
+
+
+def build_footer():
+    """The page footer: the engines/latency line, out of the story's way.
+
+    Same component + contract key as before (``status_box`` in
+    FETCH_KEYS) — only its position on the page moved.
+    """
+    status_box = gr.Textbox(
+        label="engines", interactive=False, elem_classes=["foot-status"],
+        placeholder="idle — pick a spot and the spin-up line lands here…")
+    return {"status_box": status_box}

ui/theme.py

@@ -111,6 +111,7 @@ button.primary:hover, button.lg.primary:hover {
     --checkbox-label-border-color-selected: #0b2c5c !important;
     --checkbox-label-text-color: #0b2c5c !important;
     --checkbox-label-text-color-selected: #ffffff !important;
+    --slider-color: #0b2c5c !important;
 }
 .gradio-container .gr-box, .gradio-container .gr-panel,
 .gradio-container .block, .gradio-container .form,
@@ -213,6 +214,60 @@ ul.options .item {
 .badge-link { background: #d6e9f8 !important; text-decoration: none; font-weight: 600; }
 .badge-link:hover { background: #0b2c5c !important; color: #ffffff !important; }
 
+/* intel rail: tab row styled after the story's score/swell/wind strip —
+   bare text tabs (no block chrome), one line, orange underline marks the
+   selected one (colors measured off the live strip: #f97316 selected) */
+.gradio-container .intel-tabs,
+.gradio-container form:has(.intel-tabs),
+.gradio-container .block:has(> .intel-tabs) {
+    border: none !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+}
+.intel-tabs { margin: 0 0 4px; border-bottom: 1px solid #c9dff2; }
+.intel-tabs .wrap { display: inline-flex !important; flex-wrap: nowrap !important; gap: 0 !important; }
+.gradio-container .intel-tabs label {
+    border: none !important;
+    border-bottom: 2px solid transparent !important;
+    border-radius: 0 !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    color: #0b2c5c !important;
+    font-size: 14px !important;
+    font-weight: 400 !important;
+    padding: 4px 16px 6px !important;
+    margin: 0 0 -1px !important;
+    white-space: nowrap !important;
+}
+.gradio-container .intel-tabs label.selected,
+.gradio-container .intel-tabs label:has(input[type="radio"]:checked) {
+    background: transparent !important;
+    color: #f97316 !important;
+    border-bottom: 2px solid #f97316 !important;
+}
+.gradio-container .intel-tabs label.selected span,
+.gradio-container .intel-tabs label:has(input[type="radio"]:checked) span {
+    color: #f97316 !important;
+}
+
+/* spot description: the break's own words, right under the spot name */
+.spot-desc { font-size: 0.85em; line-height: 1.55; margin: 2px 0 4px !important; }
+.spot-desc-empty { opacity: 0.55; font-style: italic; }
+
+/* page footer: the machinery line (engines + latencies) below the fold */
+.page-foot { border-top: 2px solid #c9dff2; margin-top: 10px; }
+.gradio-container .page-foot .form,
+.gradio-container .page-foot .block {
+    border: none !important; background: transparent !important;
+    padding: 0 !important; box-shadow: none !important;
+}
+.gradio-container .page-foot label span { font-size: 0.72em; opacity: 0.7; }
+.gradio-container .page-foot textarea {
+    background: transparent !important; border: none !important;
+    font-size: 0.8em !important; padding: 2px 2px !important; resize: none !important;
+}
+
 /* week hero: day chips with score-coloured left borders */
 .day-chips { display: flex; flex-wrap: wrap; gap: 6px; margin: 6px 0; }
 .day-chip {
@@ -249,6 +304,43 @@ ul.options .item {
 .agent-controls .wrap { flex-wrap: nowrap !important; }
 .ctx-line { font-size: 0.78em; opacity: 0.8; margin: 0 2px 4px !important; }
 
+/* max-calls slider: ink-blue instrument, no number box — the thumb is the
+   value; min/max labels bracket the track */
+.steps-slider .tab-like-container { display: none !important; }
+.steps-slider .slider_input_container { align-items: center !important; margin-top: 4px !important; }
+.steps-slider .min_value, .steps-slider .max_value {
+    font-size: 12px !important; font-weight: 600 !important;
+    color: #4a6fa5 !important; opacity: 1 !important;
+}
+.steps-slider input[type="range"] { height: 20px !important; }
+.steps-slider input[type="range"]::-webkit-slider-runnable-track {
+    height: 8px !important; border-radius: 999px !important;
+    background: linear-gradient(to right, #0b2c5c var(--range_progress), #c9dff2 var(--range_progress)) !important;
+}
+.steps-slider input[type="range"]::-webkit-slider-thumb {
+    appearance: none !important;
+    height: 18px !important; width: 18px !important; margin-top: -5px !important;
+    background: #ffffff !important;
+    border: 2.5px solid #0b2c5c !important;
+    border-radius: 50% !important;
+    box-shadow: 0 1px 4px rgba(11, 44, 92, 0.3) !important;
+    transition: transform 0.12s ease !important;
+}
+.steps-slider input[type="range"]:hover::-webkit-slider-thumb,
+.steps-slider input[type="range"]:active::-webkit-slider-thumb { transform: scale(1.15); }
+.steps-slider input[type="range"]::-moz-range-track {
+    height: 8px !important; border-radius: 999px !important; background: #c9dff2 !important;
+}
+.steps-slider input[type="range"]::-moz-range-progress {
+    height: 8px !important; border-radius: 999px !important; background: #0b2c5c !important;
+}
+.steps-slider input[type="range"]::-moz-range-thumb {
+    height: 14px !important; width: 14px !important;
+    background: #ffffff !important; border: 2.5px solid #0b2c5c !important;
+    border-radius: 50% !important;
+    box-shadow: 0 1px 4px rgba(11, 44, 92, 0.3) !important;
+}
+
 /* agent trace: live tool cards with ms timing bars + payload previews */
 .trace { display: flex; flex-direction: column; gap: 6px; }
 .trace-ask { font-size: 0.78em; opacity: 0.7; margin-bottom: 2px; }
@@ -307,7 +399,10 @@ ul.options .item {
 .mode-toggle .wrap { display: inline-flex !important; gap: 0 !important; }
 .mode-toggle input[type="radio"],
 .mode-toggle input[type="radio"] + * .circle,
-.mode-toggle span.circle { display: none !important; }
+.mode-toggle span.circle,
+.intel-tabs input[type="radio"],
+.intel-tabs input[type="radio"] + * .circle,
+.intel-tabs span.circle { display: none !important; }
 .mode-toggle label {
   border-radius: 999px !important; padding: 4px 14px !important;
   font-size: 0.78em; font-weight: 600; color: #0b2c5c; cursor: pointer;