v2 with model changed and using gradio server func

.gitignore

@@ -30,3 +30,6 @@ test_output.log
 # NOTE: data/*.graphml and data/*.parquet are the offline build artifacts.
 # They are committed for the Hugging Face Space so it needs no runtime download.
 # If they exceed Space size limits, switch to git-lfs (see PROGRESS.md).
+
+# Inference trace logs (Open Trace) — written at runtime, pushed to HF Dataset
+logs/

DEPLOY.md

@@ -40,28 +40,31 @@ app, source, tests, and `data/` artifacts are pushed.
 
 ## Enable the narration LLM (optional)
 
-The app runs CPU-only out of the box (grounded **template** narration). To turn on
-the Qwen3.5-9B generative narration:
+The app runs CPU-only out of the box (grounded **template** narration + keyword/
+embedding vibe weights). To turn on the in-Space MiniCPM5-1B generative path:
 
 1. In the Space **Settings → Hardware**, select a **ZeroGPU** tier.
-2. The `@spaces.GPU` decorator on `narrate/llm.py::generate` activates automatically.
-   `narrate()` only calls the LLM when a GPU is present, and **falls back to the
-   grounded template if the LLM output fails the zero-hallucination gate** — so the
-   0% gate holds either way.
+2. The `@spaces.GPU` decorator on `narrate/llm.py::run_inference` activates
+   automatically. Vibe→weights (Call 1) and narration (Call 2) only call the model
+   when a GPU is present, and **fall back to the keyword matcher / grounded template
+   if the model is absent or its output fails validation / the zero-hallucination
+   gate** — so the app is correct either way. Weights are pulled from the HF Hub.
 
 To force the LLM on/off regardless of hardware, set the Space variable
 `DISCOVERROUTE_USE_LLM` to `1` / `0`.
 
-## Optional: live Google verification of the final stops
+## Off the Grid — no external APIs
 
-Set the Space **secret** `GOOGLE_MAPS_API_KEY` (Google Cloud → APIs → Places API
-(New) enabled, billing on) and each planned route live-verifies its ~8 chosen
-stops: permanently-closed detection, open-right-now, rating. Notes:
-- Hours fields bill at the Enterprise SKU → ~1,000 free lookups/month ≈ 125
-  routes; ~$0.15/route beyond. Only the final stops are queried, never stored
-  (Google ToS), and OSM remains the routing/candidate base.
-- Without the key the app is fully offline: open-now still works from OSM
-  `opening_hours` tags (~31% of POIs carry them).
+DiscoverRoute is OSM-only: there is **no** Google Places (or any cloud) dependency.
+Open-now comes from OSM `opening_hours` tags (~31% of POIs carry them); the 1B model
+runs inside the Space on ZeroGPU. Nothing leaves the Space at request time.
+
+## Open Trace — optional inference trace dataset
+
+Every model call logs a row to `logs/traces.jsonl`. To also publish them to an HF
+Dataset, set the Space **secret** `HF_TOKEN` (write scope) — rows are then pushed
+async to `DISCOVERROUTE_TRACE_REPO` (default `build-small-hackathon/discoverroute-traces`).
+Without the token, logging stays local (graceful no-op).
 
 ## Refreshing the data snapshot
 

HACKATHON_DEPLOYMENT.md

@@ -59,9 +59,11 @@ git push -u origin main
 
 **In Space Settings:**
 
