Pre-baked offline cities (London, Barcelona, New York) + endpoint-stop fix

Keeps the "Off the Grid" badge while going multi-city: each extra city is baked
as a bounded walkable core (centre + radius) committed via Git LFS, so it routes
fully offline — no live OSM at request time.

- data/build_city.py + config.CITIES registry; data/cities/<slug>_{walk.graphml,
pois.parquet} for london/barcelona/newyork (+ cities_manifest.json).
- routing/area.py: resolve_area now picks Paris → a pre-baked city (both points
in its core) → (online only) on-demand fetch. In offline mode, anywhere else
is refused with an honest "WanderLust covers Paris, London, …" message.
- routing/geocode.py: offline name index now spans Paris + every pre-baked city,
with city-hint disambiguation ("…, London") so a landmark resolves to the
right city; suggest()/local_geocode() are city-aware.
- pipeline.py: drop candidate POIs within 80 m of the start/destination so an
endpoint (e.g. the square you start from) is never offered as a "discovery
stop" — it isn't a detour and read as a bug.

Verified offline: London/Barcelona/NYC geocode with no network and route on
their own graphs; Paris unchanged; uncovered locations refused gracefully.
17 geocode/routing/pois tests pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

data/cities/barcelona_pois.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd2cf7db57860905475a21d74ac5f2529e361201f9d640f3a813beea38c7f696
+size 467125

data/cities/barcelona_walk.graphml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d915d218b8672f34a6ae6e8a28dc81e44357feda1032f99cc5e6797d2828056
+size 51051619

data/cities/cities_manifest.json

