fixed ui

app.py

@@ -28,8 +28,9 @@ def _alt_label(i: int, alt, plain) -> str:
     from collections import Counter
     top = Counter(p.category for p in alt.pois).most_common(2)
     flavor = ", ".join(c.replace("_", " ") for c, _ in top)
+    n = len(alt.pois)
     return (f"Option {i + 1} · {alt.discovery.distance_m / 1000:.1f} km · +{extra} min · "
-            f"{len(alt.pois)} stops ({flavor})")
+            f"{n} place{'' if n == 1 else 's'} ({flavor})")
 
 
 @app.api(name="suggest")
@@ -63,9 +64,16 @@ def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
     if result.error:
         return {
             "error": result.error,
-            "map_html": mapui.empty_map("Hmm — " + result.error.split(".")[0] + "."),
+            "map_html": mapui.empty_map("Hmm — " + result.error.split(". ")[0].rstrip(".") + "."),
         }
 
+    geo = {
+        "start": list(result.start) if result.start else None,
+        "end": list(result.end) if result.end else None,
+        "mode": (mode or "walk").lower(),
+        "start_label": start, "end_label": dest,
+    }
+
     alts = result.alternatives or []
     if not alts:  # honest no-detour (or budget 0): plain route + stump state
         return {
@@ -79,6 +87,8 @@ def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
             "nodetour_html": _nodetour_html(),
             "alternatives": [],
             "last_cats": [],
+            "export": _export_data(result.plain, []),
+            **geo,
         }
 
     alternatives = []
@@ -90,6 +100,7 @@ def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
                 start=result.start, end=result.end),
             "summary_md": alt.summary_md,
             "itinerary_md": alt.itinerary_md,
+            "export": _export_data(alt.discovery, alt.pois),
         })
 
     return {
@@ -98,6 +109,22 @@ def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
         "interpretation_md": result.interpretation_md,
         "alternatives": alternatives,
         "last_cats": [p.category for p in alts[0].pois],
+        **geo,
+    }
+
+
+def _export_data(route, pois) -> dict:
+    """Lat/lon waypoints + the real polyline, so the browser can build a Google/
+    Apple Maps link or a GPX file without re-planning."""
+    from discoverroute.data import taxonomy
+    return {
+        "waypoints": [
+            {"lat": round(p.lat, 6), "lon": round(p.lon, 6),
+             "name": taxonomy.display_label(p)}
+            for p in (pois or [])
+        ],
+        "coords": [[round(c[0], 6), round(c[1], 6)]
+                   for c in (getattr(route, "coords", None) or [])],
     }
 
 

data/build_manifest.json

@@ -0,0 +1,8 @@
+{
+  "source": "OpenStreetMap",
+  "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors",
+  "city": "Paris",
+  "build_date": "2026-06-12",
+  "poi_count": 30589,
+  "opening_hours_coverage_pct": 30.9
+}

src/discoverroute/config.py