-1. **Hardware:** Select **ZeroGPU** (for optional Qwen3.5-9B narration LLM)
-   - The app works CPU-only with template narration (no GPU needed)
-   - GPU enables the enhanced generative narration (optional polish)
+1. **Hardware:** Select **ZeroGPU** (for the in-Space MiniCPM5-1B model — a ≤4B
+   Tiny Titan, weights pulled from the HF Hub)
+   - The app works CPU-only with the keyword/embedding vibe path + template
+     narration (no GPU needed)
+   - GPU enables the generative vibe→weights (Call 1) and narration (Call 2)
 
 2. **Environment Variables (for "Off the Grid" badge):**
    ```
@@ -179,7 +181,7 @@ Go to https://huggingface.co/build-small-hackathon and submit:
 ## Post-Launch
 
 - Monitor Space logs for errors (Settings → Logs)
-- If narration LLM is enabled (ZeroGPU), watch for Qwen3.5-9B load/unload messages
+- If the LLM is enabled (ZeroGPU), watch for MiniCPM5-1B load/unload messages
 - Share the build story on Twitter / Hacker News / forums (Field Notes badge)
 
 **All code is ready. User only needs to: auth with HF → run the git push commands above → submit.**

README.md

@@ -4,7 +4,7 @@ emoji: 🗺️
 colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 6.17.3
+sdk_version: 6.18.0
 app_file: app.py
 pinned: false
 license: mit
@@ -41,7 +41,8 @@ for the per-brick build log, `FIELD_NOTES.md` for the build story, and
   viewpoint + a bookshop over five cafés, within budget.
 - **Adventurousness**: low → well-documented places; high → injects hidden gems.
 - **Grounded narration**: an itinerary that names only real waypoints, behind a
-  hard zero-hallucination gate (optional Qwen3.5-9B enhancer, gated by the same).
+  hard zero-hallucination gate (optional in-Space MiniCPM5-1B enhancer — a ≤4B
+  Tiny Titan on ZeroGPU — gated by the same).
 - **Alternative routes**: up to three genuinely distinct options.
 - **Persistent taste profile**: standing preferences + saved places, per device,
   blended with each trip's mood. No accounts.

app.py

@@ -1,249 +1,118 @@
-"""DiscoverRoute — Gradio app (Hugging Face Space entrypoint).
+"""DiscoverRoute — gradio.Server entrypoint (Hugging Face Space app_file).
+
+Off-Brand custom frontend: instead of Gradio's default column layout, this serves
+a hand-built app-shell (ui/shell.py) from ``app.get("/")`` and exposes the planner
+as ``@app.api`` endpoints called from the browser via ``@gradio/client`` (the
+required path for ZeroGPU).
 
 Run locally:  python app.py
-UI design ported from the Claude-design handoff (low-poly clay-sticker look):
-state machine empty → loading → (routed | no-detour), framed map window with
-in-iframe route-draw animation, springy controls, toasts, per-device profile.
 """
 from __future__ import annotations
 
-import gradio as gr
+import json
+
+from fastapi.responses import HTMLResponse
+from gradio import Server
 
-from discoverroute import config
 from discoverroute.pipeline import plan_route
-from discoverroute.ui import design
 from discoverroute.ui import map as mapui
+from discoverroute.ui import shell
 
 N_ALTERNATIVES = 3
 
-
-def _saved_md(profile: dict) -> str:
-    saved = (profile or {}).get("saved_categories") or []
-    if not saved:
-        return "_No saved places yet. Plan a route, then ⭐ save its places._"
-    from collections import Counter
-    counts = Counter(saved)
-    items = ", ".join(f"{c.replace('_',' ')} ×{n}" for c, n in counts.most_common())
-    return f"**Saved taste:** {items}"
+app = Server()
 
 
 def _alt_label(i: int, alt, plain) -> str:
-    extra = round(alt.discovery.time_min + alt.discovery.dwell_s / 60.0
-                  - plain.time_min)
+    extra = round(alt.discovery.time_min + alt.discovery.dwell_s / 60.0 - plain.time_min)
     from collections import Counter
     top = Counter(p.category for p in alt.pois).most_common(2)
     flavor = ", ".join(c.replace("_", " ") for c, _ in top)
-    return (f"Option {i+1} · {alt.discovery.distance_m/1000:.1f} km · +{extra} min · "
+    return (f"Option {i + 1} · {alt.discovery.distance_m / 1000:.1f} km · +{extra} min · "
             f"{len(alt.pois)} stops ({flavor})")
 
 
-def on_plan(start, dest, mode, budget, vibe, adventurousness,
-            prefer_green, prefer_quiet, profile, progress=gr.Progress()):
-    progress(0.1, desc="Reading your vibe…")
+@app.api(name="suggest")
+def suggest(query: str = "") -> list:
+    """Autocomplete Start/Destination from the local POI-name index."""
+    from discoverroute.routing.geocode import suggest as _suggest
+    typed = (query or "").strip()
+    matches = list(_suggest(typed))
+    if typed and typed not in matches:
+        matches = [typed] + matches
+    return matches or ([typed] if typed else [])
+
+
+@app.api(name="plan")
+def plan(start: str, dest: str, mode: str = "walk", budget: float = 0.5,
+         vibe: str = "", adventurousness: float = 0.3,
+         prefer_green: float = 0.0, prefer_quiet: float = 0.0,
+         profile: str = "") -> dict:
+    """Plan a route and return everything the custom frontend renders."""
+    try:
+        profile_obj = json.loads(profile) if profile else {}
+    except Exception:  # noqa: BLE001
+        profile_obj = {}
+
     result = plan_route(
         start_query=start, dest_query=dest, mode=mode, budget=budget, vibe=vibe,
         adventurousness=adventurousness, prefer_green=prefer_green,
-        prefer_quiet=prefer_quiet, profile=profile or {}, n_alternatives=N_ALTERNATIVES,
+        prefer_quiet=prefer_quiet, profile=profile_obj, n_alternatives=N_ALTERNATIVES,
     )
-    progress(0.9, desc="Drawing your wander…")
 
     if result.error:
-        gr.Warning(result.error)
-        return (mapui.empty_map("Hmm — " + result.error.split(".")[0] + "."),
-                gr.update(visible=False), gr.update(visible=False),
-                gr.update(choices=[], visible=False),
-                "", "", "", {"items": []}, [])
+        return {
+            "error": result.error,
+            "map_html": mapui.empty_map("Hmm — " + result.error.split(".")[0] + "."),
+        }
 
     alts = result.alternatives or []
-    if not alts:  # honest no-detour (or budget 0 → plain route): design's stump state
-        html = mapui.render_routes(plain=result.plain, start=result.start, end=result.end)
-        return (html,
-                gr.update(visible=True), gr.update(visible=True),
-                gr.update(choices=[], visible=False),
-                result.summary_md, result.interpretation_md, result.itinerary_md,
-                {"items": []}, [])
-
-    items, choices = [], []
+    if not alts:  # honest no-detour (or budget 0): plain route + stump state
+        return {
+            "error": None,
+            "no_detour": True,
+            "map_html": mapui.render_routes(
+                plain=result.plain, start=result.start, end=result.end),
+            "summary_md": result.summary_md,
+            "interpretation_md": result.interpretation_md,
+            "itinerary_md": result.itinerary_md,
+            "nodetour_html": _nodetour_html(),
+            "alternatives": [],
+            "last_cats": [],
+        }
+
+    alternatives = []
     for i, alt in enumerate(alts):
-        html = mapui.render_routes(plain=result.plain, discovery=alt.discovery,
-                                   pois=alt.pois, start=result.start, end=result.end)
-        choices.append(_alt_label(i, alt, result.plain))
-        items.append({"map": html, "summary": alt.summary_md,
-                      "itinerary": alt.itinerary_md})
-
-    first = items[0]
-    return (first["map"],
-            gr.update(visible=True), gr.update(visible=False),
-            gr.update(choices=choices, value=choices[0], visible=len(choices) > 1),
-            first["summary"], result.interpretation_md, first["itinerary"],
-            {"choices": choices, "items": items},
-            [p.category for p in alts[0].pois])
-
-
-def on_select_alt(choice, state):
-    items = (state or {}).get("items") or []
-    choices = (state or {}).get("choices") or []
-    if not items or choice not in choices:
-        return gr.update(), gr.update(), gr.update()
-    it = items[choices.index(choice)]
-    return it["map"], it["summary"], it["itinerary"]
-
+        alternatives.append({
+            "label": _alt_label(i, alt, result.plain),
+            "map_html": mapui.render_routes(
+                plain=result.plain, discovery=alt.discovery, pois=alt.pois,
+                start=result.start, end=result.end),
+            "summary_md": alt.summary_md,
+            "itinerary_md": alt.itinerary_md,
+        })
 
-def on_save_places(profile, last_cats):
-    profile = dict(profile or {"standing_text": "", "saved_categories": []})
-    if not last_cats:
-        gr.Warning("Plan a route first — then I can save its places to your taste.")
-        return profile, _saved_md(profile)
-    profile["saved_categories"] = (profile.get("saved_categories") or []) + list(last_cats)
-    gr.Info("Saved this route's places to your taste ✨")
-    return profile, _saved_md(profile)
+    return {
+        "error": None,
+        "no_detour": False,
+        "interpretation_md": result.interpretation_md,
+        "alternatives": alternatives,
+        "last_cats": [p.category for p in alts[0].pois],
+    }
 
 
-def on_save_prefs(standing_text, profile):
-    profile = dict(profile or {"standing_text": "", "saved_categories": []})
-    profile["standing_text"] = standing_text or ""
-    gr.Info("Saved your standing preferences ✨")
-    return profile, _saved_md(profile)
+def _nodetour_html() -> str:
+    from discoverroute.ui import design
+    return design.NO_DETOUR_HTML
 
 
-def on_clear_profile():
-    gr.Info("Profile cleared 🧹")
-    empty = {"standing_text": "", "saved_categories": []}
-    return empty, "", _saved_md(empty)
+@app.get("/", response_class=HTMLResponse)
+def homepage() -> str:
+    return shell.index_html()
 
 
-def on_suggest(evt: gr.KeyUpData):
-    """Autocomplete a Start/Destination field from the local POI-name index."""
-    from discoverroute.routing.geocode import suggest
-    typed = evt.input_value or ""
-    matches = list(suggest(typed))
-    # keep what the user typed selectable on top; never clobber their text
-    choices = ([typed] if typed and typed not in matches else []) + matches
-    return gr.update(choices=choices or [typed])
-
-
-def show_loading():
-    """Instant feedback the moment Plan is clicked (the .then chain computes)."""
-    return (design.LOADING_HTML, gr.update(visible=False),
-            gr.update(visible=False), gr.update(visible=False))
-
-
-def build_ui() -> gr.Blocks:
-    with gr.Blocks(title="DiscoverRoute · Paris") as demo:
-        profile = gr.BrowserState(
-            {"standing_text": "", "saved_categories": []},
-            storage_key="discoverroute_profile",
-        )
-        alts_state = gr.State({"items": []})
-        last_cats = gr.State([])
-
-        gr.HTML(design.DR_HERO, elem_id="dr-hero")
-
-        with gr.Row(equal_height=False):
-            # ---- LEFT: controls --------------------------------------------
-            with gr.Column(scale=4, min_width=340):
-                with gr.Group():
-                    start = gr.Dropdown(
-                        label="Start", elem_id="dr-start", elem_classes="dr-field",
-                        info="Type a Paris place — suggestions appear as you type",
-                        value="Place de la République, Paris",
-                        choices=["Place de la République, Paris"],
-                        allow_custom_value=True, filterable=True)
-                    dest = gr.Dropdown(
-                        label="Destination", elem_id="dr-dest", elem_classes="dr-field",
-                        value="Jardin du Luxembourg, Paris",
-                        choices=["Jardin du Luxembourg, Paris"],
-                        allow_custom_value=True, filterable=True)
-                    vibe = gr.Textbox(label="Vibe (free text)", elem_id="dr-vibe",
-                                      elem_classes="dr-field",
-                                      info="e.g. 'quiet green wander' or 'lively café crawl'")
-                mode = gr.Radio(choices=["walk", "bike"], value=config.DEFAULT_MODE,
-                                label="Mode", elem_id="dr-mode", elem_classes="dr-seg")
-                budget = gr.Slider(0.0, config.MAX_BUDGET, value=config.DEFAULT_BUDGET,
-                                   step=0.1, label="Detour budget",
-                                   elem_id="dr-budget", elem_classes="dr-slider",
-                                   info="Extra time vs. the direct trip — 0 = straight there, 1 = up to 2× longer")
-                adventurousness = gr.Slider(
-                    0.0, 1.0, value=config.DEFAULT_ADVENTUROUSNESS, step=0.05,
-                    label="Adventurousness", elem_id="dr-adv", elem_classes="dr-slider",
-                    info="Low = well-known places · high = hidden gems")
-                with gr.Accordion("Manual taste (used only when Vibe and saved profile are both empty)",
-                                  open=False, elem_id="dr-manual", elem_classes="dr-collapse"):
-                    prefer_green = gr.Slider(0.0, 1.0, value=0.5, step=0.05,
-                                             label="Prefer green", elem_id="dr-green",
-                                             elem_classes=["dr-slider", "green"])
-                    prefer_quiet = gr.Slider(0.0, 1.0, value=0.5, step=0.05,
-                                             label="Prefer quiet", elem_id="dr-quiet",
-                                             elem_classes=["dr-slider", "green"])
-                go = gr.Button("Plan route", variant="primary", size="lg",
-                               elem_id="dr-plan")
-                with gr.Accordion("⭐ My taste profile (saved on this device)",
-                                  open=False, elem_id="dr-profile", elem_classes="dr-collapse"):
-                    standing = gr.Textbox(
-                        label="Standing preferences", lines=3, elem_id="dr-profile-text",
-                        info="e.g. 'I always love bookshops, gardens, and old churches'")
-                    with gr.Row():
-                        save_prefs_btn = gr.Button("Save", size="sm", elem_id="dr-save")
-                        clear_btn = gr.Button("Clear", size="sm", variant="secondary",
-                                              elem_id="dr-clear")
-                    saved_display = gr.Markdown(_saved_md({}), elem_id="dr-saved",
-                                                elem_classes="dr-note")
-                    save_places_btn = gr.Button("⭐ Save this route's places",
-                                                elem_id="dr-save-places",
-                                                elem_classes="dr-star")
-
-            # ---- RIGHT: results --------------------------------------------
-            with gr.Column(scale=7, min_width=440, elem_id="dr-results"):
-                alt_radio = gr.Radio(choices=[], label="Route options", visible=False,
-                                     elem_id="dr-options", elem_classes="dr-cards")
-                map_out = gr.HTML(mapui.empty_map(), elem_id="dr-map")
-                with gr.Group(visible=False) as results_grp:
-                    summary_out = gr.Markdown(elem_id="dr-summary")
-                    interpretation_out = gr.Markdown(elem_id="dr-interp",
-                                                     elem_classes="dr-tags")
-                    itinerary_out = gr.Markdown(elem_id="dr-itin")
-                nodetour_html = gr.HTML(design.NO_DETOUR_HTML, visible=False,
-                                        elem_id="dr-nodetour")
-
-        # Cosmetic map-press bounce. Gradio feeds an event's `js` return value
-        # back as the inputs to its `fn`; a side-effect-only js (returns
-        # undefined) attached to the data event corrupts on_plan's inputs and
-        # white-screens the frontend. So keep the animation on its own fn-less
-        # listener, where its return value is harmless.
-        go.click(None, js=design.DR_CELEBRATE)
-        # Loading state first (instant), then the actual planning overwrites it.
-        go.click(
-            show_loading,
-            outputs=[map_out, results_grp, nodetour_html, alt_radio],
-            show_progress="hidden",
-        ).then(
-            on_plan,
-            inputs=[start, dest, mode, budget, vibe, adventurousness,
-                    prefer_green, prefer_quiet, profile],
-            outputs=[map_out, results_grp, nodetour_html, alt_radio,
-                     summary_out, interpretation_out, itinerary_out,
-                     alts_state, last_cats],
-            show_progress="minimal",
-        )
-        # Autocomplete Start/Destination from the local POI-name index.
-        for _field in (start, dest):
-            _field.key_up(on_suggest, outputs=[_field], show_progress="hidden")
-        alt_radio.change(on_select_alt, inputs=[alt_radio, alts_state],
-                         outputs=[map_out, summary_out, itinerary_out])
-        save_places_btn.click(on_save_places, inputs=[profile, last_cats],
-                              outputs=[profile, saved_display])
-        save_prefs_btn.click(on_save_prefs, inputs=[standing, profile],
-                             outputs=[profile, saved_display])
-        clear_btn.click(on_clear_profile, outputs=[profile, standing, saved_display])
-
-        demo.load(lambda p: (p.get("standing_text", ""), _saved_md(p)),
-                  inputs=[profile], outputs=[standing, saved_display])
-    return demo
-
-
-def warmup():
-    """Preload graph + CSR + POIs + the vibe embedder at boot so the first
-    request is fast (~1s) instead of paying the torch/model load lazily."""
+def warmup() -> None:
+    """Preload graph + CSR + POIs + the vibe embedder so the first request is fast."""
     try:
         from discoverroute.routing import graph as g
         from discoverroute.routing import pois as poimod
@@ -255,7 +124,7 @@ def warmup():
         print(f"[warmup] graph FAILED: {exc}", flush=True)
     try:
         from discoverroute.interpret import embed
-        embed.vibe_to_affinity("quiet green wander")  # loads model + gloss cache
+        embed.vibe_to_affinity("quiet green wander")
         print("[warmup] vibe embedder ready", flush=True)
     except Exception as exc:  # noqa: BLE001
         print(f"[warmup] embedder skipped: {exc}", flush=True)
@@ -263,8 +132,7 @@ def warmup():
 
 if __name__ == "__main__":
     warmup()
-    build_ui().queue(default_concurrency_limit=4).launch(
-        theme=design.build_theme(),
-        css=design.DR_CSS,
-        head=design.DR_HEAD,
-    )
+    # _frontend=False: do NOT mount Gradio's default SPA at "/", so our custom
+    # app-shell route (@app.get("/")) wins. The @app.api endpoints + @gradio/client
+    # queue still work (that's the API engine, independent of the default UI).
+    app.launch(show_error=True, _frontend=False)

requirements.txt

@@ -10,8 +10,8 @@ scikit-learn==1.9.0
 pyarrow==24.0.0
 folium==0.20.0
 
-# UI
-gradio==6.17.3
+# UI — 6.18 introduces gradio.Server (custom-frontend app-shell; see app.py)
+gradio==6.18.0
 
 # Vibe interpretation (Brick 4) — fastembed (ONNX, no torch) is the primary
 # backend; sentence-transformers remains as fallback.

src/discoverroute/config.py

@@ -4,6 +4,7 @@ Everything tunable lives here so behaviour is inspectable, not scattered.
 """
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 # --- Paths -------------------------------------------------------------------
@@ -66,8 +67,20 @@ def corridor_halfwidth_m(budget: float) -> float:
 EMBED_MODEL = "BAAI/bge-small-en-v1.5"
 # bge-v1.5 retrieval instruction, prepended to the query (the vibe) only.
 EMBED_QUERY_INSTRUCTION = "Represent this sentence for searching relevant passages: "
-# Generative model for posture interpretation + narration (optional; ≤32B, ZeroGPU).
-LLM_MODEL = "Qwen/Qwen3.5-9B"
+# Generative model for vibe→weights extraction + narration. A 1B in-Space model
+# (Tiny Titan ≤4B; weights pulled from the Hub and run on ZeroGPU). Standard
+# LlamaForCausalLM architecture — no custom kernels.
+LLM_MODEL = "openbmb/MiniCPM5-1B"
+
+# --- Trace logging (Open Trace) ----------------------------------------------
+# Every inference call logs a row locally to logs/traces.jsonl; when a write
+# token is present, rows are ALSO pushed (async, non-blocking) to TRACE_REPO.
+# No token => local-only (graceful stub; nothing blocks).
+HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+TRACE_REPO = os.environ.get(
+    "DISCOVERROUTE_TRACE_REPO", "build-small-hackathon/discoverroute-traces"
+)
+
 # Affinity floor: the least-matching category still keeps this much interest so
 # the route can explore a little; the best-matching category maps to 1.0.
 AFFINITY_FLOOR = 0.15

src/discoverroute/enrich/__init__.py

@@ -1 +0,0 @@
-"""Pluggable live-enrichment sources (spec P2-2). Optional; never required."""

src/discoverroute/enrich/google_places.py

@@ -1,87 +0,0 @@
-"""Optional live verification of the FINAL selected stops via Google Places.
-
-Design constraints (and why this module looks the way it does):
-  * Google's ToS prohibit storing Places content (only place_id is cacheable),
-    so this runs per-request on the ~8 chosen stops only and nothing is
-    persisted. OSM remains the storable base for candidates and routing.
-  * Opening-hours fields bill at the Enterprise SKU (1,000 free events/month
-    => ~125 free routes). Verifying only the final stops keeps cost bounded.
-  * Entirely optional: without ``GOOGLE_MAPS_API_KEY`` in the environment this
-    module is a silent no-op and the app stays fully offline.
-
-Each verified POI gains ``.live_status`` (True=open now, False=closed) and
-``.live_rating`` — consumed by the narration template's badges.
-"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import urllib.request
-from concurrent.futures import ThreadPoolExecutor
-
-logger = logging.getLogger("discoverroute")
-
-_ENDPOINT = "https://places.googleapis.com/v1/places:searchText"
-_FIELDS = ("places.id,places.displayName,places.businessStatus,"
-           "places.currentOpeningHours.openNow,places.rating")
-_TIMEOUT_S = 3.0
-_MAX_STOPS = 12
-
-
-def api_key() -> str | None:
-    return os.environ.get("GOOGLE_MAPS_API_KEY") or None
-
-
-def _verify_one(poi, key: str) -> None:
-    """Look up one POI by name near its coordinates; annotate it in place."""
-    name = getattr(poi, "name", None)
-    if not name:
-        return
-    body = json.dumps({
-        "textQuery": name,
-        "locationBias": {"circle": {
-            "center": {"latitude": poi.lat, "longitude": poi.lon},
-            "radius": 150.0,
-        }},
-        "maxResultCount": 1,
-    }).encode()
-    req = urllib.request.Request(
-        _ENDPOINT, data=body, method="POST",
-        headers={
-            "Content-Type": "application/json",
-            "X-Goog-Api-Key": key,
-            "X-Goog-FieldMask": _FIELDS,
-        },
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=_TIMEOUT_S) as resp:
-            data = json.loads(resp.read().decode())
-    except Exception as exc:  # noqa: BLE001 - enrichment must never break a route
-        logger.warning("google verify failed for %r: %s: %s",
-                       name, type(exc).__name__, exc)
-        return
-    places = data.get("places") or []
-    if not places:
-        return
-    place = places[0]
-    if place.get("businessStatus") == "CLOSED_PERMANENTLY":
-        poi.live_status = False
-        return
-    open_now = (place.get("currentOpeningHours") or {}).get("openNow")
-    if open_now is not None:
-        poi.live_status = bool(open_now)
-    rating = place.get("rating")
-    if rating is not None:
-        poi.live_rating = float(rating)
-
-
-def verify_stops(pois: list) -> bool:
-    """Live-verify up to _MAX_STOPS POIs in parallel. Returns True if any ran."""
-    key = api_key()
-    if not key or not pois:
-        return False
-    batch = pois[:_MAX_STOPS]
-    with ThreadPoolExecutor(max_workers=4) as pool:
-        list(pool.map(lambda p: _verify_one(p, key), batch))
-    return True

src/discoverroute/interpret/affinity.py

@@ -0,0 +1,59 @@
+"""Resolve a free-text vibe into category affinity, with graceful fallbacks.
+
+Single entry point for "vibe → affinity over the taxonomy". Tiers, best first:
+
+  1. MiniCPM5-1B Call 1 (``llm_vibe.extract``) — when a GPU is present in-Space.
+  2. bge-small embeddings (``embed.vibe_to_affinity``) — CPU, no model download
+     beyond the small encoder; the strictly-better-than-keywords middle tier.
+  3. Keyword matcher (``keywords.keyword_affinity``) — instant, model-free net.
+  4. Neutral — equal interest in everything.
+
+Every tier returns the same floored ``{category: affinity}`` shape, so the
+routing engine (and the ``Weights`` struct) is oblivious to which one ran.
+"""
+from __future__ import annotations
+
+import functools
+
+from discoverroute.data import taxonomy
+
+
+def _neutral() -> dict[str, float]:
+    return {c: 1.0 for c in taxonomy.CATEGORIES}
+
+
+@functools.lru_cache(maxsize=256)
+def resolve_affinity(vibe: str) -> tuple[dict[str, float], str]:
+    """Return ``(affinity, source)`` where source ∈ {llm, embed, keyword, neutral}."""
+    vibe = (vibe or "").strip()
+    if not vibe:
+        return _neutral(), "neutral"
+
+    # tier 1 — LLM extraction (in-Space GPU only)
+    from discoverroute.interpret import llm_vibe
+    result = llm_vibe.extract(vibe)
+    if result:
+        return result["affinity"], "llm"
+
+    # tier 2 — sentence embeddings (CPU)
+    try:
+        from discoverroute.interpret import embed
+        return embed.vibe_to_affinity(vibe), "embed"
+    except Exception:  # noqa: BLE001 - encoder unavailable → keyword net
+        pass
+
+    # tier 3 — keyword matcher (model-free)
+    from discoverroute.interpret import keywords
+    kw = keywords.keyword_affinity(vibe)
+    if kw:
+        return kw, "keyword"
+
+    return _neutral(), "neutral"
+
+
+def affinity_only(vibe: str) -> dict[str, float]:
+    return resolve_affinity(vibe)[0]
+
+
+def source_of(vibe: str) -> str:
+    return resolve_affinity(vibe)[1]

src/discoverroute/interpret/keywords.py

@@ -0,0 +1,84 @@
+"""Model-free keyword vibe matcher — the always-available safety net.
+
+When Call 1 (the LLM vibe→weights extractor) is unavailable or returns malformed
+JSON, this runs instantly with no model: it scans the vibe text for known cues,
+unions and averages the matched brief-key weight dicts, and hands the result to
+:func:`mapping.brief_scores_to_affinity`. Returns ``None`` when nothing matches,
+so the caller can fall through to a neutral (equal-interest) reading.
+"""
+from __future__ import annotations
+
+from discoverroute.interpret import mapping
+
+# substring cue -> brief-key scores (category keys + quiet/green/busy modifiers).
+KEYWORD_WEIGHTS: dict[str, dict[str, float]] = {
+    "quiet": {"quiet": 0.9, "busy": 0.1, "park": 0.6},
+    "calm": {"quiet": 0.85, "park": 0.5},
+    "peace": {"quiet": 0.85, "park": 0.5},
+    "coffee": {"cafe": 0.9, "bakery": 0.7},
+    "café": {"cafe": 0.9, "bakery": 0.6},
+    "cafe": {"cafe": 0.9, "bakery": 0.6},
+    "espresso": {"cafe": 0.9},
+    "book": {"bookshop": 0.95},
+    "librair": {"bookshop": 0.8},  # libraire / librairie
+    "read": {"bookshop": 0.7, "quiet": 0.5},
+    "green": {"park": 0.9, "green": 0.85},
+    "park": {"park": 0.9, "green": 0.8},
+    "garden": {"park": 0.9, "green": 0.85},
+    "nature": {"park": 0.85, "green": 0.8},
+    "water": {"park": 0.6, "viewpoint": 0.6, "green": 0.4},
+    "river": {"viewpoint": 0.7, "green": 0.4},
+    "canal": {"viewpoint": 0.7, "green": 0.4},
+    "histor": {"museum": 0.7, "historic": 0.9},
+    "herit": {"historic": 0.9},
+    "old": {"historic": 0.7},
+    "church": {"historic": 0.8, "quiet": 0.6},
+    "museum": {"museum": 0.9, "historic": 0.5},
+    "art": {"museum": 0.85},
+    "galler": {"museum": 0.85},
+    "view": {"viewpoint": 0.9},
+    "panoram": {"viewpoint": 0.9},
+    "scenic": {"viewpoint": 0.8, "green": 0.5},
+    "food": {"restaurant": 0.8, "market": 0.7, "bakery": 0.6},
+    "eat": {"restaurant": 0.8, "bakery": 0.5},
+    "lunch": {"restaurant": 0.8, "cafe": 0.5},
+    "dinner": {"restaurant": 0.85},
+    "bakery": {"bakery": 0.9},
+    "pastr": {"bakery": 0.9},
+    "market": {"market": 0.9},
+    "shop": {"market": 0.7},
+    "bar": {"bar": 0.85, "busy": 0.5},
+    "pub": {"bar": 0.85, "busy": 0.5},
+    "drink": {"bar": 0.8},
+    "wine": {"bar": 0.8},
+    "lively": {"busy": 0.9, "bar": 0.6, "market": 0.6},
+    "busy": {"busy": 0.9, "market": 0.6},
+    "bustl": {"busy": 0.85, "market": 0.7},
+}
+
+
+def keyword_scores(vibe: str) -> dict[str, float] | None:
+    """Union + average the brief-key scores of every cue found in ``vibe``."""
+    text = (vibe or "").lower()
+    if not text:
+        return None
+    sums: dict[str, float] = {}
+    counts: dict[str, int] = {}
+    matched = False
+    for cue, weights in KEYWORD_WEIGHTS.items():
+        if cue in text:
+            matched = True
+            for key, val in weights.items():
+                sums[key] = sums.get(key, 0.0) + val
+                counts[key] = counts.get(key, 0) + 1
+    if not matched:
+        return None
+    return {key: sums[key] / counts[key] for key in sums}
+
+
+def keyword_affinity(vibe: str) -> dict[str, float] | None:
+    """Keyword scores mapped to a taxonomy affinity dict, or ``None``."""
+    scores = keyword_scores(vibe)
+    if not scores:
+        return None
+    return mapping.brief_scores_to_affinity(scores)

src/discoverroute/interpret/llm_vibe.py

@@ -0,0 +1,117 @@
+"""Call 1 — vibe → routing weights via MiniCPM5-1B (JSON-only, lean).
+
+Asks the in-Space 1B model for a small fixed-schema JSON of preference weights,
+validates it hard, and maps it onto the taxonomy affinity the router consumes.
+Any failure — model absent (off-GPU), invalid JSON, or missing keys — returns
+``None`` so the caller falls back to the keyword matcher. Every attempt is
+traced (``used_fallback=True`` when the model's output is rejected).
+"""
+from __future__ import annotations
+
+import functools
+import json
+import re
+import time
+
+from discoverroute.interpret import mapping
+
+SYSTEM_PROMPT = (
+    "You are a routing preference extractor.\n"
+    "Output ONLY valid JSON. No prose, no explanation, no markdown.\n"
+    'Schema: {"cafe": 0.0-1.0, "park": 0.0-1.0, "bookshop": 0.0-1.0, '
+    '"museum": 0.0-1.0, "bakery": 0.0-1.0, "restaurant": 0.0-1.0, '
+    '"bar": 0.0-1.0, "viewpoint": 0.0-1.0, "market": 0.0-1.0, '
+    '"quiet": 0.0-1.0, "green": 0.0-1.0, "historic": 0.0-1.0, '
+    '"busy": 0.0-1.0, "detour_budget_multiplier": 0.5-2.0}\n'
+    "All keys required. Values reflect how strongly the vibe matches each."
+)
+
+REQUIRED_KEYS = (
+    "cafe", "park", "bookshop", "museum", "bakery", "restaurant", "bar",
+    "viewpoint", "market", "quiet", "green", "historic", "busy",
+    "detour_budget_multiplier",
+)
+
+
+def _extract_json(text: str) -> dict | None:
+    """Pull the first balanced JSON object out of a model response."""
+    if not text:
+        return None
+    # strip code fences if present
+    text = re.sub(r"^```(?:json)?|```$", "", text.strip(), flags=re.MULTILINE)
+    start = text.find("{")
+    if start < 0:
+        return None
+    depth = 0
+    for i in range(start, len(text)):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[start:i + 1])
+                except Exception:  # noqa: BLE001
+                    return None
+    return None
+
+
+def _validate(obj: dict | None) -> dict | None:
+    """Require all keys present and numeric; coerce to floats. Else None."""
+    if not isinstance(obj, dict):
+        return None
+    out: dict[str, float] = {}
+    for key in REQUIRED_KEYS:
+        if key not in obj:
+            return None
+        try:
+            out[key] = float(obj[key])
+        except (TypeError, ValueError):
+            return None
+    return out
+
+
+@functools.lru_cache(maxsize=256)
+def extract(vibe: str) -> dict | None:
+    """Return ``{"affinity", "budget_multiplier", "raw"}`` or ``None``.
+
+    ``None`` means "use the fallback": either the model is unavailable
+    (off-GPU) or it produced output that failed validation.
+    """
+    vibe = (vibe or "").strip()
+    if not vibe:
+        return None
+
+    from discoverroute.narrate import narrate as _narrate  # lazy: llm_available()
+    from discoverroute.narrate import trace
+
+    if not _narrate.llm_available():
+        return None  # off-GPU: skip straight to the fallback (no trace noise)
+
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"Extract routing weights for this vibe: {vibe}"},
+    ]
+    t0 = time.time()
+    try:
+        from discoverroute.narrate.llm import run_inference
+        raw_text = run_inference(messages, max_new_tokens=160, temperature=0.2)
+    except Exception as exc:  # noqa: BLE001 - never break interpretation
+        latency = int((time.time() - t0) * 1000)
+        trace.log_trace("vibe_extraction", {"vibe": vibe},
+                        {"error": f"{type(exc).__name__}: {exc}"},
+                        latency, used_fallback=True)
+        return None
+
+    latency = int((time.time() - t0) * 1000)
+    parsed = _validate(_extract_json(raw_text))
+    if parsed is None:
+        trace.log_trace("vibe_extraction", {"vibe": vibe},
+                        {"raw": raw_text}, latency, used_fallback=True)
+        return None
+
+    affinity = mapping.brief_scores_to_affinity(parsed)
+    budget_mult = max(0.5, min(2.0, parsed["detour_budget_multiplier"]))
+    trace.log_trace("vibe_extraction", {"vibe": vibe}, parsed,
+                    latency, used_fallback=False)
+    return {"affinity": affinity, "budget_multiplier": budget_mult, "raw": parsed}

src/discoverroute/interpret/mapping.py

@@ -0,0 +1,68 @@
+"""Bridge the LLM/keyword "brief keys" to the taxonomy's category affinity.
+
+Call 1 (vibe→weights) and the keyword fallback both speak a small, human set of
+keys — ``cafe, park, bookshop, museum, bakery, restaurant, bar, viewpoint,
+market, historic`` (category keys) plus ``quiet, green, busy`` (modifiers). The
+routing engine, however, scores over the 17-category :mod:`taxonomy` vocabulary
+via the ``Weights.category_affinity`` dict. This module is the single, dependency
+-light translator between the two, so both producers stay consistent.
+"""
+from __future__ import annotations
+
+from discoverroute import config
+from discoverroute.data import taxonomy
+
+# brief category-key -> taxonomy categories it directly expresses interest in.
+CATEGORY_KEYS: dict[str, list[str]] = {
+    "cafe": ["cafe"],
+    "park": ["park_garden"],
+    "bookshop": ["bookshop", "library"],
+    "museum": ["museum_gallery", "theatre_cinema", "artwork"],
+    "bakery": ["bakery_food_shop"],
+    "restaurant": ["restaurant"],
+    "bar": ["bar_pub"],
+    "viewpoint": ["viewpoint", "attraction"],
+    "market": ["market", "specialty_shop"],
+    "historic": ["monument_historic", "place_of_worship"],
+}
+
+# Modifier keys shape every category via its intrinsic priors (not 1:1 to a
+# category): green→greenness, quiet→quietness, busy→liveliness (1−quietness).
+MODIFIER_KEYS = ("green", "quiet", "busy")
+
+# Inverted: taxonomy category -> the brief category-keys that target it.
+_KEYS_FOR_CATEGORY: dict[str, list[str]] = {}
+for _key, _cats in CATEGORY_KEYS.items():
+    for _c in _cats:
+        _KEYS_FOR_CATEGORY.setdefault(_c, []).append(_key)
+
+# All keys a producer is expected to emit (category keys + modifiers).
+BRIEF_KEYS: tuple[str, ...] = tuple(CATEGORY_KEYS) + MODIFIER_KEYS
+
+
+def brief_scores_to_affinity(scores: dict[str, float]) -> dict[str, float]:
+    """Map brief-key scores → a floored affinity over every taxonomy category.
+
+    Each category takes the strongest signal among: its direct category-key
+    score, and the modifier contributions (green·greenness, quiet·quietness,
+    busy·liveliness). The top category is scaled to 1.0 and the rest floored to
+    ``AFFINITY_FLOOR`` — the same shape :func:`embed.vibe_to_affinity` returns,
+    so the routing engine cannot tell which producer ran.
+    """
+    green = float(scores.get("green", 0.0) or 0.0)
+    quiet = float(scores.get("quiet", 0.0) or 0.0)
+    busy = float(scores.get("busy", 0.0) or 0.0)
+
+    raw: dict[str, float] = {}
+    for cat in taxonomy.CATEGORIES:
+        contribs = [0.0]
+        for key in _KEYS_FOR_CATEGORY.get(cat, []):
+            contribs.append(float(scores.get(key, 0.0) or 0.0))
+        contribs.append(green * taxonomy.greenness(cat))
+        contribs.append(quiet * taxonomy.quietness(cat))
+        contribs.append(busy * (1.0 - taxonomy.quietness(cat)))
+        raw[cat] = max(contribs)
+
+    hi = max(raw.values()) or 1.0
+    floor = config.AFFINITY_FLOOR
+    return {c: floor + (1.0 - floor) * (v / hi) for c, v in raw.items()}

src/discoverroute/interpret/profile.py

@@ -63,8 +63,8 @@ def effective_weights(profile: dict, trip_vibe: str = "",
     prof = profile_affinity(profile)
     trip = None
     if (trip_vibe or "").strip():
-        from discoverroute.interpret import embed
-        trip = embed.vibe_to_affinity(trip_vibe)
+        from discoverroute.interpret.affinity import affinity_only
+        trip = affinity_only(trip_vibe)
 
     if prof is None and trip is None:
         affinity = {c: 1.0 for c in taxonomy.CATEGORIES}

src/discoverroute/interpret/vibe.py

@@ -45,10 +45,10 @@ def _contains(text: str, cues) -> bool:
 
 def interpret(vibe: str, adventurousness: float = config.DEFAULT_ADVENTUROUSNESS,
               budget: float | None = None) -> Interpretation:
-    from discoverroute.interpret import embed  # lazy: avoids loading the model unless used
+    from discoverroute.interpret.affinity import resolve_affinity  # lazy: model only if used
 
     text = (vibe or "").strip().lower()
-    affinity = embed.vibe_to_affinity(vibe)
+    affinity, _source = resolve_affinity(vibe)
     weights = Weights(category_affinity=affinity, w_category=1.0)
 
     # (b) posture: start from category defaults, then let the mood tilt it.

src/discoverroute/narrate/llm.py

@@ -1,8 +1,10 @@
-"""Lazy Qwen3.5-9B client for narration/posture (≤32B, ZeroGPU).
+"""Lazy MiniCPM5-1B client (Tiny Titan ≤4B, in-Space ZeroGPU).
 
-Loaded only when narration explicitly enables the LLM (GPU present). Runs with
-thinking disabled for fast, direct itinerary text. Kept isolated so importing the
-rest of the app never pulls in the model.
+One model serves both inference calls — vibe→weights extraction and route
+narration — so the weights load once and are reused. Standard LlamaForCausalLM
+(no custom kernels). Loaded only when a GPU is present (off-Space the
+``@spaces.GPU`` decorator is an identity no-op, and callers fall back), so
+importing the rest of the app never pulls in torch/transformers.
 """
 from __future__ import annotations
 
@@ -19,29 +21,33 @@ except Exception:  # noqa: BLE001 - not on a Space / package absent
 
 
 @functools.lru_cache(maxsize=1)
-def _pipe():
+def _load():
+    """Load (tokenizer, model) once. MiniCPM5-1B → fp16, device_map=auto."""
     import torch
     from transformers import AutoModelForCausalLM, AutoTokenizer
 
-    tok = AutoTokenizer.from_pretrained(config.LLM_MODEL)
+    tok = AutoTokenizer.from_pretrained(config.LLM_MODEL, trust_remote_code=True)
     model = AutoModelForCausalLM.from_pretrained(
-        config.LLM_MODEL, torch_dtype="auto", device_map="auto"
+        config.LLM_MODEL,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True,
     )
     return tok, model
 
 
 @_gpu
-def generate(prompt: str, max_new_tokens: int = 320) -> str:
-    tok, model = _pipe()
-    messages = [{"role": "user", "content": prompt}]
+def run_inference(messages: list[dict], max_new_tokens: int = 320,
+                  temperature: float = 0.7) -> str:
+    """Run a chat completion. ``messages`` = [{"role","content"}, ...]."""
+    tok, model = _load()
     text = tok.apply_chat_template(
-        messages, tokenize=False, add_generation_prompt=True,
-        enable_thinking=False,  # Qwen3.5: direct answer, no <think> block
+        messages, tokenize=False, add_generation_prompt=True
     )
     inputs = tok([text], return_tensors="pt").to(model.device)
     out = model.generate(
         **inputs, max_new_tokens=max_new_tokens,
-        temperature=0.7, top_p=0.8, top_k=20, do_sample=True,
+        temperature=temperature, top_p=0.8, top_k=20, do_sample=True,
     )
     gen = out[0][inputs.input_ids.shape[1]:]
     return tok.decode(gen, skip_special_tokens=True).strip()

src/discoverroute/narrate/narrate.py

@@ -3,7 +3,7 @@
 Two generators behind one gate:
   * a deterministic **template** — grounded by construction (only ever inserts
     real waypoint names + the start/end labels), the safe default; and
-  * an optional **LLM** (Qwen3.5-9B) that adds voice, used only when it runs
+  * an optional **LLM** (MiniCPM5-1B) that adds voice, used only when it runs
     (GPU/Space) and only if its output passes the zero-hallucination gate.
 
 ``narrate`` always returns text that passes ``verify_grounded`` — the LLM is a
@@ -13,7 +13,6 @@ from __future__ import annotations
 
 import os
 
-from discoverroute import config
 from discoverroute.narrate import grounding
 
 # Phrasing per category for the template. Generic (no external facts) so the only
@@ -61,11 +60,8 @@ def template_narration(plain, discovery, pois, vibe, mode, start_label="",
         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)
-        live = getattr(p, "live_status", None)  # Google-verified, when present
-        if live is not None:
-            badge = " · 🟢 open now ✓live" if live else " · 🔴 closed right now ✓live"
-        elif state is True:
+        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"
@@ -98,7 +94,7 @@ def llm_available() -> bool:
 
 
 def narrate(plain, discovery, pois, vibe="", mode="walk", start_label="",
-            end_label="", posture=None) -> tuple[str, bool]:
+            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
@@ -106,36 +102,73 @@ def narrate(plain, discovery, pois, vibe="", mode="walk", start_label="",
     if not llm_available():
         return template, False
 
+    import time
+
+    from discoverroute.narrate import trace
+
+    meta = {"vibe": vibe, "mode": mode, "n_stops": len(pois)}
+    t0 = time.time()
     try:
-        text = _llm_narration(plain, discovery, pois, vibe, mode, start_label, end_label)
+        text = _llm_narration(plain, discovery, pois, vibe, mode,
+                              start_label, end_label, weights)
         ok, offenders = grounding.verify_grounded(text, pois, start_label, end_label)
+        latency = int((time.time() - t0) * 1000)
         if ok and text.strip():
+            trace.log_trace("narration", meta, {"text": text}, latency,
+                            used_fallback=False)
             return text, True
+        trace.log_trace("narration", meta, {"text": text, "offenders": offenders},
+                        latency, used_fallback=True)
         print(f"[narrate] LLM output rejected by grounding gate; offenders={offenders}",
               flush=True)
     except Exception as exc:  # noqa: BLE001 - never let narration break a route
+        trace.log_trace("narration", meta, {"error": f"{type(exc).__name__}: {exc}"},
+                        int((time.time() - t0) * 1000), used_fallback=True)
         print(f"[narrate] LLM failed ({type(exc).__name__}): {exc}", flush=True)
     return template, False  # fail-closed: ship the grounded template
 
 
-def _llm_narration(plain, discovery, pois, vibe, mode, start_label, end_label) -> str:
-    """Generate narration with Qwen3.5-9B, constrained to the allowed names."""
-    from discoverroute.narrate.llm import generate
+def _weights_summary(weights) -> str:
+    """Compact 'cafe 0.9, park 0.7' line from the extracted weights, if any."""
+    aff = getattr(weights, "category_affinity", None)
+    if not aff:
+        return ""
+    top = sorted(aff, key=aff.get, reverse=True)[:5]
+    return ", ".join(f"{c.replace('_', ' ')} {aff[c]:.2f}" for c in top)
+
+
+def _llm_narration(plain, discovery, pois, vibe, mode, start_label, end_label,
+                   weights=None) -> str:
+    """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]
     bullet = "\n".join(
         f"- {n} ({p.category.replace('_', ' ')})" for n, p in zip(names, pois)
     )
     extra = round(discovery.time_min - plain.time_min)
-    prompt = (
-        "You are a warm local guide writing a short itinerary for a "
-        f"{mode} through Paris from {start_label} to {end_label}.\n"
-        f"The traveller's vibe: {vibe or 'open to anything'}.\n"
-        f"The route adds {extra} minutes to pass these real places, in order:\n"
-        f"{bullet}\n\n"
-        "Write 3-5 short sentences. CRITICAL RULES: mention ONLY the place names "
-        "listed above, spelled exactly. Do NOT invent or name any other place, "
-        "landmark, street, or neighbourhood. If unsure, refer to a place by its "
-        "type instead of a name."
+    total_min = round(discovery.time_min + getattr(discovery, "dwell_s", 0.0) / 60.0)
+    weights_line = _weights_summary(weights)
+
+    system = (
+        "You are a Parisian city guide who knows every street. Write a warm, "
+        "specific, first-person itinerary for this walking route. Reference the "
+        "user's stated vibe directly. For each stop, explain in one sentence why "
+        "it matches what they were looking for. Format as markdown with one "
+        "header per stop.\n"
+        "CRITICAL: mention ONLY the place names listed in the prompt, spelled "
+        "exactly. Never invent or name any other place, street, landmark, or "
+        "neighbourhood. If unsure, refer to a place by its type, not a name."
+    )
+    user = (
+        f"Vibe: {vibe or 'open to anything'}\n"
+        + (f"Weights extracted: {weights_line}\n" if weights_line else "")
+        + f"Mode: {mode} from {start_label or 'the start'} to "
+        f"{end_label or 'the destination'}\n"
+        f"Ordered stops:\n{bullet}\n"
+        f"Total time: {total_min} minutes (about {extra} minutes of discovery)\n\n"
+        "Write the itinerary."
     )
-    return generate(prompt, max_new_tokens=320)
+    messages = [{"role": "system", "content": system},
+                {"role": "user", "content": user}]
+    return run_inference(messages, max_new_tokens=600)

src/discoverroute/narrate/trace.py

@@ -0,0 +1,98 @@
+"""Inference trace logging (Open Trace badge).
+
+Every model call — vibe→weights extraction and route narration — emits one JSON
+row. Rows are always appended to ``logs/traces.jsonl`` locally; when a Hugging
+Face write token is present (``HF_TOKEN``), each row is *also* pushed to the
+configured HF Dataset on a daemon thread (non-blocking — the user never waits on
+the write). With no token the push is a silent no-op, so nothing breaks locally.
+
+Both successful calls and fallback activations are logged (``used_fallback``),
+so the dataset reflects exactly what the model did vs. what the safety net did.
+"""
+from __future__ import annotations
+
+import json
+import threading
+from datetime import datetime, timezone
+
+from discoverroute import config
+
+LOG_DIR = config.PROJECT_ROOT / "logs"
+TRACES_PATH = LOG_DIR / "traces.jsonl"
+PLANS_PATH = LOG_DIR / "plans.jsonl"
+
+# Monotonic, process-local counter so concurrently-written HF filenames never
+# collide (datetime alone can repeat under load).
+_seq_lock = threading.Lock()
+_seq = 0
+
+
+def _next_seq() -> int:
+    global _seq
+    with _seq_lock:
+        _seq += 1
+        return _seq
+
+
+def _utcnow_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _append_local(path, row: dict) -> None:
+    try:
+        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        with open(path, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+    except Exception:  # noqa: BLE001 - logging must never break a route
+        pass
+
+
+def _push_hf_async(row: dict, kind: str) -> None:
+    """Best-effort async upload of one row to the trace dataset (token-gated)."""
+    token = config.HF_TOKEN
+    if not token:
+        return  # stub: local-only until a token is provided on the Space
+    seq = _next_seq()
+    stamp = row.get("timestamp", _utcnow_iso()).replace(":", "-")
+
+    def _push() -> None:
+        try:
+            from huggingface_hub import HfApi
+
+            api = HfApi(token=token)
+            api.upload_file(
+                path_or_fileobj=json.dumps(row, ensure_ascii=False).encode("utf-8"),
+                path_in_repo=f"{kind}/{stamp}-{seq:06d}.json",
+                repo_id=config.TRACE_REPO,
+                repo_type="dataset",
+            )
+        except Exception:  # noqa: BLE001 - never surface trace-push failures
+            pass
+
+    threading.Thread(target=_push, daemon=True).start()
+
+
+def log_trace(call_type: str, input_data: dict, output_data: dict,
+              latency_ms: int, used_fallback: bool = False,
+              model: str | None = None) -> dict:
+    """Record one inference call (``vibe_extraction`` or ``narration``)."""
+    row = {
+        "timestamp": _utcnow_iso(),
+        "call_type": call_type,
+        "model": model or config.LLM_MODEL,
+        "input": json.dumps(input_data, ensure_ascii=False),
+        "output": json.dumps(output_data, ensure_ascii=False),
+        "latency_ms": int(latency_ms),
+        "used_fallback": bool(used_fallback),
+    }
+    _append_local(TRACES_PATH, row)
+    _push_hf_async(row, "traces")
+    return row
+
+
+def log_plan(params: dict, summary: dict) -> dict:
+    """Record one end-to-end plan_route call (feeds the Field Notes write-up)."""
+    row = {"timestamp": _utcnow_iso(), "params": params, "summary": summary}
+    _append_local(PLANS_PATH, row)
+    _push_hf_async(row, "plans")
+    return row

src/discoverroute/pipeline.py

@@ -55,6 +55,43 @@ def plan_route(
     prefer_quiet: float = 0.0,
     profile: dict | None = None,
     n_alternatives: int = 1,
+) -> PlanResult:
+    """Plan a route + log one plan-level trace row. Never raises for user errors."""
+    result = _plan_route_impl(
+        start_query, dest_query, mode, budget, vibe, adventurousness,
+        prefer_green, prefer_quiet, profile, n_alternatives,
+    )
+    try:  # one Open-Trace / Field-Notes row per call; never break a route
+        from discoverroute.interpret.affinity import source_of
+        from discoverroute.narrate import trace
+        trace.log_plan(
+            {"start": start_query, "dest": dest_query, "mode": mode,
+             "budget": budget, "vibe": vibe, "adventurousness": adventurousness,
+             "weights_source": source_of(vibe) if (vibe or "").strip()
+             else ("profile" if profile else "manual")},
+            {"error": result.error,
+             "n_pois_selected": len(result.pois),
+             "n_alternatives": len(result.alternatives),
+             "plain_min": round(result.plain.time_min, 1) if result.plain else None,
+             "discovery_min": (round(result.discovery.time_min, 1)
+                               if result.discovery else None)},
+        )
+    except Exception:  # noqa: BLE001
+        pass
+    return result
+
+
+def _plan_route_impl(
+    start_query: str,
+    dest_query: str,
+    mode: str = config.DEFAULT_MODE,
+    budget: float = config.DEFAULT_BUDGET,
+    vibe: str = "",
+    adventurousness: float = config.DEFAULT_ADVENTUROUSNESS,
+    prefer_green: float = 0.0,
+    prefer_quiet: float = 0.0,
+    profile: dict | None = None,
+    n_alternatives: int = 1,
 ) -> PlanResult:
     """Plan a route. Returns a PlanResult; never raises for user-facing errors."""
     try:
@@ -120,13 +157,10 @@ def plan_route(
             if discovery is None or not selected:
                 break
             used_ids.update(p.osm_id for p in selected)
-            # Optional live verification of the chosen stops (no-op without key).
-            from discoverroute.enrich import google_places
-            google_places.verify_stops(selected)
             itinerary_md, _ = narrate(
                 plain, discovery, selected, vibe=vibe, mode=mode,
                 start_label=start_query.strip(), end_label=dest_query.strip(),
-                posture=posture,
+                posture=posture, weights=weights,
             )
             alternatives.append(Alternative(
                 discovery=discovery, pois=selected,

src/discoverroute/ui/shell.py

@@ -0,0 +1,554 @@
+"""Custom app-shell frontend for the ``gradio.Server`` backend.
+
+Off-Brand: instead of Gradio's default column layout, the page is a hand-built
+HTML/CSS/JS app-shell — fixed left control panel · large map · green route-summary
+bar · scrollable itinerary · mobile bottom-drawer — served from ``app.get("/")``
+and talking to ``@app.api`` endpoints through ``@gradio/client``.
+
+Visual identity is preserved by REUSE, not reimplementation: the existing
+:data:`design.DR_CSS` (tokens, sliders, segmented toggle, coral CTA, green summary
+banner, dashed-rail itinerary, framed map window) is injected verbatim and the
+same ``#dr-*`` element ids are kept, so every color/font/treatment carries over.
+Only the spatial layout (``APP_SHELL_CSS``) and the vanilla-JS interactivity
+(autocomplete, localStorage profile, sliders, the 4-step loader) are new.
+"""
+from __future__ import annotations
+
+from discoverroute.ui import design
+from discoverroute.ui import map as mapui
+
+# --------------------------------------------------------------- app-shell CSS
+APP_SHELL_CSS = """
+*{ box-sizing:border-box; }
+html,body{ margin:0; height:100%; }
+body{ font-family:'DM Sans',ui-sans-serif,system-ui,sans-serif; color:var(--dr-ink);
+  background:radial-gradient(1100px 520px at 88% -8%,#FBEFD6 0%,transparent 60%),var(--dr-cream); }
+
+.app-shell{
+  display:grid; grid-template-columns:320px 1fr; grid-template-rows:auto 1fr;
+  height:100vh; width:100%; background:var(--dr-cream);
+}
+
+/* ---- hero (compact ≤120px, content + colors preserved) ---- */
+.hero{ grid-column:1 / -1; grid-row:1; display:flex; align-items:center; gap:18px;
+  background:linear-gradient(120deg,#2F5DF4,#5C7DF8); color:#fff;
+  padding:12px 26px; max-height:120px; overflow:hidden; position:relative; }
+.hero .hero-body{ flex:1; min-width:0; }
+.hero .loc-pill{ display:inline-flex; align-items:center; gap:7px; background:rgba(255,255,255,.16);
+  border-radius:999px; padding:3px 11px; font-family:'Fredoka',sans-serif; font-weight:600;
+  font-size:11.5px; letter-spacing:.04em; }
+.hero .loc-pill .dot{ width:7px;height:7px;border-radius:50%;background:#FFC247; }
+.hero h1{ font-family:'Fredoka',sans-serif; font-weight:700; font-size:28px; letter-spacing:-.02em;
+  margin:5px 0 3px; line-height:1.05; color:#fff; }
+.hero h1 .accent{ color:#FFE0A0; }
+.hero p{ margin:0 0 7px; max-width:62ch; color:#EAF0FF; font-size:13px; line-height:1.3; }
+.hero .badges{ display:flex; flex-wrap:wrap; gap:7px; }
+.hero .badges span{ background:rgba(255,255,255,.13); border-radius:999px; padding:4px 11px;
+  font-size:11.5px; font-family:'Fredoka',sans-serif; font-weight:500; }
+.hero .hero-art{ flex-shrink:0; width:80px; }
+.hero .hero-art svg{ width:80px; height:auto; display:block; }
+.hero .titan-chip{ position:absolute; top:10px; right:18px; background:rgba(255,255,255,.16);
+  border-radius:999px; padding:3px 10px; font-size:10.5px; font-family:'Fredoka',sans-serif;
+  font-weight:600; letter-spacing:.02em; }
+
+/* ---- left control panel (320px, scrollable, sticky CTA) ---- */
+.left-panel{ grid-column:1; grid-row:2; width:320px; height:100%; overflow-y:auto;
+  padding:18px 16px 0; border-right:1px solid rgba(0,0,0,.08); background:var(--dr-cream);
+  display:flex; flex-direction:column; }
+.dr-control{ margin-bottom:13px; }
+.dr-label{ display:block; font-family:'Fredoka',sans-serif; font-weight:600; font-size:13.5px;
+  color:var(--dr-ink); margin-bottom:5px; }
+.dr-help{ font-size:11.5px; color:var(--dr-soft); margin-top:3px; }
+.left-panel input[type=text]{ width:100%; padding:10px 12px; font-size:14px; }
+.combo{ position:relative; }
+.combo-list{ position:absolute; z-index:50; left:0; right:0; top:calc(100% + 3px);
+  background:var(--dr-paper); border:1px solid var(--dr-line); border-radius:14px;
+  box-shadow:0 14px 30px -14px rgba(43,38,32,.4); overflow:hidden; display:none; }
+.combo-list.open{ display:block; }
+.combo-list div{ padding:9px 12px; font-size:13.5px; cursor:pointer; }
+.combo-list div:hover,.combo-list div.active{ background:#F1FAF4; }
+.dr-slider{ display:flex; align-items:center; gap:10px; }
+.dr-slider input[type=range]{ flex:1; }
+.dr-slider output{ font-family:'JetBrains Mono',monospace; font-size:12.5px; color:var(--dr-soft);
+  min-width:30px; text-align:right; }
+details.dr-collapse{ padding:0; margin-bottom:13px; }
+details.dr-collapse summary{ list-style:none; cursor:pointer; padding:11px 14px;
+  font-family:'Fredoka',sans-serif; font-weight:600; font-size:13px; color:var(--dr-ink); }
+details.dr-collapse summary::-webkit-details-marker{ display:none; }
+details.dr-collapse[open] summary{ border-bottom:1.5px dashed var(--dr-line); }
+details.dr-collapse .collapse-body{ padding:12px 14px; }
+.dr-cta-wrap{ position:sticky; bottom:0; padding:12px 0; margin-top:auto;
+  background:linear-gradient(180deg,rgba(246,236,217,0),var(--dr-cream) 32%); }
+#dr-plan button{ width:100%; padding:13px; cursor:pointer; }
+.dr-note{ font-size:12.5px; color:var(--dr-soft); margin:8px 0; }
+.dr-row{ display:flex; gap:8px; }
+.dr-row button{ flex:1; padding:8px; border-radius:12px; border:1px solid var(--dr-line);
+  background:var(--dr-paper); font-family:'Fredoka',sans-serif; font-weight:600; cursor:pointer;
+  color:var(--dr-ink); }
+.dr-star{ width:100%; margin-top:8px; padding:9px; border-radius:12px; border:1px solid var(--dr-line);
+  background:var(--dr-paper); font-family:'Fredoka',sans-serif; font-weight:600; cursor:pointer;
+  color:var(--dr-ink); }
+
+/* ---- 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:14px 16px 0; gap:12px; overflow:hidden; }
+.map-container{ flex:1 1 0; min-height:480px; position:relative; }
+#dr-map{ height:100%; }
+#dr-map .map-inner{ position:absolute; inset:34px 0 0 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 0 auto; max-height:40vh; overflow-y:auto; padding-bottom:14px; }
+#dr-options{ display:flex; flex-wrap:wrap; gap:10px; margin-bottom:12px; }
+#dr-options .opt{ border:2px solid var(--dr-line); border-radius:var(--dr-r); padding:10px 13px;
+  background:var(--dr-paper); color:var(--dr-ink); cursor:pointer; font-size:12.5px;
+  transition:all .2s var(--dr-spring); }
+#dr-options .opt:hover{ transform:translateY(-3px); }
+#dr-options .opt.selected{ border-color:var(--dr-grass); background:#F1FAF4;
+  box-shadow:0 10px 26px -14px rgba(47,164,99,.6); }
+
+/* ---- loading: stride + 4-step stepper (State 2) ---- */
+#dr-loading{ position:absolute; inset:34px 0 0 0; z-index:20; display:none;
+  place-items:center; border-radius:0 0 26px 26px;
+  background:radial-gradient(700px 320px at 50% 0%,#FBEFD6 0%,transparent 70%),#F6ECD9; }
+#dr-loading.on{ display:grid; }
+.stepper{ display:flex; align-items:center; gap:0; margin-top:18px; }
+.stepper .step{ display:flex; flex-direction:column; align-items:center; gap:6px; width:120px;
+  opacity:.4; transition:opacity .4s ease; }
+.stepper .step.active{ opacity:1; }
+.stepper .step .pip{ width:14px; height:14px; border-radius:50%; background:#CFE8D8;
+  transition:background .4s ease, transform .4s var(--dr-spring); }
+.stepper .step.active .pip{ background:var(--dr-grass); transform:scale(1.15); }
+.stepper .step .lbl{ font-size:11.5px; font-family:'DM Sans',sans-serif; color:var(--dr-ink);
+  text-align:center; }
+.stepper .bar{ flex:1; height:3px; min-width:24px; background:#CFE8D8; position:relative; }
+.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:34px 0 0 0; z-index:21; 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);
+  animation:drPulse 1.1s ease-in-out infinite; margin:0 auto 10px; }
+@keyframes drPulse{ 0%,100%{ transform:scale(.7); opacity:.5; } 50%{ transform:scale(1.1); opacity:1; } }
+
+/* no-detour sticker slot */
+#dr-nodetour:empty{ display:none; }
+
+/* mobile FAB (hidden on desktop) */
+.fab{ display:none; }
+
+/* ---- 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; }
+  .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; }
+  .left-panel{ position:fixed; left:0; right:0; bottom:0; top:auto; z-index:200; width:100%;
+    height:auto; max-height:78vh; border-right:none; border-top-left-radius:24px;
+    border-top-right-radius:24px; box-shadow:0 -18px 44px -20px rgba(43,38,32,.4);
+    transform:translateY(110%); transition:transform .32s var(--dr-spring); }
+  .left-panel.open{ transform:translateY(0); }
+  .fab{ display:grid; place-items:center; position:fixed; right:18px; bottom:18px; z-index:210;
+    width:60px; height:60px; border-radius:50%; border:none; cursor:pointer;
+    background:var(--dr-coral); color:#fff; font-size:24px;
+    box-shadow:0 10px 24px -8px rgba(255,106,82,.8); }
+  .drawer-close{ display:block; }
+}
+.drawer-close{ display:none; width:100%; text-align:center; padding:6px; font-size:22px;
+  color:var(--dr-soft); cursor:pointer; }
+
+@media (prefers-reduced-motion:reduce){ *{ animation:none !important; transition:none !important; } }
+"""
+
+
+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>
+"""
+
+
+def _left_panel() -> str:
+    return """
+<aside class="left-panel" id="left-panel">
+  <div class="drawer-close" id="drawer-close">×</div>
+
+  <div class="dr-control combo">
+    <label class="dr-label" for="dr-start">Start</label>
+    <input type="text" id="dr-start" class="dr-field" autocomplete="off"
+           value="Place de la République, Paris">
+    <div class="combo-list" id="dr-start-list"></div>
+    <div class="dr-help">Type a Paris place — suggestions appear as you type</div>
+  </div>
+
+  <div class="dr-control combo">
+    <label class="dr-label" for="dr-dest">Destination</label>
+    <input type="text" id="dr-dest" class="dr-field" autocomplete="off"
+           value="Jardin du Luxembourg, Paris">
+    <div class="combo-list" id="dr-dest-list"></div>
+  </div>
+
+  <div class="dr-control">
+    <label class="dr-label" for="dr-vibe">Vibe (free text)</label>
+    <input type="text" id="dr-vibe" class="dr-field"
+           placeholder="e.g. 'quiet green wander' or 'lively café crawl'">
+  </div>
+
+  <div class="dr-control">
+    <label class="dr-label">Mode</label>
+    <div id="dr-mode" class="dr-seg">
+      <div class="wrap">
+        <label class="selected" data-v="walk">walk</label>
+        <label data-v="bike">bike</label>
+      </div>
+    </div>
+  </div>
+
+  <div class="dr-control">
+    <label class="dr-label" for="dr-budget-i">Detour budget</label>
+    <div id="dr-budget" class="dr-slider">
+      <input type="range" id="dr-budget-i" min="0" max="2" step="0.1" value="0.5">
+      <output id="dr-budget-o">0.5</output>
+    </div>
+    <div class="dr-help">Extra time vs. the direct trip — 0 = straight there, 1 = up to 2× longer</div>
+  </div>
+
+  <div class="dr-control">
+    <label class="dr-label" for="dr-adv-i">Adventurousness</label>
+    <div id="dr-adv" class="dr-slider">
+      <input type="range" id="dr-adv-i" min="0" max="1" step="0.05" value="0.3">
+      <output id="dr-adv-o">0.3</output>
+    </div>
+    <div class="dr-help">Low = well-known places · high = hidden gems</div>
+  </div>
+
+  <details class="dr-collapse">
+    <summary>Manual taste (used only when Vibe and saved profile are both empty)</summary>
+    <div class="collapse-body">
+      <div class="dr-control">
+        <label class="dr-label" for="dr-green-i">Prefer green</label>
+        <div id="dr-green" class="dr-slider green">
+          <input type="range" id="dr-green-i" min="0" max="1" step="0.05" value="0.5">
+          <output id="dr-green-o">0.5</output>
+        </div>
+      </div>
+      <div class="dr-control">
+        <label class="dr-label" for="dr-quiet-i">Prefer quiet</label>
+        <div id="dr-quiet" class="dr-slider green">
+          <input type="range" id="dr-quiet-i" min="0" max="1" step="0.05" value="0.5">
+          <output id="dr-quiet-o">0.5</output>
+        </div>
+      </div>
+    </div>
+  </details>
+
+  <div class="dr-cta-wrap">
+    <div id="dr-plan"><button type="button" id="dr-plan-btn">Plan route</button></div>
+  </div>
+
+  <details class="dr-collapse">
+    <summary>⭐ My taste profile (saved on this device)</summary>
+    <div class="collapse-body">
+      <label class="dr-label" for="dr-profile-text">Standing preferences</label>
+      <input type="text" id="dr-profile-text" class="dr-field"
+             placeholder="e.g. 'I always love bookshops, gardens, and old churches'">
+      <div class="dr-row" style="margin-top:8px;">
+        <button type="button" id="dr-save">Save</button>
+        <button type="button" id="dr-clear">Clear</button>
+      </div>
+      <div class="dr-note" id="dr-saved"></div>
+      <button type="button" class="dr-star" id="dr-save-places">⭐ Save this route's places</button>
+    </div>
+  </details>
+</aside>
+"""
+
+
+def index_html() -> str:
+    """Assemble the full single-page app served at ``/``."""
+    empty = mapui.empty_map()
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DiscoverRoute · Paris</title>
+{design.DR_HEAD}
+<style>{design.DR_CSS}</style>
+<style>{APP_SHELL_CSS}</style>
+<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+</head>
+<body>
+<div class="gradio-container app-shell">
+  {_compact_hero()}
+  {_left_panel()}
+  <main class="right-col">
+    <div class="map-container">
+      <div id="dr-map"><div class="map-inner">{empty}</div></div>
+      <div id="dr-mapping"><div><div class="pulse"></div>
+        <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-options"></div>
+      <div id="dr-nodetour"></div>
+      <div id="dr-interp"></div>
+      <div id="dr-itin"></div>
+    </div>
+  </main>
+</div>
+<button class="fab" id="fab" aria-label="Open controls">☰</button>
+
+<script type="module">{_app_js()}</script>
+</body>
+</html>"""
+
+
+def _loading_inner() -> str:
+    """Stride mascot (reused) + the 4-step stepper."""
+    steps = ["Interpreting vibe", "Scoring places", "Solving route", "Writing itinerary"]
+    pips = []
+    for i, label in enumerate(steps):
+        if i:
+            pips.append('<div class="bar" data-bar="%d"></div>' % i)
+        pips.append(
+            f'<div class="step" data-step="{i}"><div class="pip"></div>'
+            f'<div class="lbl">{label}</div></div>'
+        )
+    stepper = '<div class="stepper">' + "".join(pips) + "</div>"
+    # Reuse the existing stride mascot markup from LOADING_HTML's inner SVG block.
+    return f"""
+<div style="text-align:center;">
+  <div style="font-family:'Fredoka',system-ui,sans-serif;font-weight:600;font-size:19px;
+       color:#2B2620;">Scouting your wander…</div>
+  {stepper}
+</div>
+<style>
+  @keyframes drBounce {{ 0%,100% {{ transform:translateY(0) }} 50% {{ transform:translateY(-9px) }} }}
+</style>
+"""
+
+
+def _app_js() -> str:
+    return r"""
+import { Client } from "https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js";
+
+const $ = (id) => document.getElementById(id);
+const md = (s) => (window.marked ? window.marked.parse(s || "") : (s || ""));
+
+let appClient = null;
+async function client() {
+  if (!appClient) appClient = await Client.connect(window.location.origin);
+  return appClient;
+}
+
+/* ---------- taste profile via localStorage (replaces gr.BrowserState) ---------- */
+const PKEY = "discoverroute_profile";
+function readProfile() {
+  try { return JSON.parse(localStorage.getItem(PKEY)) ||
+        { standing_text: "", saved_categories: [] }; }
+  catch (e) { return { standing_text: "", saved_categories: [] }; }
+}
+function writeProfile(p) { localStorage.setItem(PKEY, JSON.stringify(p)); renderSaved(); }
+function renderSaved() {
+  const p = readProfile();
+  const cats = p.saved_categories || [];
+  let txt = "_No saved places yet. Plan a route, then ⭐ save its places._";
+  if (cats.length) {
+    const counts = {};
+    cats.forEach(c => counts[c] = (counts[c] || 0) + 1);
+    txt = "**Saved taste:** " + Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([c, n]) => `${c.replace(/_/g, " ")} ×${n}`).join(", ");
+  }
+  $("dr-saved").innerHTML = md(txt);
+  if ($("dr-profile-text") && !$("dr-profile-text").value) $("dr-profile-text").value = p.standing_text || "";
+}
+
+/* ---------- toast ---------- */
+function toast(msg) {
+  const t = document.createElement("div");
+  t.textContent = msg;
+  t.style.cssText = "position:fixed;left:50%;bottom:24px;transform:translateX(-50%);z-index:999;" +
+    "background:#2B2620;color:#fff;padding:11px 18px;border-radius:14px;font-size:13.5px;" +
+    "box-shadow:0 12px 30px -12px rgba(0,0,0,.5);font-family:'DM Sans',sans-serif;";
+  document.body.appendChild(t);
+  setTimeout(() => t.remove(), 2600);
+}
+
+/* ---------- sliders ---------- */
+[["dr-budget-i", "dr-budget-o"], ["dr-adv-i", "dr-adv-o"],
+ ["dr-green-i", "dr-green-o"], ["dr-quiet-i", "dr-quiet-o"]].forEach(([i, o]) => {
+  const inp = $(i); if (!inp) return;
+  const out = $(o);
+  inp.addEventListener("input", () => out.textContent = (+inp.value).toFixed(2).replace(/\.?0+$/, "") || "0");
+});
+
+/* ---------- mode segmented toggle ---------- */
+let mode = "walk";
+document.querySelectorAll("#dr-mode label").forEach(l => {
+  l.addEventListener("click", () => {
+    document.querySelectorAll("#dr-mode label").forEach(x => x.classList.remove("selected"));
+    l.classList.add("selected"); mode = l.dataset.v;
+  });
+});
+
+/* ---------- autocomplete combobox (replaces gr.Dropdown) ---------- */
+function wireCombo(inputId, listId) {
+  const input = $(inputId), list = $(listId);
+  let timer = null, items = [], active = -1;
+  const close = () => { list.classList.remove("open"); active = -1; };
+  input.addEventListener("input", () => {
+    clearTimeout(timer);
+    timer = setTimeout(async () => {
+      try {
+        const c = await client();
+        const r = await c.predict("/suggest", { query: input.value });
+        items = (r.data && r.data[0]) || [];
+        if (!items.length) return close();
+        list.innerHTML = items.map((s, i) =>
+          `<div data-i="${i}">${s.replace(/</g, "&lt;")}</div>`).join("");
+        list.querySelectorAll("div").forEach(d => d.addEventListener("mousedown", (e) => {
+          e.preventDefault(); input.value = items[+d.dataset.i]; close();
+        }));
+        list.classList.add("open");
+      } catch (e) { /* suggestions are best-effort */ }
+    }, 160);
+  });
+  input.addEventListener("keydown", (e) => {
+    if (!list.classList.contains("open")) return;
+    const els = list.querySelectorAll("div");
+    if (e.key === "ArrowDown") { active = Math.min(active + 1, els.length - 1); e.preventDefault(); }
+    else if (e.key === "ArrowUp") { active = Math.max(active - 1, 0); e.preventDefault(); }
+    else if (e.key === "Enter" && active >= 0) { input.value = items[active]; close(); e.preventDefault(); return; }
+    else if (e.key === "Escape") { return close(); }
+    els.forEach((d, i) => d.classList.toggle("active", i === active));
+  });
+  input.addEventListener("blur", () => setTimeout(close, 120));
+}
+wireCombo("dr-start", "dr-start-list");
+wireCombo("dr-dest", "dr-dest-list");
+
+/* ---------- 4-step loader (paced to the pipeline phases) ---------- */
+let stepTimer = null;
+function setStep(n) {
+  document.querySelectorAll(".stepper .step").forEach(s =>
+    s.classList.toggle("active", +s.dataset.step <= n));
+  document.querySelectorAll(".stepper .bar").forEach(b =>
+    b.classList.toggle("fill", +b.dataset.bar <= n));
+}
+function startLoading() {
+  $("dr-loading").classList.add("on");
+  $("dr-summary").innerHTML = ""; $("dr-itin").innerHTML = "";
+  $("dr-interp").innerHTML = ""; $("dr-options").innerHTML = ""; $("dr-nodetour").innerHTML = "";
+  let n = 0; setStep(0);
+  stepTimer = setInterval(() => { n = Math.min(n + 1, 3); setStep(n); }, 1200);
+}
+function stopLoading() { clearInterval(stepTimer); setStep(3); $("dr-loading").classList.remove("on"); }
+
+/* ---------- render ---------- */
+let lastAlts = [], lastCats = [];
+function renderMap(html) { $("dr-map").innerHTML = '<div class="map-inner">' + html + "</div>"; }
+function selectAlt(idx) {
+  const a = lastAlts[idx]; if (!a) return;
+  renderMap(a.map_html);
+  $("dr-summary").innerHTML = md(a.summary_md);
+  $("dr-itin").innerHTML = md(a.itinerary_md);
+  document.querySelectorAll("#dr-options .opt").forEach((o, i) =>
+    o.classList.toggle("selected", i === idx));
+}
+function renderResult(d) {
+  if (d.error) { renderMap(d.map_html); toast("Hmm — " + d.error.split(".")[0] + "."); return; }
+  $("dr-interp").innerHTML = md(d.interpretation_md);
+  if (d.no_detour) {
+    renderMap(d.map_html);
+    $("dr-summary").innerHTML = md(d.summary_md);
+    $("dr-itin").innerHTML = md(d.itinerary_md);
+    $("dr-nodetour").innerHTML = d.nodetour_html || "";
+    lastAlts = []; lastCats = [];
+    return;
+  }
+  $("dr-nodetour").innerHTML = "";
+  lastAlts = d.alternatives || [];
+  lastCats = d.last_cats || [];
+  if (lastAlts.length > 1) {
+    $("dr-options").innerHTML = lastAlts.map((a, i) =>
+      `<div class="opt${i === 0 ? " selected" : ""}" data-i="${i}">${a.label}</div>`).join("");
+    document.querySelectorAll("#dr-options .opt").forEach(o =>
+      o.addEventListener("click", () => selectAlt(+o.dataset.i)));
+  } else { $("dr-options").innerHTML = ""; }
+  selectAlt(0);
+}
+
+/* ---------- plan ---------- */
+async function plan() {
+  // map-press bounce (reused micro-interaction)
+  const mapEl = $("dr-map");
+  if (mapEl) mapEl.animate(
+    [{ transform: "scale(1)" }, { transform: "scale(.99)" }, { transform: "scale(1)" }],
+    { duration: 260, easing: "cubic-bezier(.34,1.56,.64,1)" });
+  startLoading();
+  try {
+    const c = await client();
+    const r = await c.predict("/plan", {
+      start: $("dr-start").value, dest: $("dr-dest").value, mode,
+      budget: +$("dr-budget-i").value, vibe: $("dr-vibe").value,
+      adventurousness: +$("dr-adv-i").value,
+      prefer_green: +$("dr-green-i").value, prefer_quiet: +$("dr-quiet-i").value,
+      profile: JSON.stringify(readProfile()),
+    });
+    renderResult((r.data && r.data[0]) || {});
+  } catch (e) {
+    toast("Something went wrong planning the route.");
+    console.error(e);
+  } finally { stopLoading(); }
+}
+$("dr-plan-btn").addEventListener("click", plan);
+
+/* ---------- profile buttons ---------- */
+$("dr-save").addEventListener("click", () => {
+  const p = readProfile(); p.standing_text = $("dr-profile-text").value || "";
+  writeProfile(p); toast("Saved your standing preferences ✨");
+});
+$("dr-clear").addEventListener("click", () => {
+  writeProfile({ standing_text: "", saved_categories: [] });
+  $("dr-profile-text").value = ""; toast("Profile cleared 🧹");
+});
+$("dr-save-places").addEventListener("click", () => {
+  if (!lastCats.length) return toast("Plan a route first — then I can save its places.");
+  const p = readProfile();
+  p.saved_categories = (p.saved_categories || []).concat(lastCats);
+  writeProfile(p); toast("Saved this route's places to your taste ✨");
+});
+
+/* ---------- mobile drawer ---------- */
+$("fab").addEventListener("click", () => $("left-panel").classList.add("open"));
+$("drawer-close").addEventListener("click", () => $("left-panel").classList.remove("open"));
+
+renderSaved();
+"""

tests/test_hours.py

@@ -69,15 +69,6 @@ def test_demotion_by_posture():
     assert unknown.score == 1.0 and unknown.open_state is None
 
 
-def test_google_verify_noop_without_key(monkeypatch):
-    """Without GOOGLE_MAPS_API_KEY the enrichment must be a silent no-op."""
-    monkeypatch.delenv("GOOGLE_MAPS_API_KEY", raising=False)
-    from discoverroute.enrich import google_places
-    p = P("cafe", None)
-    assert google_places.verify_stops([p]) is False
-    assert not hasattr(p, "live_status")
-
-
 def test_holiday_rules_dont_block_weekday_decisions():
     # "PH off" must not force abstention on a decidable weekday
     assert is_open("Mo-Fr 08:00-18:00; PH off", TUE_15H) is True

tests/test_interpret_fallback.py

@@ -0,0 +1,59 @@
+"""Fallback vibe-interpretation: keyword matcher, brief→taxonomy mapping, JSON parse.
+
+These cover the model-free path that runs whenever the LLM (Call 1) is absent or
+returns malformed output — the path actually exercised off-GPU.
+"""
+from __future__ import annotations
+
+from discoverroute.data import taxonomy
+from discoverroute.interpret import affinity, keywords, llm_vibe, mapping
+
+
+def _is_floored_affinity(aff: dict) -> bool:
+    return (set(aff) == set(taxonomy.CATEGORIES)
+            and all(0.0 <= v <= 1.0 for v in aff.values())
+            and abs(max(aff.values()) - 1.0) < 1e-9)
+
+
+def test_keyword_affinity_matches_books_and_green():
+    aff = keywords.keyword_affinity("quiet green bookshops")
+    assert aff is not None and _is_floored_affinity(aff)
+    # the bookish/green categories should outrank a lively bar
+    assert aff["bookshop"] > aff["bar_pub"]
+    assert aff["park_garden"] > aff["bar_pub"]
+
+
+def test_keyword_affinity_none_when_no_cue():
+    assert keywords.keyword_affinity("zzzz qwerty") is None
+    assert keywords.keyword_scores("") is None
+
+
+def test_brief_scores_to_affinity_shape_and_modifiers():
+    # a pure "green" modifier should lift the greenest category to the top
+    aff = mapping.brief_scores_to_affinity({"green": 1.0})
+    assert _is_floored_affinity(aff)
+    assert aff["park_garden"] >= max(aff[c] for c in taxonomy.CATEGORIES)
+
+
+def test_llm_json_extract_and_validate():
+    good = ('{"cafe":0.9,"park":0.1,"bookshop":0.2,"museum":0.3,"bakery":0.4,'
+            '"restaurant":0.5,"bar":0.6,"viewpoint":0.7,"market":0.8,"quiet":0.2,'
+            '"green":0.3,"historic":0.4,"busy":0.5,"detour_budget_multiplier":1.4}')
+    obj = llm_vibe._validate(llm_vibe._extract_json("noise " + good + " trailing"))
+    assert obj is not None and obj["cafe"] == 0.9
+    # missing a required key -> rejected
+    assert llm_vibe._validate(llm_vibe._extract_json('{"cafe":0.9}')) is None
+    # not JSON at all -> None
+    assert llm_vibe._extract_json("sorry, I cannot do that") is None
+
+
+def test_resolve_affinity_neutral_on_empty():
+    aff, src = affinity.resolve_affinity("")
+    assert src == "neutral"
+    assert all(abs(v - 1.0) < 1e-9 for v in aff.values())
+
+
+def test_resolve_affinity_returns_full_taxonomy():
+    aff, src = affinity.resolve_affinity("lively cafe crawl")
+    assert set(aff) == set(taxonomy.CATEGORIES)
+    assert src in {"llm", "embed", "keyword"}