@@ -0,0 +1,56 @@
+{
+  "london": {
+    "label": "London",
+    "center": [
+      51.5118,
+      -0.123
+    ],
+    "bbox": [
+      -0.16918911934351633,
+      51.48285120318437,
+      -0.07681088065648367,
+      51.540748796815635
+    ],
+    "tz": "Europe/London",
+    "poi_count": 10852,
+    "build_date": "2026-06-13",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "barcelona": {
+    "label": "Barcelona",
+    "center": [
+      41.387,
+      2.17
+    ],
+    "bbox": [
+      2.131685394983051,
+      41.35805120318437,
+      2.2083146050169487,
+      41.415948796815634
+    ],
+    "tz": "Europe/Madrid",
+    "poi_count": 11198,
+    "build_date": "2026-06-13",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  },
+  "newyork": {
+    "label": "New York",
+    "center": [
+      40.756,
+      -73.9845
+    ],
+    "bbox": [
+      -74.02244862803626,
+      40.72705120318437,
+      -73.94655137196374,
+      40.784948796815634
+    ],
+    "tz": "America/New_York",
+    "poi_count": 7416,
+    "build_date": "2026-06-13",
+    "source": "OpenStreetMap",
+    "license": "ODbL \u2014 \u00a9 OpenStreetMap contributors"
+  }
+}

data/cities/london_pois.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cea6dead717a364c54f17c27f08083f7d47c7ad3c1c36d539a324777de3eb092
+size 469067

data/cities/london_walk.graphml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29788fdbdc48a9859c30350a2dcb33dae04aae47e5e5f38fc6b79f8ecd60c77f
+size 51874171

data/cities/newyork_pois.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a46cc3449673d4faac43e6456d26bb3d2a74effdbf0d436c0921495e275a5a75
+size 320167

data/cities/newyork_walk.graphml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fb8c2f6c51fc2d29c30d345c6e2628553dd80cb2db43242a5a4865f94a71fea
+size 18354729

src/discoverroute/config.py

@@ -79,6 +79,28 @@ def corridor_halfwidth_m(budget: float) -> float:
     return CORRIDOR_BASE_M + CORRIDOR_BUDGET_M * max(0.0, budget)
 
 
+# --- Pre-baked extra cities (offline, keeps "Off the Grid") ------------------
+# Paris ships full-city (above). These additional cities are baked as a bounded
+# walkable core (centre + radius) by data/build_city.py and committed, so they
+# route fully offline — no live OSM at request time. Add a city here, run
+# `python -m discoverroute.data.build_city <slug>`, commit the data.
+CITY_DATA_DIR = DATA_DIR / "cities"
+CITIES_MANIFEST_PATH = CITY_DATA_DIR / "cities_manifest.json"
+CITIES = {
+    "london":    {"label": "London",    "center": (51.5118, -0.1230), "radius_m": 3200, "tz": "Europe/London"},
+    "barcelona": {"label": "Barcelona", "center": (41.3870,  2.1700), "radius_m": 3200, "tz": "Europe/Madrid"},
+    "newyork":   {"label": "New York",  "center": (40.7560, -73.9845), "radius_m": 3200, "tz": "America/New_York"},
+}
+
+
+def city_graph_path(slug: str) -> Path:
+    return CITY_DATA_DIR / f"{slug}_walk.graphml"
+
+
+def city_pois_path(slug: str) -> Path:
+    return CITY_DATA_DIR / f"{slug}_pois.parquet"
+
+
 # --- Other cities (on-demand) ------------------------------------------------
 # Paris ships pre-baked (instant, offline). Any other city is fetched live from
 # OpenStreetMap at request time: we download only the bounding box spanning the

src/discoverroute/data/build_city.py

@@ -0,0 +1,87 @@
+"""Pre-bake a walkable *city core* (graph + POIs) for offline routing.
+
+Paris ships full-city; additional cities are baked as a bounded core (a box
+around the centre) so the data stays small and the build is quick, while still
+covering the walkable, demo-worthy heart of the city. Running this writes
+``data/cities/<slug>_walk.graphml`` + ``data/cities/<slug>_pois.parquet`` so the
+city routes **fully offline** at request time — no live OSM calls, preserving the
+"Off the Grid" badge while still being multi-city.
+
+    python -m discoverroute.data.build_city london
+    python -m discoverroute.data.build_city          # all cities in config.CITIES
+"""
+from __future__ import annotations
+
+import json
+import math
+import sys
+import time
+from datetime import datetime, timezone
+
+import osmnx as ox
+
+from discoverroute import config
+from discoverroute.routing.area import _fetch_pois  # reuse the tested POI fetch
+
+
+def _bbox_from_center(center, radius_m):
+    """(left, bottom, right, top) = (W, S, E, N) box around a centre point."""
+    lat, lon = center
+    dlat = radius_m / 110_540.0
+    dlon = radius_m / (111_320.0 * max(0.1, math.cos(math.radians(lat))))
+    return (lon - dlon, lat - dlat, lon + dlon, lat + dlat)
+
+
+def build_city(slug: str) -> None:
+    spec = config.CITIES.get(slug)
+    if spec is None:
+        raise SystemExit(f"Unknown city {slug!r}. Known: {', '.join(config.CITIES)}")
+    label = spec["label"]
+    bbox = _bbox_from_center(spec["center"], spec["radius_m"])
+
+    ox.settings.use_cache = True
+    ox.settings.log_console = False
+    ox.settings.requests_timeout = 180
+
+    config.CITY_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    t0 = time.time()
+    print(f"[build_city] {label}: downloading walk graph for bbox {bbox}")
+    graph = ox.graph_from_bbox(bbox, network_type="walk")
+    graph = ox.truncate.largest_component(graph, strongly=True)
+    gpath = config.city_graph_path(slug)
+    ox.save_graphml(graph, gpath)
+    print(f"[build_city] {label}: {graph.number_of_nodes():,} nodes -> {gpath.name}")
+
+    df = _fetch_pois(bbox)
+    if not len(df):
+        raise SystemExit(f"[build_city] {label}: no POIs found — aborting.")
+    ppath = config.city_pois_path(slug)
+    df.to_parquet(ppath, index=False)
+    print(f"[build_city] {label}: {len(df):,} POIs -> {ppath.name} "
+          f"(by category:\n{df['category'].value_counts().to_string()})")
+
+    # Per-city provenance, appended to the cities manifest.
+    manifest = {}
+    if config.CITIES_MANIFEST_PATH.exists():
+        manifest = json.loads(config.CITIES_MANIFEST_PATH.read_text("utf-8"))
+    manifest[slug] = {
+        "label": label,
+        "center": list(spec["center"]),
+        "bbox": list(bbox),
+        "tz": spec["tz"],
+        "poi_count": int(len(df)),
+        "build_date": datetime.now(timezone.utc).date().isoformat(),
+        "source": "OpenStreetMap", "license": "ODbL — © OpenStreetMap contributors",
+    }
+    config.CITIES_MANIFEST_PATH.write_text(json.dumps(manifest, indent=2) + "\n", "utf-8")
+    print(f"[build_city] {label}: done in {time.time() - t0:.0f}s")
+
+
+def main() -> None:
+    slugs = sys.argv[1:] or list(config.CITIES)
+    for s in slugs:
+        build_city(s)
+
+
+if __name__ == "__main__":
+    main()

src/discoverroute/pipeline.py

@@ -245,6 +245,13 @@ def _prepare_discovery(graph, start, end, plain, mode, budget, weights, adventur
     table = area.table if area is not None else None
     origin = area.origin if area is not None else None
     candidates = poimod.corridor_pois(plain.coords, budget, table=table, origin=origin)
+    if not candidates:
+        return None, None, None
+    # Never offer the start or destination itself as a "discovery stop" — a POI
+    # sitting on an endpoint (e.g. the square you're starting from) is not a
+    # detour and reads as a bug. Drop anything within ENDPOINT_EXCLUSION_M.
+    candidates = [p for p in candidates
+                  if not _near_endpoint(p.lat, p.lon, start, end)]
     if not candidates:
         return None, None, None
     # Discovery vibes ("hidden gems"): drop famous, well-documented sights so the
@@ -324,6 +331,19 @@ def _solve_one(graph, start, end, plain, mode, budget, shortlist, matrix, time_f
     return discovery, result.ordered_pois
 
 
+def _near_endpoint(lat: float, lon: float, start, end, thresh_m: float = 80.0) -> bool:
+    """True if (lat, lon) is within thresh_m of the start or destination point."""
+    import math
+
+    def d(a, b):
+        (la1, lo1), (la2, lo2) = a, b
+        p1, p2 = math.radians(la1), math.radians(la2)
+        dp, dl = math.radians(la2 - la1), math.radians(lo2 - lo1)
+        h = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+        return 2 * 6_371_000.0 * math.asin(math.sqrt(h))
+    return d((lat, lon), start) < thresh_m or d((lat, lon), end) < thresh_m
+
+
 def _city_label(start_query: str, dest_query: str) -> str:
     """A friendly area name for on-demand fetch logs/messages.
 

src/discoverroute/routing/area.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import functools
 import logging
 import math
+import os
 import time
 from dataclasses import dataclass
 from zoneinfo import ZoneInfo
@@ -157,6 +158,42 @@ def _paris_area() -> Area:
     )
 
 
+def city_bbox(slug: str):
+    """(left, bottom, right, top) box for a pre-baked city — matches build_city."""
+    spec = config.CITIES[slug]
+    lat, lon = spec["center"]
+    r = spec["radius_m"]
+    dlat = r / 110_540.0
+    dlon = r / (111_320.0 * max(0.1, math.cos(math.radians(lat))))
+    return (lon - dlon, lat - dlat, lon + dlon, lat + dlat)
+
+
+def _in_bbox(pt, bbox) -> bool:
+    return bbox[0] <= pt[1] <= bbox[2] and bbox[1] <= pt[0] <= bbox[3]
+
+
+def available_cities() -> list[str]:
+    """Slugs of pre-baked cities whose data is actually present on disk."""
+    return [s for s in config.CITIES
+            if config.city_graph_path(s).exists() and config.city_pois_path(s).exists()]
+
+
+@functools.lru_cache(maxsize=8)
+def _city_area(slug: str) -> Area:
+    """Load a pre-baked city (committed graph + parquet) as an offline Area."""
+    from discoverroute.routing import graph as g
+
+    spec = config.CITIES[slug]
+    graph = ox.load_graphml(config.city_graph_path(slug))
+    df = pd.read_parquet(config.city_pois_path(slug))
+    origin = tuple(spec["center"])
+    return Area(
+        key=slug, label=spec["label"], graph=graph,
+        table=poimod.index_table(df, origin), csr=g.build_csr(graph),
+        origin=origin, tz=ZoneInfo(spec["tz"]), source="prebaked",
+    )
+
+
 # Manual bounded LRU of on-demand areas (graphs are heavy — keep only a few).
 _ondemand_cache: dict[str, Area] = {}
 _ondemand_order: list[str] = []
@@ -216,9 +253,25 @@ def resolve_area(start: tuple[float, float], end: tuple[float, float],
     """
     from discoverroute.routing.graph import RouteError
 
+    # 1) Paris — full pre-baked city (instant, offline).
     if config.in_paris(*start) and config.in_paris(*end):
         return _paris_area()
 
+    # 2) Other pre-baked cities (instant, offline) — both points in one city core.
+    for slug in available_cities():
+        bbox = city_bbox(slug)
+        if _in_bbox(start, bbox) and _in_bbox(end, bbox):
+            return _city_area(slug)
+
+    # 3) Anywhere else. Offline mode (the "Off the Grid" deploy config) only knows
+    # the pre-baked cities, so say so honestly. Online mode fetches live from OSM.
+    if os.environ.get(config.OFFLINE_ENV_VAR) == "1":
+        covered = ", ".join(["Paris"] + [config.CITIES[s]["label"] for s in available_cities()])
+        raise RouteError(
+            f"WanderLust covers {covered}. Pick a start and destination within one "
+            "of these cities (this build runs fully offline)."
+        )
+
     dist = _haversine_m(start, end)
     if dist > config.MAX_ENDPOINT_DISTANCE_M:
         raise RouteError(

src/discoverroute/routing/geocode.py

@@ -31,6 +31,7 @@ class _Entry(NamedTuple):
     n_tags: int
     display: str       # original POI name, for autocomplete suggestions
     category: str
+    city: str          # "paris" or a pre-baked city slug — for disambiguation
 
 
 def _normalize(text: str) -> str:
@@ -44,10 +45,36 @@ def _normalize(text: str) -> str:
 
 def _strip_trailing_geo(norm: str) -> str:
     """Drop trailing 'paris' / 'france' qualifiers (but never the whole query)."""
+    return _split_geo(norm)[0]
+
+
+@functools.lru_cache(maxsize=1)
+def _geo_hints() -> dict[str, str]:
+    """Normalised city/qualifier word -> city slug (for trailing-token hints)."""
+    from discoverroute import config
+
+    hints = {"paris": "paris", "france": "paris"}
+    for slug, spec in config.CITIES.items():
+        hints[slug] = slug
+        for tok in _normalize(spec["label"]).split():
+            hints[tok] = slug
+    return hints
+
+
+def _split_geo(norm: str) -> tuple[str, str | None]:
+    """Split a normalised query into (core, city_hint_slug).
+
+    Pops trailing geography qualifiers ("…, london", "…, paris, france") and
+    returns which city they point at, so a landmark that exists in two cities can
+    be disambiguated by the city the user named.
+    """
     tokens = norm.split()
-    while len(tokens) > 1 and tokens[-1] in _TRAILING_TOKENS:
+    hints = _geo_hints()
+    hint = None
+    while len(tokens) > 1 and tokens[-1] in hints:
+        hint = hints[tokens[-1]]
         tokens.pop()
-    return " ".join(tokens)
+    return " ".join(tokens), hint
 
 
 # Obvious non-Paris places that would otherwise namesake-match a Paris POI
@@ -76,35 +103,43 @@ def is_world_place(query: str) -> bool:
 
 @functools.lru_cache(maxsize=1)
 def _index() -> tuple[dict[str, _Entry], list[_Entry]]:
-    """Lazy name index: exact normalised-name map + full entry list.
+    """Lazy name index over Paris + every pre-baked city's POI names.
 
-    For duplicate names (e.g. chain shops) the exact map keeps the entry with
-    the highest (confidence, n_tags) — the best-documented bearer of the name.
+    Exact normalised-name map + full entry list. For duplicate names the exact
+    map keeps the entry with the highest (confidence, n_tags); the per-entry city
+    tag lets a city-hinted query ("…, London") prefer the right city.
     """
+    import pandas as pd
+
+    from discoverroute import config
+    from discoverroute.routing import area as area_mod
     from discoverroute.routing.pois import load_pois
 
-    df = load_pois()
-    named = df[df["name"].notna()]
+    sources = [("paris", load_pois())]
+    for slug in area_mod.available_cities():
+        try:
+            sources.append((slug, pd.read_parquet(config.city_pois_path(slug))))
+        except Exception:  # noqa: BLE001 - a missing/partial city is non-fatal
+            continue
+
     exact: dict[str, _Entry] = {}
     entries: list[_Entry] = []
-    for row in named.itertuples(index=False):
-        norm = _normalize(row.name)
-        if not norm:
-            continue
-        entry = _Entry(
-            norm=norm,
-            tokens=frozenset(norm.split()),
-            lat=float(row.lat),
-            lon=float(row.lon),
-            confidence=float(row.confidence),
-            n_tags=int(row.n_tags),
-            display=str(row.name),
-            category=str(row.category),
-        )
-        entries.append(entry)
-        best = exact.get(norm)
-        if best is None or (entry.confidence, entry.n_tags) > (best.confidence, best.n_tags):
-            exact[norm] = entry
+    for city, df in sources:
+        named = df[df["name"].notna()]
+        for row in named.itertuples(index=False):
+            norm = _normalize(row.name)
+            if not norm:
+                continue
+            entry = _Entry(
+                norm=norm, tokens=frozenset(norm.split()),
+                lat=float(row.lat), lon=float(row.lon),
+                confidence=float(row.confidence), n_tags=int(row.n_tags),
+                display=str(row.name), category=str(row.category), city=city,
+            )
+            entries.append(entry)
+            best = exact.get(norm)
+            if best is None or (entry.confidence, entry.n_tags) > (best.confidence, best.n_tags):
+                exact[norm] = entry
     return exact, entries
 
 
@@ -116,11 +151,16 @@ def local_geocode(query: str) -> tuple[float, float] | None:
     tokens present in the POI name), ranked by substring match, confidence,
     tag count, and name brevity. Returns None when nothing matches confidently.
     """
-    norm = _strip_trailing_geo(_normalize(query or ""))
+    norm, hint = _split_geo(_normalize(query or ""))
     if not norm:
         return None
     exact, entries = _index()
 
+    # Exact name match — prefer the hinted city when the query named one.
+    if hint:
+        for e in entries:
+            if e.norm == norm and e.city == hint:
+                return e.lat, e.lon
     hit = exact.get(norm)
     if hit is not None:
         return hit.lat, hit.lon
@@ -130,6 +170,10 @@ def local_geocode(query: str) -> tuple[float, float] | None:
         return None  # only short fragments — too ambiguous to trust
     q_set = frozenset(q_tokens)
     candidates = [e for e in entries if q_set <= e.tokens]
+    if hint:
+        hinted = [e for e in candidates if e.city == hint]
+        if hinted:
+            candidates = hinted
     if not candidates:
         return None
     best = max(
@@ -148,10 +192,12 @@ def suggest(query: str, limit: int = 8) -> tuple[str, ...]:
     display name. Pure local index — no network. Returns () for short/ambiguous
     input rather than guessing.
     """
-    norm = _strip_trailing_geo(_normalize(query or ""))
+    norm, hint = _split_geo(_normalize(query or ""))
     if len(norm) < 3:
         return ()
     _, entries = _index()
+    if hint:
+        entries = [e for e in entries if e.city == hint] or entries
     toks = norm.split()
     head, last = frozenset(toks[:-1]), toks[-1]