@@ -4,6 +4,7 @@ Everything tunable lives here so behaviour is inspectable, not scattered.
 """
 from __future__ import annotations
 
+import json
 import os
 from pathlib import Path
 
@@ -19,6 +20,22 @@ DATA_DIR.mkdir(exist_ok=True)
 GRAPH_WALK_PATH = DATA_DIR / "paris_walk.graphml"
 POIS_PATH = DATA_DIR / "paris_pois.parquet"
 
+# --- Data provenance / freshness --------------------------------------------
+# The app runs on a static OSM snapshot; this manifest (written by build_pois.py)
+# records when it was built so the UI can show an honest "as of <date>" line.
+DATA_MANIFEST_PATH = DATA_DIR / "build_manifest.json"
+
+
+def _load_manifest() -> dict:
+    try:
+        return json.loads(DATA_MANIFEST_PATH.read_text(encoding="utf-8"))
+    except Exception:  # noqa: BLE001 - missing/invalid manifest is non-fatal
+        return {}
+
+
+DATA_MANIFEST = _load_manifest()
+DATA_BUILD_DATE = DATA_MANIFEST.get("build_date", "")  # ISO 'YYYY-MM-DD' or ''
+
 # --- Geographic scope --------------------------------------------------------
 # Paris proper (the 20 arrondissements). Used to bound the OSM download and to
 # reject out-of-area requests.
@@ -85,8 +102,10 @@ TRACE_REPO = os.environ.get(
 # the route can explore a little; the best-matching category maps to 1.0.
 AFFINITY_FLOOR = 0.15
 # Below this cosine-similarity span across categories, a vibe is treated as
-# off-domain/neutral rather than amplified into false preferences.
-MIN_AFFINITY_SPAN = 0.04
+# off-domain/neutral rather than amplified into false preferences. Measured:
+# off-domain text (gibberish, "quantum physics") spans ~0.06-0.14, real vibes
+# ~0.30+, so the threshold sits between — at 0.04 the guard never fired.
+MIN_AFFINITY_SPAN = 0.18
 
 
 # --- Adventurousness ---------------------------------------------------------

src/discoverroute/data/build_pois.py

@@ -116,11 +116,29 @@ def build_pois(place: str = config.PARIS_PLACE) -> pd.DataFrame:
 
 
 def main() -> None:
+    import json
+    from datetime import datetime, timezone
+
     df = build_pois()
     config.POIS_PATH.parent.mkdir(parents=True, exist_ok=True)
     df.to_parquet(config.POIS_PATH, index=False)
     print(f"[build_pois] saved {len(df):,} POIs to {config.POIS_PATH}")
 
+    # Provenance manifest so the app can show an honest "data as of <date>" line.
+    n = max(1, len(df))
+    hours = int(df["opening_hours"].notna().sum())
+    manifest = {
+        "source": "OpenStreetMap",
+        "license": "ODbL — © OpenStreetMap contributors",
+        "city": "Paris",
+        "build_date": datetime.now(timezone.utc).date().isoformat(),
+        "poi_count": int(len(df)),
+        "opening_hours_coverage_pct": round(hours / n * 100, 1),
+    }
+    config.DATA_MANIFEST_PATH.write_text(
+        json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(f"[build_pois] wrote manifest {config.DATA_MANIFEST_PATH}")
+
 
 if __name__ == "__main__":
     main()

src/discoverroute/data/taxonomy.py

@@ -108,6 +108,48 @@ DWELL_TIME_SEC: dict[str, float] = {
 }
 
 
+# Warm, natural noun per category for POIs that have no OSM name — so an unnamed
+# place reads as "a quiet garden", not the clunky "a park garden" / raw snake_case.
+PRETTY_CATEGORY: dict[str, str] = {
+    "park_garden": "garden",
+    "water_feature": "fountain",
+    "viewpoint": "viewpoint",
+    "monument_historic": "historic landmark",
+    "museum_gallery": "museum",
+    "artwork": "piece of public art",
+    "place_of_worship": "church",
+    "library": "library",
+    "bookshop": "bookshop",
+    "theatre_cinema": "theatre",
+    "cafe": "café",
+    "bakery_food_shop": "bakery",
+    "restaurant": "restaurant",
+    "bar_pub": "bar",
+    "market": "market",
+    "specialty_shop": "shop",
+    "attraction": "landmark",
+}
+
+
+def pretty_category(category: str) -> str:
+    """Human noun for a category, e.g. 'park_garden' -> 'garden'."""
+    return PRETTY_CATEGORY.get(category) or (category or "place").replace("_", " ")
+
+
+def display_label(poi) -> str:
+    """The single source of truth for naming a POI in any UI surface.
+
+    The real OSM name when present; otherwise a natural 'a/an <noun>' phrase with
+    the correct article (never a raw 'a artwork' or snake_case category).
+    """
+    name = getattr(poi, "name", None)
+    if name is not None and str(name).strip():
+        return str(name).strip()
+    noun = pretty_category(getattr(poi, "category", "") or "")
+    article = "an" if noun[:1].lower() in "aeiou" else "a"
+    return f"{article} {noun}"
+
+
 def posture(category: str) -> str:
     return POSTURE_DEFAULT.get(category, "pass")
 

src/discoverroute/interpret/vibe.py

@@ -75,6 +75,12 @@ def interpret(vibe: str, adventurousness: float = config.DEFAULT_ADVENTUROUSNESS
 def _explain(vibe, top, affinity, posture, budget_hint) -> str:
     if not (vibe or "").strip():
         return "_No vibe given — every kind of place is weighted equally._"
+    # Off-domain / unreadable vibe: the interpreter degraded to neutral (all
+    # categories equal). Say so honestly instead of inventing a confident top-4.
+    vals = list(affinity.values())
+    if vals and (max(vals) - min(vals)) < 1e-6:
+        return (f"_I couldn't read a clear taste from “{vibe.strip()}” — "
+                f"weighting every kind of place equally._")
     lines = [f"**Reading “{vibe.strip()}” as:**"]
     for c in top:
         nice = c.replace("_", " ")

src/discoverroute/narrate/narrate.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import os
 
+from discoverroute.data import taxonomy
 from discoverroute.narrate import grounding
 
 # Phrasing per category for the template. Generic (no external facts) so the only
@@ -42,32 +43,54 @@ def _verb(posture: str) -> str:
     return "Pause at" if posture == "stop" else "Pass by"
 
 
+def _hours_badge(poi, posture_val: str) -> str:
+    """Honest open/closed badge. Unknown hours are flagged only for places you'd
+    enter (stops); a park you stroll past needs no 'hours unverified' caveat."""
+    state = getattr(poi, "open_state", None)  # OSM opening_hours, when decidable
+    if state is True:
+        return " · 🟢 open now"
+    if state is False:
+        return " · 🔴 closed right now"
+    if posture_val == "stop":
+        return " · ⚪ hours unverified"
+    return ""
+
+
 def template_narration(plain, discovery, pois, vibe, mode, start_label="",
-                       end_label="", posture=None) -> str:
+                       end_label="", posture=None, weights=None) -> str:
     posture = posture or {}
+    n = len(pois)
     extra = round(discovery.time_min + getattr(discovery, "dwell_s", 0.0) / 60.0
                   - plain.time_min)
     unit = "minute" if extra == 1 else "minutes"
-    lead = f"### Why this route\n"
-    vibe_clause = f" for a *{vibe.strip()}*" if (vibe or "").strip() else ""
+    place_word = "place" if n == 1 else "places"
+    v = (vibe or "").strip()
+    vibe_clause = f" to match your *{v}* mood" if v else ""
+    lead = "### Why this route\n"
     lead += (
         f"Spending **{extra} extra {unit}**{vibe_clause}, your {mode} threads "
-        f"{len(pois)} discoveries between {start_label or 'the start'} and "
+        f"**{n} {place_word}** between {start_label or 'the start'} and "
         f"{end_label or 'the destination'}:\n"
     )
+    # The categories the vibe leans on most — used to tie a stop back to the vibe.
+    top_cats: set[str] = set()
+    aff = getattr(weights, "category_affinity", None)
+    if v and aff:
+        top_cats = set(sorted(aff, key=aff.get, reverse=True)[:3])
+
     lines = [lead]
+    prev_cat = None
     for i, p in enumerate(pois, 1):
-        name = p.name or f"a {p.category.replace('_', ' ')}"
-        reason = _REASON.get(p.category, "a stop worth making")
-        verb = _verb(posture.get(p.category, "pass"))
-        state = getattr(p, "open_state", None)  # OSM opening_hours, when decidable
-        if state is True:
-            badge = " · 🟢 open now"
-        elif state is False:
-            badge = " · 🔴 closed right now"
+        label = taxonomy.display_label(p)
+        if p.category == prev_cat:  # avoid 3 identical reason lines in a row
+            reason = f"another {taxonomy.pretty_category(p.category)} along the way"
         else:
-            badge = ""
-        lines.append(f"{i}. **{name}** — {verb.lower()} for {reason}.{badge}")
+            reason = _REASON.get(p.category, "a spot worth a look")
+        prev_cat = p.category
+        verb = _verb(posture.get(p.category, "pass"))
+        tie = " — a match for your vibe" if (v and p.category in top_cats) else ""
+        badge = _hours_badge(p, posture.get(p.category, "pass"))
+        lines.append(f"{i}. **{label}** — {verb.lower()} for {reason}{tie}.{badge}")
     lines.append(
         f"\nThen on to {end_label or 'your destination'}. Every place above is a "
         f"real spot on your route — nothing invented."
@@ -76,18 +99,29 @@ def template_narration(plain, discovery, pois, vibe, mode, start_label="",
 
 
 def llm_available() -> bool:
-    """True only if explicitly enabled and a GPU + transformers are present."""
-    if os.environ.get("DISCOVERROUTE_USE_LLM", "auto").lower() in ("0", "false", "off"):
+    """True when the generative narrator (MiniCPM5-1B) should run.
+
+    ZeroGPU gotcha: on a ZeroGPU Space the GPU is allocated on demand *inside* an
+    ``@spaces.GPU`` call, so ``torch.cuda.is_available()`` is False here at gate
+    time — gating on it would silently force the template forever. We instead
+    trust the ZeroGPU/Space environment (and an explicit override). The narrator
+    still fails closed to the template if the model errors or fails grounding.
+    """
+    flag = os.environ.get("DISCOVERROUTE_USE_LLM", "auto").lower()
+    if flag in ("0", "false", "off"):
         return False
     try:
         import torch  # noqa: F401
         import transformers  # noqa: F401
     except Exception:
         return False
+    if flag in ("1", "true", "on"):
+        return True
+    # ZeroGPU Space: CUDA isn't visible outside @spaces.GPU — enable by environment.
+    if os.environ.get("SPACES_ZERO_GPU") or os.environ.get("SPACES_ZERO_GPU_V2"):
+        return True
     try:
         import torch
-        if os.environ.get("DISCOVERROUTE_USE_LLM", "auto").lower() in ("1", "true", "on"):
-            return True
         return bool(torch.cuda.is_available())
     except Exception:
         return False
@@ -97,7 +131,7 @@ def narrate(plain, discovery, pois, vibe="", mode="walk", start_label="",
             end_label="", posture=None, weights=None) -> tuple[str, bool]:
     """Return (markdown, used_llm). Output is guaranteed grounded."""
     template = template_narration(
-        plain, discovery, pois, vibe, mode, start_label, end_label, posture
+        plain, discovery, pois, vibe, mode, start_label, end_label, posture, weights
     )
     if not llm_available():
         return template, False
@@ -142,7 +176,7 @@ def _llm_narration(plain, discovery, pois, vibe, mode, start_label, end_label,
     """Generate narration with MiniCPM5-1B, constrained to the allowed names."""
     from discoverroute.narrate.llm import run_inference
 
-    names = [p.name or f"a {p.category.replace('_', ' ')}" for p in pois]
+    names = [taxonomy.display_label(p) for p in pois]
     bullet = "\n".join(
         f"- {n} ({p.category.replace('_', ' ')})" for n, p in zip(names, pois)
     )

src/discoverroute/pipeline.py

@@ -94,6 +94,15 @@ def _plan_route_impl(
     n_alternatives: int = 1,
 ) -> PlanResult:
     """Plan a route. Returns a PlanResult; never raises for user-facing errors."""
+    # Validate & clamp inputs up front (an unknown mode would silently route at
+    # walking speed then mislabel itself; out-of-range budget breaks invariants).
+    mode = (mode or "").strip().lower()
+    if mode not in config.TRAVEL_SPEEDS_KMH:
+        return PlanResult(None, None, [], None, None, "", "",
+                          error="Mode must be 'walk' or 'bike'.")
+    slider_budget = max(0.0, min(float(budget), config.MAX_BUDGET))
+    budget = slider_budget
+    adventurousness = max(0.0, min(float(adventurousness), 1.0))
     try:
         graph = g.load_graph()
         start = g.geocode_point(start_query)
@@ -119,10 +128,10 @@ def _plan_route_impl(
             interp = interpret(vibe, adventurousness, budget)
             posture = interp.posture
             interp_md = interp.explanation
-            # An explicit pace word in the vibe ("quick", "all day") overrides the
-            # slider — otherwise the shown "pace hint → budget ≈ X" contradicts the
-            # route actually planned.
-            if interp.budget_hint is not None:
+            # An explicit pace word in the vibe ("quick", "all day") nudges the
+            # budget — BUT never resurrects a detour the user explicitly disabled
+            # by zeroing the slider (P0-3: budget 0 == plain route, slider wins).
+            if interp.budget_hint is not None and slider_budget > 0:
                 budget = interp.budget_hint
             if has_profile:
                 interp_md += "\n\n_Blended with your saved taste profile._"

src/discoverroute/routing/geocode.py

@@ -50,6 +50,30 @@ def _strip_trailing_geo(norm: str) -> str:
     return " ".join(tokens)
 
 
+# Obvious non-Paris places that would otherwise namesake-match a Paris POI
+# (e.g. a restaurant literally named "Tokyo"), silently producing a fake route.
+# Checked before name matching so they fail with an honest "Paris only" message.
+WORLD_PLACES = frozenset({
+    "london", "tokyo", "new york", "newyork", "berlin", "rome", "madrid",
+    "barcelona", "amsterdam", "brussels", "lisbon", "vienna", "prague",
+    "budapest", "moscow", "beijing", "shanghai", "hong kong", "seoul",
+    "bangkok", "singapore", "sydney", "melbourne", "dubai", "mumbai", "delhi",
+    "new delhi", "cairo", "istanbul", "athens", "dublin", "edinburgh",
+    "manchester", "los angeles", "san francisco", "chicago", "boston", "miami",
+    "toronto", "montreal", "mexico city", "rio de janeiro", "sao paulo",
+    "buenos aires", "kyoto", "osaka", "milan", "venice", "florence", "naples",
+    "munich", "frankfurt", "hamburg", "zurich", "geneva", "oslo", "stockholm",
+    "copenhagen", "helsinki", "warsaw", "kyiv", "kiev",
+    "china", "japan", "america", "usa", "england", "germany", "italy", "spain",
+    "russia", "india", "europe", "france",
+})
+
+
+def is_world_place(query: str) -> bool:
+    """True if the query is plainly a non-Paris city/country (denylist)."""
+    return _strip_trailing_geo(_normalize(query or "")) in WORLD_PLACES
+
+
 @functools.lru_cache(maxsize=1)
 def _index() -> tuple[dict[str, _Entry], list[_Entry]]:
     """Lazy name index: exact normalised-name map + full entry list.

src/discoverroute/routing/graph.py

@@ -101,8 +101,13 @@ def geocode_point(query: str) -> tuple[float, float]:
     # Try "lat, lon" first, then the offline POI-name index (no network needed).
     latlon = _try_parse_latlon(query)
     if latlon is None:
-        from discoverroute.routing.geocode import local_geocode
+        from discoverroute.routing.geocode import is_world_place, local_geocode
 
+        if is_world_place(query):
+            raise RouteError(
+                f"{query!r} looks like a place outside Paris — DiscoverRoute "
+                "covers Paris only. Try a Paris landmark (e.g. 'Louvre')."
+            )
         latlon = local_geocode(query)
     if latlon is None:
         if os.environ.get(config.OFFLINE_ENV_VAR) == "1":

src/discoverroute/routing/scoring.py

@@ -20,6 +20,12 @@ from discoverroute.data import taxonomy
 # ranks contribute score * decay**rank (rank 0 = full). 0.5 => 1, 0.5, 0.25, ...
 DIVERSITY_DECAY = 0.5
 
+# Anonymous POIs (no OSM name) are demoted by this factor — applied BEFORE the
+# adventurousness serendipity boost, so high adventurousness surfaces *named*
+# hidden gems instead of flooding the route with un-findable "a piece of public
+# art" entries. (Parks/fountains/art are 40-83% unnamed in OSM.)
+UNNAMED_SCORE_FACTOR = 0.45
+
 
 @dataclass
 class Weights:
@@ -77,7 +83,15 @@ def base_score(poi, weights: Weights, adventurousness: float) -> float:
     adv = min(1.0, max(0.0, adventurousness))
     confidence_factor = poi.confidence ** (1.0 - adv)
     serendipity = 1.0 + adv * (1.0 - poi.confidence)
-    return raw * confidence_factor * serendipity
+    # Name-aware demotion (adv-independent): only penalise POIs that explicitly
+    # carry an empty/None name. POIs with no ``name`` attribute at all (synthetic
+    # test objects) are treated as named, so this never perturbs unit tests.
+    name_factor = 1.0
+    if hasattr(poi, "name"):
+        _name = getattr(poi, "name")
+        if _name is None or (isinstance(_name, str) and not _name.strip()):
+            name_factor = UNNAMED_SCORE_FACTOR
+    return raw * name_factor * confidence_factor * serendipity
 
 
 def score_pois(pois: list, weights: Weights, adventurousness: float) -> list:

src/discoverroute/ui/map.py

@@ -110,11 +110,15 @@ def render_routes(
         all_coords.extend(discovery.coords)
 
     if pois:
+        from discoverroute.data import taxonomy
         for i, poi in enumerate(pois):
-            name = getattr(poi, "name", None) or getattr(poi, "category", "POI")
+            name = getattr(poi, "name", None)
             cat = getattr(poi, "category", "")
             icon = markers.poi_icon(cat, index=i)
-            tooltip = f"{name} · {cat.replace('_', ' ')}" if cat else str(name)
+            if name and str(name).strip():
+                tooltip = f"{name} · {taxonomy.pretty_category(cat)}" if cat else str(name)
+            else:  # unnamed → a single natural label, never raw snake_case
+                tooltip = taxonomy.display_label(poi)
             if icon is not None:
                 folium.Marker([poi.lat, poi.lon], icon=icon,
                               tooltip=tooltip).add_to(fmap)

src/discoverroute/ui/shell.py

@@ -14,9 +14,27 @@ Only the spatial layout (``APP_SHELL_CSS``) and the vanilla-JS interactivity
 """
 from __future__ import annotations
 
+from discoverroute import config
 from discoverroute.ui import design
 from discoverroute.ui import map as mapui
 
+_MONTHS = ["", "January", "February", "March", "April", "May", "June", "July",
+           "August", "September", "October", "November", "December"]
+
+
+def _provenance_line() -> str:
+    """Honest data-freshness + attribution line for the results sheet footer."""
+    when = ""
+    d = config.DATA_BUILD_DATE
+    if d:
+        try:
+            y, m, _ = d.split("-")
+            when = f" · snapshot {_MONTHS[int(m)]} {y}"
+        except Exception:  # noqa: BLE001
+            when = f" · snapshot {d}"
+    return (f"Places from OpenStreetMap{when} · open/close times are best-effort "
+            f"(often unlisted) · © OpenStreetMap contributors (ODbL)")
+
 # --------------------------------------------------------------- app-shell CSS
 APP_SHELL_CSS = """
 *{ box-sizing:border-box; }
@@ -25,45 +43,26 @@ body{ font-family:'DM Sans',ui-sans-serif,system-ui,sans-serif; color:var(--dr-i
   background:radial-gradient(1100px 520px at 88% -8%,#FBEFD6 0%,transparent 60%),var(--dr-cream); }
 
 .app-shell{
-  display:grid; grid-template-columns:340px 1fr; grid-template-rows:auto 1fr;
-  height:100vh; width:100%; background:var(--dr-cream);
+  display:grid; grid-template-columns:340px 1fr; grid-template-rows:1fr;
+  height:100vh; height:100dvh; width:100%; background:var(--dr-cream);
 }
 
-/* ---- hero (compact but roomy — content must never clip) ---- */
-.hero{ grid-column:1 / -1; grid-row:1; display:flex; align-items:center; gap:22px;
-  background:linear-gradient(120deg,#2F5DF4,#5C7DF8); color:#fff;
-  padding:18px 34px; max-height:180px; overflow:hidden; position:relative;
-  box-shadow:0 10px 30px -18px rgba(33,74,208,.7); z-index:3; }
-.hero::after{ content:''; position:absolute; inset:0; pointer-events:none;
-  background:radial-gradient(420px 180px at 96% -30%,rgba(255,255,255,.16),transparent 70%); }
-.hero .hero-body{ flex:1; min-width:0; position:relative; z-index:1; }
-.hero .loc-pill{ display:inline-flex; align-items:center; gap:7px; background:rgba(255,255,255,.18);
-  border-radius:999px; padding:4px 12px; font-family:'Fredoka',sans-serif; font-weight:600;
-  font-size:11.5px; letter-spacing:.05em; text-transform:uppercase; }
-.hero .loc-pill .dot{ width:7px;height:7px;border-radius:50%;background:#FFC247;
-  box-shadow:0 0 0 0 rgba(255,194,71,.7); animation:drBeacon 2.4s ease-out infinite; }
-@keyframes drBeacon{ 0%{ box-shadow:0 0 0 0 rgba(255,194,71,.6); }
-  70%,100%{ box-shadow:0 0 0 7px rgba(255,194,71,0); } }
-.hero h1{ font-family:'Fredoka',sans-serif; font-weight:700; font-size:30px; letter-spacing:-.025em;
-  margin:7px 0 4px; line-height:1.04; color:#fff; }
-.hero h1 .accent{ color:#FFE0A0; }
-.hero p{ margin:0 0 9px; max-width:64ch; color:#EAF0FF; font-size:13px; line-height:1.35; }
-.hero .badges{ display:flex; flex-wrap:wrap; gap:8px; }
-.hero .badges span{ background:rgba(255,255,255,.14); border-radius:999px; padding:5px 12px;
-  font-size:11.5px; font-family:'Fredoka',sans-serif; font-weight:500; }
-.hero .hero-art{ flex-shrink:0; width:84px; position:relative; z-index:1;
-  animation:drFloat 6s ease-in-out infinite; }
-.hero .hero-art svg{ width:84px; height:auto; display:block; }
-@keyframes drFloat{ 0%,100%{ transform:translateY(0); } 50%{ transform:translateY(-7px); } }
-.hero .titan-chip{ position:absolute; top:12px; right:20px; z-index:2;
-  display:inline-flex; align-items:center; gap:6px; background:rgba(255,255,255,.18);
-  border-radius:999px; padding:4px 12px; font-size:10.5px; font-family:'Fredoka',sans-serif;
-  font-weight:600; letter-spacing:.02em; }
-.hero .titan-chip::before{ content:''; width:6px; height:6px; border-radius:50%;
-  background:#9BF0BE; box-shadow:0 0 6px #6FE39C; }
+/* ---- brand header (top of the left panel — replaces the old blue ribbon) ---- */
+.brand{ display:flex; align-items:center; gap:10px; padding:0 0 14px; margin-bottom:6px;
+  border-bottom:1px solid var(--dr-line); }
+.brand .logo{ width:34px; height:34px; border-radius:11px; flex-shrink:0; display:grid;
+  place-items:center; font-size:18px; background:linear-gradient(135deg,#2F5DF4,#5C7DF8);
+  box-shadow:0 6px 14px -6px rgba(47,93,244,.7); }
+.brand .bname{ font-family:'Fredoka',sans-serif; font-weight:700; font-size:19px;
+  letter-spacing:-.01em; color:var(--dr-ink); line-height:1; }
+.brand .titan-chip{ margin-left:auto; display:inline-flex; align-items:center; gap:6px;
+  background:#EAF6EF; color:var(--dr-grass-d); border-radius:999px; padding:4px 10px;
+  font-size:10px; font-family:'Fredoka',sans-serif; font-weight:600; white-space:nowrap; }
+.brand .titan-chip::before{ content:''; width:6px; height:6px; border-radius:50%;
+  background:var(--dr-grass); box-shadow:0 0 6px var(--dr-grass); }
 
 /* ---- left control panel (340px, scrollable, sticky CTA) ---- */
-.left-panel{ grid-column:1; grid-row:2; width:340px; height:100%; overflow:hidden;
+.left-panel{ grid-column:1; grid-row:1; width:340px; height:100%; overflow:hidden;
   border-right:1px solid var(--dr-line);
   background:linear-gradient(180deg,#FBF3E2,var(--dr-cream) 140px);
   display:flex; flex-direction:column; }
@@ -152,26 +151,59 @@ details.dr-collapse .collapse-body{ padding:13px 15px; }
   color:var(--dr-ink); transition:all .16s var(--dr-spring); }
 .dr-star:hover{ transform:translateY(-2px); border-color:var(--dr-sun); background:#FFF8E8; }
 
-/* ---- right column: map · summary bar · itinerary ---- */
-.right-col{ grid-column:2; grid-row:2; display:flex; flex-direction:column; height:100%;
-  min-width:0; padding:16px 18px 0; gap:14px; overflow:hidden; }
-.map-container{ flex:1 1 0; min-height:240px; position:relative; }
-#dr-map{ height:100%; }
-#dr-map .map-inner{ position:absolute; inset:46px 0 0 0; }
+/* ---- right column: full-bleed map (the hero element) ---- */
+.right-col{ grid-column:2; grid-row:1; position:relative; height:100%; min-width:0; overflow:hidden; }
+.map-container{ position:absolute; inset:0; }
+/* full-bleed: strip the framed-window chrome that DR_CSS gives #dr-map */
+#dr-map{ height:100%; border:none !important; border-radius:0 !important;
+  box-shadow:none !important; background:#F6ECD9; }
+#dr-map::before{ display:none !important; }
+#dr-map .map-inner{ position:absolute; inset:0; }
 #dr-map .map-inner > div,
 #dr-map iframe,
 #dr-map .folium-map,
 #dr-map .leaflet-container{ width:100% !important; height:100% !important; }
 #dr-map .map-inner > div > div{ padding-bottom:0 !important; height:100% !important; }
-.route-summary-bar{ flex:0 0 auto; }
-#dr-summary{ margin:0; }
+
 /* the styled result blocks only exist once a route is planned */
 #dr-summary:empty, #dr-interp:empty, #dr-itin:empty, #dr-nodetour:empty{ display:none; }
-.itinerary-panel{ flex:0 1 auto; min-height:0; max-height:46vh; overflow-y:auto; padding-bottom:16px;
+
+/* ---- floating results sheet: overlays the map, never resizes it ---- */
+.results-sheet{ position:absolute; left:16px; right:16px; bottom:16px; z-index:30;
+  display:flex; flex-direction:column; max-height:46%;
+  background:var(--dr-paper); border:1px solid var(--dr-line); border-radius:22px;
+  box-shadow:0 26px 64px -26px rgba(43,38,32,.62); overflow:hidden;
+  animation:drSheetIn .34s var(--dr-spring); }
+@keyframes drSheetIn{ from{ transform:translateY(16px); opacity:.4; } to{ transform:none; opacity:1; } }
+.results-sheet[hidden]{ display:none; }
+.sheet-head{ flex:0 0 auto; display:flex; align-items:stretch; cursor:pointer; }
+.sheet-head #dr-summary{ flex:1 1 auto; margin:0 !important; border-radius:0 !important; }
+.sheet-toggle{ flex:0 0 auto; width:46px; border:none; cursor:pointer; color:#fff;
+  background:var(--dr-grass-d); font-size:16px; display:grid; place-items:center;
+  transition:background .15s, transform .25s var(--dr-spring); }
+.sheet-toggle:hover{ background:#1A6B3E; }
+.results-sheet.collapsed .sheet-toggle{ transform:rotate(180deg); }
+.sheet-body{ flex:1 1 auto; min-height:0; overflow-y:auto; padding:14px 18px 16px;
   scrollbar-width:thin; scrollbar-color:var(--dr-line) transparent; }
-.itinerary-panel::-webkit-scrollbar{ width:9px; }
-.itinerary-panel::-webkit-scrollbar-thumb{ background:var(--dr-line); border-radius:9px;
+.sheet-body::-webkit-scrollbar{ width:9px; }
+.sheet-body::-webkit-scrollbar-thumb{ background:var(--dr-line); border-radius:9px;
   border:3px solid transparent; background-clip:content-box; }
+.results-sheet.collapsed .sheet-body{ display:none; }
+
+/* export-to-maps row inside the results sheet */
+.export-row{ display:flex; flex-wrap:wrap; align-items:center; gap:8px; margin-bottom:14px;
+  padding-bottom:14px; border-bottom:1px dashed var(--dr-line); }
+.export-row[hidden]{ display:none; }
+.export-label{ font-family:'Fredoka',sans-serif; font-weight:600; font-size:12px;
+  color:var(--dr-soft); margin-right:2px; }
+.ex-btn{ display:inline-flex; align-items:center; gap:5px; font-family:'DM Sans',sans-serif;
+  font-size:12.5px; font-weight:600; color:var(--dr-ink); text-decoration:none; cursor:pointer;
+  border:1.5px solid var(--dr-line); background:#FFFDF8; border-radius:999px; padding:6px 12px;
+  transition:transform .16s var(--dr-spring), border-color .16s, background .16s; }
+.ex-btn:hover{ transform:translateY(-2px); border-color:var(--dr-cobalt); background:#F0F4FF; }
+.ex-note{ flex-basis:100%; font-size:11px; color:var(--dr-soft); line-height:1.4; }
+.data-note{ margin-top:14px; padding-top:12px; border-top:1px dashed var(--dr-line);
+  font-size:10.5px; color:var(--dr-soft); line-height:1.45; }
 #dr-options{ display:flex; flex-wrap:wrap; gap:10px; margin-bottom:14px; }
 #dr-options:empty{ display:none; }
 #dr-options .opt{ border:2px solid var(--dr-line); border-radius:var(--dr-r); padding:11px 14px;
@@ -191,8 +223,8 @@ details.dr-collapse .collapse-body{ padding:13px 15px; }
 .onboard p{ margin:0; font-size:12.5px; color:var(--dr-soft); line-height:1.5; }
 
 /* ---- loading: stride + 4-step stepper (State 2) ---- */
-#dr-loading{ position:absolute; inset:46px 0 0 0; z-index:20; display:none;
-  place-items:center; border-radius:0 0 26px 26px;
+#dr-loading{ position:absolute; inset:0; z-index:40; display:none;
+  place-items:center;
   background:radial-gradient(700px 320px at 50% 0%,#FBEFD6 0%,transparent 70%),#F6ECD9; }
 #dr-loading.on{ display:grid; animation:drFade .25s ease; }
 @keyframes drFade{ from{ opacity:0; } to{ opacity:1; } }
@@ -213,7 +245,7 @@ details.dr-collapse .collapse-body{ padding:13px 15px; }
   border-radius:3px; transition:background .4s ease; }
 .stepper .bar.fill{ background:var(--dr-grass); }
 /* State 1 — non-Paris graph load (inert for the Paris demo, built per brief) */
-#dr-mapping{ position:absolute; inset:46px 0 0 0; z-index:21; display:none; place-items:center;
+#dr-mapping{ position:absolute; inset:0; z-index:41; display:none; place-items:center;
   background:#F6ECD9; }
 #dr-mapping.on{ display:grid; }
 #dr-mapping .pulse{ width:18px;height:18px;border-radius:50%;background:var(--dr-grass);
@@ -229,17 +261,11 @@ details.dr-collapse .collapse-body{ padding:13px 15px; }
 
 /* ---- mobile: left panel → bottom drawer, full-screen map, coral FAB ---- */
 @media (max-width:768px){
-  .app-shell{ grid-template-columns:1fr; grid-template-rows:auto 1fr; height:100vh; }
-  .hero{ max-height:none; }
-  .hero .hero-art{ display:none; }
-  .hero .titan-chip{ position:static; margin-top:8px; align-self:flex-start; }
-  .right-col{ grid-column:1; grid-row:2; padding:0; gap:0; }
-  .map-container{ min-height:0; }
-  #dr-map .map-inner, #dr-loading, #dr-mapping{ inset:0; }
-  .itinerary-panel{ max-height:34vh; padding:0 14px 14px; }
-  .route-summary-bar{ padding:0 12px; }
+  .app-shell{ grid-template-columns:1fr; grid-template-rows:1fr; }
+  .right-col{ grid-column:1; grid-row:1; }
+  .results-sheet{ left:10px; right:10px; bottom:10px; max-height:56%; }
   .left-panel{ position:fixed; left:0; right:0; bottom:0; top:auto; z-index:200; width:100%;
-    height:auto; max-height:84vh; border-right:none; border-top-left-radius:26px;
+    height:auto; max-height:86vh; max-height:86dvh; border-right:none; border-top-left-radius:26px;
     border-top-right-radius:26px; box-shadow:0 -18px 44px -20px rgba(43,38,32,.4);
     transform:translateY(110%); transition:transform .32s var(--dr-spring);
     padding-top:8px; }
@@ -263,27 +289,6 @@ details.dr-collapse .collapse-body{ padding:13px 15px; }
 """
 
 
-def _compact_hero() -> str:
-    """Hero with the exact copy/badges/colors, tightened to ≤120px."""
-    return f"""
-<header class="hero">
-  <div class="hero-body">
-    <span class="loc-pill"><span class="dot"></span>Paris · walkable detours</span>
-    <h1>Spend your extra time on <span class="accent">discovery.</span></h1>
-    <p>Ordinary navigation minimizes time. DiscoverRoute detours past places that match
-       your taste — within a travel-time budget — and tells you why each one is on the path.</p>
-    <div class="badges">
-      <span>🗺️ OpenStreetMap data</span>
-      <span>🥐 A friendly local guide</span>
-      <span>✨ Tuned to your vibe</span>
-    </div>
-  </div>
-  <div class="hero-art">{design._HERO_SVG}</div>
-  <span class="titan-chip">running on a 1B model, in-Space</span>
-</header>
-"""
-
-
 _VIBE_PRESETS = [
     "quiet green wander",
     "lively café crawl",
@@ -310,6 +315,11 @@ def _left_panel() -> str:
        aria-label="Close controls">&times;</div>
 
   <div class="panel-scroll">
+  <div class="brand">
+    <span class="logo">🗺️</span>
+    <span class="bname">WanderLust</span>
+    <span class="titan-chip">1B · in-Space</span>
+  </div>
   <div class="vibe-block">
     <div class="dr-control combo" style="margin-bottom:0;">
       <label class="dr-label" for="dr-vibe">What's your vibe today?</label>
@@ -433,7 +443,6 @@ def index_html() -> str:
 </head>
 <body>
 <div class="gradio-container app-shell">
-  {_compact_hero()}
   {_left_panel()}
   <main class="right-col">
     <div class="map-container">
@@ -442,22 +451,27 @@ def index_html() -> str:
         <span style="font-family:'Fredoka',sans-serif;font-weight:600;">Mapping the streets…</span></div></div>
       <div id="dr-loading">{_loading_inner()}</div>
     </div>
-    <div class="route-summary-bar"><div id="dr-summary"></div></div>
-    <div class="itinerary-panel">
-      <div id="dr-onboard" class="onboard">
-        <div class="ob-emoji">🥐</div>
-        <div>
-          <h3>Ready when you are.</h3>
-          <p>Pick a vibe (or tap a chip), keep or tweak the Start &amp; Destination, then
-             hit <strong>Plan my route</strong>. I'll thread a detour past places that match —
-             and tell you why each one made the cut.</p>
+    <section class="results-sheet" id="results-sheet" hidden aria-label="Route details">
+      <div class="sheet-head" id="sheet-head">
+        <div id="dr-summary"></div>
+        <button class="sheet-toggle" id="sheet-toggle" aria-label="Collapse or expand details"
+                title="Collapse / expand">&#9662;</button>
+      </div>
+      <div class="sheet-body">
+        <div class="export-row" id="export-row" hidden>
+          <span class="export-label">Take it with you</span>
+          <a id="ex-gmaps" class="ex-btn" target="_blank" rel="noopener noreferrer">🗺️ Google&nbsp;Maps</a>
+          <a id="ex-apple" class="ex-btn" target="_blank" rel="noopener noreferrer">🍎 Apple&nbsp;Maps</a>
+          <button id="ex-gpx" class="ex-btn" type="button">⬇️ GPX file</button>
+          <span class="ex-note" id="ex-note"></span>
         </div>
+        <div id="dr-options"></div>
+        <div id="dr-nodetour"></div>
+        <div id="dr-interp"></div>
+        <div id="dr-itin"></div>
+        <div class="data-note">{_provenance_line()}</div>
       </div>
-      <div id="dr-options"></div>
-      <div id="dr-nodetour"></div>
-      <div id="dr-interp"></div>
-      <div id="dr-itin"></div>
-    </div>
+    </section>
   </main>
 </div>
 <button class="fab" id="fab" aria-label="Open route controls">Plan</button>
@@ -626,6 +640,7 @@ function setStep(n) {
 function hideOnboard() { const o = $("dr-onboard"); if (o) o.style.display = "none"; }
 function startLoading() {
   hideOnboard();
+  hideSheet();
   $("dr-loading").classList.add("on");
   $("dr-summary").innerHTML = ""; $("dr-itin").innerHTML = "";
   $("dr-interp").innerHTML = ""; $("dr-options").innerHTML = ""; $("dr-nodetour").innerHTML = "";
@@ -636,8 +651,56 @@ function stopLoading() { clearInterval(stepTimer); setStep(3); $("dr-loading").c
 
 /* ---------- render ---------- */
 const REDUCE = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-let lastAlts = [], lastCats = [];
+let lastAlts = [], lastCats = [], geo = null, curExport = null;
 function renderMap(html) { $("dr-map").innerHTML = '<div class="map-inner">' + html + "</div>"; }
+
+/* ---------- export to maps (client-side; data already in the /plan payload) ---------- */
+function _ll(p) { return (+p[0]).toFixed(6) + "," + (+p[1]).toFixed(6); }
+function buildGmaps(start, end, wps, mode) {
+  const travel = mode === "bike" ? "bicycling" : "walking";
+  let u = "https://www.google.com/maps/dir/?api=1&origin=" + _ll(start) +
+          "&destination=" + _ll(end) + "&travelmode=" + travel;
+  const w = (wps || []).slice(0, 9).map(p => p.lat.toFixed(6) + "," + p.lon.toFixed(6));
+  if (w.length) u += "&waypoints=" + encodeURIComponent(w.join("|"));
+  return u;
+}
+function buildApple(start, end) {
+  return "https://maps.apple.com/?saddr=" + _ll(start) + "&daddr=" + _ll(end) + "&dirflg=w";
+}
+function _xml(s) { return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"); }
+function buildGpx(name, start, end, wps, coords) {
+  const L = ['<?xml version="1.0" encoding="UTF-8"?>',
+    '<gpx version="1.1" creator="WanderLust" xmlns="http://www.topografix.com/GPX/1/1">',
+    "<metadata><name>" + _xml(name) + "</name></metadata>"];
+  if (start) L.push('<wpt lat="' + start[0].toFixed(6) + '" lon="' + start[1].toFixed(6) + '"><name>Start</name></wpt>');
+  (wps || []).forEach(p => L.push('<wpt lat="' + p.lat.toFixed(6) + '" lon="' + p.lon.toFixed(6) + '"><name>' + _xml(p.name) + "</name></wpt>"));
+  if (end) L.push('<wpt lat="' + end[0].toFixed(6) + '" lon="' + end[1].toFixed(6) + '"><name>Destination</name></wpt>');
+  L.push("<trk><name>" + _xml(name) + "</name><trkseg>");
+  (coords || []).forEach(c => L.push('<trkpt lat="' + (+c[0]).toFixed(6) + '" lon="' + (+c[1]).toFixed(6) + '"/>'));
+  L.push("</trkseg></trk></gpx>");
+  return L.join("\n");
+}
+function refreshExport() {
+  const row = $("export-row");
+  if (!row) return;
+  if (!geo || !geo.start || !geo.end || !curExport) { row.hidden = true; return; }
+  row.hidden = false;
+  const wps = curExport.waypoints || [];
+  $("ex-gmaps").href = buildGmaps(geo.start, geo.end, wps, geo.mode);
+  $("ex-apple").href = buildApple(geo.start, geo.end);
+  $("ex-note").textContent = (wps.length > 9
+    ? "Google Maps fits 9 stops — the GPX keeps all " + wps.length + ". " : "") +
+    "Apple Maps shows start → end only; the GPX keeps every stop.";
+}
+function downloadGpx() {
+  if (!geo || !curExport) return;
+  const gpx = buildGpx("WanderLust route", geo.start, geo.end, curExport.waypoints, curExport.coords);
+  const blob = new Blob([gpx], { type: "application/gpx+xml" });
+  const a = document.createElement("a");
+  a.href = URL.createObjectURL(blob); a.download = "wanderlust-route.gpx";
+  document.body.appendChild(a); a.click(); a.remove();
+  setTimeout(() => URL.revokeObjectURL(a.href), 1500);
+}
 function enter(el) {
   if (!el || REDUCE) return;
   try { el.animate([{ transform: "translateY(10px)", opacity: 0.001 }, { transform: "none", opacity: 1 }],
@@ -661,10 +724,13 @@ function selectAlt(idx) {
   enter($("dr-summary")); enter($("dr-itin"));
   document.querySelectorAll("#dr-options .opt").forEach((o, i) =>
     o.classList.toggle("selected", i === idx));
+  curExport = a.export || null; refreshExport();
 }
 function renderResult(d) {
   hideOnboard();
-  if (d.error) { renderMap(d.map_html); toast("Hmm — " + d.error.split(".")[0] + "."); return; }
+  if (d.error) { hideSheet(); renderMap(d.map_html); toast(d.error); return; }
+  geo = { start: d.start, end: d.end, mode: d.mode,
+          start_label: d.start_label, end_label: d.end_label };
   $("dr-interp").innerHTML = md(d.interpretation_md);
   enter($("dr-interp"));
   if (d.no_detour) {
@@ -673,6 +739,8 @@ function renderResult(d) {
     $("dr-itin").innerHTML = md(d.itinerary_md);
     $("dr-nodetour").innerHTML = d.nodetour_html || "";
     lastAlts = []; lastCats = [];
+    curExport = d.export || null; refreshExport();
+    showSheet();
     return;
   }
   $("dr-nodetour").innerHTML = "";
@@ -685,10 +753,12 @@ function renderResult(d) {
       o.addEventListener("click", () => selectAlt(+o.dataset.i)));
   } else { $("dr-options").innerHTML = ""; }
   selectAlt(0);
+  showSheet();
 }
 
 /* ---------- plan ---------- */
 async function plan() {
+  closeDrawer();  // mobile: reveal the full-screen map + route
   // map-press bounce (reused micro-interaction)
   const mapEl = $("dr-map");
   if (mapEl) mapEl.animate(
@@ -734,6 +804,12 @@ const closeDrawer = () => $("left-panel").classList.remove("open");
 $("fab").addEventListener("click", openDrawer);
 $("drawer-close").addEventListener("click", closeDrawer);
 
+/* ---------- floating results sheet (collapsible overlay) ---------- */
+function showSheet() { const s = $("results-sheet"); if (s) { s.hidden = false; s.classList.remove("collapsed"); } }
+function hideSheet() { const s = $("results-sheet"); if (s) s.hidden = true; }
+$("sheet-head").addEventListener("click", () => $("results-sheet").classList.toggle("collapsed"));
+$("ex-gpx").addEventListener("click", downloadGpx);
+
 /* ---------- organic bounce on interaction (delegated, capture phase) ---------- */
 document.addEventListener("click", (e) => {
   const el = e.target.closest(

tests/test_robustness.py

@@ -0,0 +1,89 @@
+"""Regression tests for the adversarial-review fixes (input robustness + clarity).
+
+These lock in invariants that were previously violated: mode validation, the
+budget=0 == plain-route guarantee, non-Paris rejection, nonsense-vibe → neutral,
+the unnamed-POI demotion, and place-count consistency across UI surfaces.
+"""
+from __future__ import annotations
+
+import app
+from discoverroute.data import taxonomy
+from discoverroute.interpret.affinity import resolve_affinity
+from discoverroute.pipeline import plan_route
+from discoverroute.routing import scoring
+
+S = "Place de la République, Paris"
+D = "Jardin du Luxembourg, Paris"
+
+
+# ---- input validation ------------------------------------------------------
+def test_invalid_mode_rejected():
+    assert plan_route(S, D, mode="car").error
+    assert plan_route(S, D, mode="xyz").error
+
+
+def test_uppercase_mode_normalized():
+    assert plan_route(S, D, mode="WALK").error is None
+
+
+def test_world_city_rejected_not_namesake_routed():
+    err = plan_route("London", "Tokyo", vibe="quiet").error
+    assert err and "Paris" in err
+
+
+def test_budget_zero_is_plain_route_even_with_pace_word():
+    # P0-3: an explicit 0 slider must win over a vibe pace hint ("all day").
+    r = plan_route(S, D, budget=0.0, vibe="I want to spend all day exploring")
+    assert r.discovery is None and not r.pois
+
+
+# ---- vibe interpretation ---------------------------------------------------
+def test_nonsense_vibe_degrades_to_neutral():
+    aff, _ = resolve_affinity("quantum physics asdfgh")
+    spread = max(aff.values()) - min(aff.values())
+    assert spread < 1e-6  # all categories equal → neutral
+
+
+def test_real_vibe_is_confident():
+    aff, _ = resolve_affinity("quiet green park")
+    assert (max(aff.values()) - min(aff.values())) > 0.2
+
+
+# ---- unnamed-POI demotion --------------------------------------------------
+class _POI:
+    def __init__(self, name, category="park_garden", confidence=0.5):
+        self.name, self.category, self.confidence = name, category, confidence
+
+
+def test_unnamed_poi_scored_below_named():
+    w = scoring.Weights(category_affinity={"park_garden": 1.0})
+    named = scoring.base_score(_POI("Jardin X"), w, adventurousness=1.0)
+    unnamed = scoring.base_score(_POI(None), w, adventurousness=1.0)
+    assert unnamed < named  # demoted even at max adventurousness
+
+
+def test_high_adventurousness_not_mostly_unnamed():
+    r = plan_route(S, D, vibe="hidden gems off the beaten path",
+                   budget=0.7, adventurousness=1.0)
+    if r.pois:
+        unnamed = sum(1 for p in r.pois
+                      if not (getattr(p, "name", None) and str(p.name).strip()))
+        assert unnamed / len(r.pois) <= 0.5
+
+
+# ---- labels & count consistency --------------------------------------------
+def test_display_label_article_and_no_snake_case():
+    assert taxonomy.display_label(_POI(None, "artwork")) == "a piece of public art"
+    assert taxonomy.display_label(_POI(None, "attraction")) == "a landmark"
+    assert "_" not in taxonomy.display_label(_POI(None, "monument_historic"))
+    assert taxonomy.display_label(_POI("Louvre")) == "Louvre"
+
+
+def test_place_count_consistent_across_surfaces():
+    r = plan_route(S, D, vibe="quiet green bookshops", budget=0.5, n_alternatives=1)
+    if r.alternatives:
+        a = r.alternatives[0]
+        n = len(a.pois)
+        assert f"{n} place" in a.summary_md
+        assert f"{n} place" in app._alt_label(0, a, r.plain)
+        assert f"{n} place" in a.itinerary_md