chore: update build settings and screenshots

Expanded leading/trailing, compact and minimal island views had
no Link, so tapping them just opened the app with no destination.
Every island region now links to the same tap destination as the
Lock Screen card (Maps vs in-app detail).

Tap hint captions follow the setting too: Tap for details vs
Tap for directions.

.gitignore

@@ -1,5 +1,7 @@
 build/
 build-release/
+build-sim/
+build-watch/
 .DS_Store
 *.xcuserstate
 xcuserdata/

APPSTORE.md

@@ -1,86 +1,131 @@
-# FuelBoard App Store Approval Review
+# FuelBoard App Store Submission Plan
 
-Review date: 2026-08-11 · Target: App Store submission readiness.
-This is the companion to SECURITY.md — focuses on App Store *review* gate
-(guideline compliance), not code security.
+Updated: 2026-08-16 · Target: safe App Store submission.
+Companion to SECURITY.md (code security) — this file is the *review-gate*
+checklist: what must happen, who owns it, and the timeline.
 
-## Status: NOT SUBMISSION-READY
+## Status: SUBMITTABLE after the checklist below
 
-Two blockers remain before a real submission (see below). Everything else
-checks out for review.
+The two 2026-08-11 blockers are RESOLVED by P0 (live chain):
+- ~~LAN relay data source~~ → **app fetches from public HTTPS
+  (raw.githubusercontent.com mirror) with a bundled real 8,022-station dump
+  as the no-network fallback.** No private IP in the consumer path. Reviewers
+  on Apple's network see real data.
+- ~~Always-location risk~~ → **Always is requested only when the user enables
+  Alerts** (ProximityMonitor escalates WhenInUse → Always on alert opt-in).
+  Onboarding requests WhenInUse only.
 
-## Blockers
+## Hard blockers (must happen before ANY submission)
 
-### 1. Data source — LAN relay (BLOCKER)
-- The app fetches from `http://192.168.1.131:8788` — a private LAN host. Off
-  the user's network it fails and falls back to sample data. Reviewers on
-  Apple's network will see empty/sample results → 2.1 (performance) rejection,
-  and hardcoded IPs look like test builds.
-- **Fix**: the govuk API switch (BACKLOG P0). App must talk to a public HTTPS
-  endpoint before submission. The relay (HTTPS domain) or direct gov.uk OAuth
-  both work; the code path is already stubbed.
+1. **[USER] Apple Developer Program membership** — the app has never been
+   signed (all builds are `CODE_SIGNING_ALLOWED=NO` + ad-hoc re-sign for
+   SideStore). Requires a paid membership ($99/yr, up to 48 h to approve) and
+   a developer account.
+2. **[USER] Register App ID `com.apt.fuelboard`** in the developer portal,
+   with the **App Group `group.com.apt.fuelboard`** capability AND the
+   **In-App Purchase** capability enabled (the widget + app-group cache
+   depend on the group; the tip jar needs IAP).
+3. ~~[ME] `PrivacyInfo.xcprivacy`~~ — **DONE 2026-08-16** (app + widget
+   manifests added; UserDefaults `1C8F.1`, Location + Diagnostics declared).
+4. **[ME] Real Distribution signing** — Distribution certificate + App Store
+   provisioning profile (or Xcode automatic signing once the account is in
+   Xcode); then `xcodebuild archive` (no more `CODE_SIGNING_ALLOWED=NO`).
+5. **[USER] Privacy policy URL** in App Store Connect — mandatory; the app
+   collects location. Policy text is now in `PRIVACY.md`; publish it via the
+   FuelBoard marketing site or GitHub Pages and paste that public URL into App
+   Store Connect.
 
-### 2. Always-location justification (BLOCKER without review notes)
-- `NSLocationAlwaysAndWhenInUseUsageDescription` + `UIBackgroundModes: location`
-  present, but guideline 5.1.1 requires the feature to be obvious AND the app
-  must visibly use background location. The geofenced "cheapest station" alerts
-  satisfy this, but the reviewer must see it:
-  - Provide detailed App Review notes explaining the alert flow (enable Alerts →
-    geofence trigger → notification when approaching the cheapest station).
-  - Ensure the Alerts tab is discoverable and functional in review.
-  - Also: "Always" prompt should only appear after the user opts into alerts
-    (in-progress UX; currently the permission prompt may fire too early).
+## Required tasks — owner [ME] (technical, do after account exists)
 
-## Review-relevant configuration — PASS
+- [x] **PrivacyInfo.xcprivacy** — app + widget manifests added (2026-08-16):
+      UserDefaults reason `1C8F.1`; app also declares Location (linked, not
+      tracking) + Diagnostics (not linked, not tracking — the dev beacon)
+- [ ] Distribution archive + TestFlight upload (needs Apple account)
+- [x] **Version bump** → `1.0.1` (build 2), app + widget plists
+- [x] **OGL attribution** — Settings → Data source footer now reads "Prices
+      use the UK Fuel Finder dataset (Open Government Licence) and refresh
+      up to twice a day." (2.3.1 hygiene)
+- [x] **Out-of-UK empty state** — "No X stations within N miles" + UK-only
+      explainer + "Browse all UK stations" button (switches to Closest)
+- [ ] ~~Gate dev surface behind #if DEBUG~~ **DECLINED — kept in Release on
+      purpose**: the user's home-testing installs the Release IPA and toggles
+      `fuelboard.relayFallback` via Settings → Debug (revealed only by tapping
+      About → Version ×5 — invisible to reviewers; no credentials involved).
+      Gating it out of Release would break that workflow for zero review gain.
+- [ ] Final pass: `swift test` green (95 tests), archive smoke test on device
+- [ ] ~~Capture screenshots from simulator~~ **RAW CAPTURES DONE (2026-08-16)** —
+      native 6.9″ 1320×2868 PNGs of all four tabs (Stations, Favourites,
+      Alerts, Settings) at `/tmp/fuelboard-shots/asc/`; assembled into ASC
+      frames by the user in the yuzu-hub App Store Screenshot Generator
+      (https://yuzu-hub.github.io/appscreen/). Screenshot harness: launch
+      args `-skipOnboarding` / `-tab stations|favourites|alerts|settings`
+      (ContentView, same pattern as `-showKeySheet`).
 
-- [x] **App icon**: was MISSING entirely (invalid-binary rejection). Fixed —
-      1024×1024 `AppIcon.appiconset` + `ASSETCATALOG_COMPILER_APPICON_NAME`.
-- [x] **Launch screen**: `UILaunchScreen` empty dict present (iOS 14+ style).
-- [x] **Device family**: iPhone-only (`TARGETED_DEVICE_FAMILY = 1`) — no iPad
-      multitasking requirements.
-- [x] **Versioning**: `CFBundleShortVersionString 1.0`, `CFBundleVersion 1`
-      (bump per release).
-- [x] **Permissions**: only location (WhenInUse + Always), with clear usage
-      strings. No contacts/photos/mic/camera.
-- [x] **No third-party SDKs** → no SDK privacy manifests or third-party
-      attribution required.
-- [x] **No account creation / login** → no account-deletion requirement (5.1.1(v)).
-- [x] **ATS**: no `NSAllowsArbitraryLoads` (raw-IP cleartext is ATS-exempt; once
-      the relay is HTTPS this is moot).
-- [x] **Export compliance**: no crypto beyond keychain/SecItem → no
-      documentation needed.
+## Required tasks — owner [USER] (App Store Connect, cannot be done by me)
 
-## Content / IP review
+- [ ] Apple Developer Program membership + App ID (blockers #1–#2)
+- [ ] **Tip jar: create the three consumable IAPs** in App Store Connect →
+      In-App Purchases (all type **Consumable**, exact product IDs, UK price
+      tier; tip jars are an accepted App Review pattern):
+      - `com.apt.fuelboard.tip099` — **£0.99** — "Splash & Dash" (Just enough to keep things moving.)
+      - `com.apt.fuelboard.tip299` — **£2.99** — "Half a Tank" (A generous top-up for development.)
+      - `com.apt.fuelboard.tip499` — **£4.99** — "Fill 'Er Up" (Keeping the app on the road.)
+      App-side is ready (`41e4c91`): Settings → Support FuelBoard shows all
+      three tiers with per-tier prices; sideloaded builds gracefully show
+      "not available in this build yet" until the products exist.
+- [ ] App Store Connect app record: name, bundle ID `com.apt.fuelboard`,
+      category (Utilities), pricing (Free), availability (UK first?)
+- [ ] Description, keywords, support URL, marketing URL, privacy policy URL
+- [ ] Privacy nutrition labels questionnaire (location: yes, linked to user
+      for alerts/nearby; diagnostics: yes — the widget-diag beacon, not
+      linked, not used for tracking; no ATT prompt needed)
+- [ ] Age rating questionnaire (4+; no objectionable content)
+- [ ] Export compliance: HTTPS-only + keychain → standard encryption
+      exemption (5A992a), no documentation needed
+- [ ] Approve the TestFlight build and do a real-device pass before submit
+- [ ] Final "Submit for Review" click + stand by to answer review questions
 
-- **Brand logos (Shell, BP, Tesco…)**: bundled from Simple Icons (CC0) +
-  Wikimedia Commons. Nominative use (identifying stations) is standard practice
-  (cf. GasBuddy). Low risk, but keep the sources documented.
-- **Price data**: gov.uk Fuel Finder data is OGL-licensed — include attribution
-  in the app (About/credits) once live data ships. Sample fallback data must be
-  clearly demo-labelled (or removed for review) so reviewers don't think the
-  prices are fake — 2.3.1 accuracy risk.
-- **"Cheapest" claims**: data is 12h-old cache. The UI says "cheapest" — fine,
-  but a small "prices from the UK Fuel Finder dataset, updated twice daily"
-  footnote is good hygiene for 2.3.1.
-
-## Suggested review notes (copy-paste for App Store Connect)
+## Review notes (copy-paste into App Store Connect)
 
 > FuelBoard shows the cheapest petrol, diesel, and premium fuel near the user
-> using the UK government Fuel Finder dataset (OGL). Prices are fetched up to
-> twice a day; the app filters 5/10/15-mile radii on-device. Location is used
-> to (a) rank stations by distance and (b) power the optional Alerts feature:
-> when enabled, the app geofences the cheapest station in the user's chosen
-> radius and sends a notification when they approach it. Always-location is
-> only requested when the user enables alerts. The app also provides a
-> home-screen widget showing the current cheapest station nearby.
+> using the UK government Fuel Finder dataset (Open Government Licence).
+> Prices are downloaded from the internet up to twice a day; the app filters
+> 5/10/15-mile radii on-device and works offline from a bundled snapshot.
+> Location is used to (a) rank stations by distance and (b) power the
+> optional Alerts feature: when the user enables alerts, the app geofences
+> the cheapest station in their radius and sends a notification when they
+> approach it. Always-location is requested only when the user enables
+> alerts. The app also provides a home-screen widget showing the current
+> cheapest station nearby, and a price-history Trends chart for starred
+> stations. All data is UK-wide (Fuel Finder covers England, Scotland, Wales
+> and Northern Ireland); users outside the UK see an empty state explaining
+> this.
 
-## Release checklist (before every submission)
+## Review risks (know before submitting)
 
-1. [ ] Relay/govuk data source live on a public HTTPS endpoint
-2. [ ] Always-permission flow tied to explicit user opt-in
-3. [ ] Bump `CFBundleShortVersionString` / `CFBundleVersion`
-4. [ ] Sample-data fallback labelled or removed in the release build
-5. [ ] OGL attribution present in-app
-6. [ ] `swift test` green (FuelBoardTests, 28 tests)
-7. [ ] Security audit pass (see SECURITY.md recurring checks)
-8. [ ] Icon + screenshots for all required sizes in App Store Connect
+- **Always-location (5.1.1)** — the #1 question. The feature is visible
+  (Alerts tab) and opt-in; the review notes above say so explicitly.
+- **Reviewer outside the UK** — empty radius; mitigated by the empty-state
+  task above + review notes.
+- **"Cheapest" claims (2.3.1)** — mitigated by the OGL/footnote task.
+- **Live Activities** — reviewers may ask why; answer: price alerts at a
+  glance. It is declared in the plist already.
+- **Brand logos (Shell, BP, Tesco…)** — Simple Icons (CC0) + Wikimedia,
+  nominative use (cf. GasBuddy); low risk, keep sources documented.
+- **GitHub raw as data source** — public data, no credentials; bundled dump
+  covers any regional GitHub unreachability.
+
+## Timeline (best case)
+
+| Day | Owner | Milestone |
+|-----|-------|-----------|
+| 0–2 | USER | Developer Program enrollment + App ID + app group capability |
+| 2–3 | ME | Signing (automatic), PrivacyInfo.xcprivacy, attribution, empty state, version bump |
+| 3–4 | ME | Archive → TestFlight; screenshots captured |
+| 4–5 | USER | TestFlight install + real-device pass (onboarding, alerts, widget, offline) |
+| 5–6 | USER | App Store Connect metadata + labels + age rating + privacy URL |
+| 6–7 | USER/ME | Submit for review |
+| 7–14 | Apple | Review (typically 1–3 days, can be a week); answer questions same-day |
+
+Rollback note: nothing about submission changes the repo's rollback posture
+(`main` history is intact; release builds are tagged per submission).

BACKLOG.md

@@ -1,8 +1,10 @@
 # FuelBoard Backlog
 
-FuelBoard — England-wide petrol-station price widget + app.
-Relay mirrors the UK gov data (hourly CSV); app fetches the full-UK dump
-(~8,038 stations, all prices) once per 12 h and filters/sorts on-device.
+FuelBoard — UK-wide petrol-station price widget + app.
+GitHub mirror (`aptonline/fuelboard-data`, 2×/day 10:00+16:00) holds the
+full-UK dump (~8,022 stations, all prices); app fetches it once per 12 h and
+filters/sorts on-device, with a bundled snapshot as the no-network last resort.
+LAN relay is dev-only (hidden `fuelboard.relayFallback` flag).
 
 Priority guide: P0 = next build, P1 = soon, P2 = later, P3 = maybe/idea.
 Status: TODO / IN PROGRESS / DONE / BLOCKED.
@@ -11,18 +13,60 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
 
 ## P1 — Soon
 
+- [x] **Move relay + mirror off the Mac mini (DONE 2026-08-16)** — dedicated
+  Debian 13 LXC on Proxmox via community-scripts/ProxmoxVE `ct/debian.sh`
+  (CT **111**, hostname **`fuelboard-relay`**, 1 core/512 MB/2 GB, static IP
+  **192.168.1.113**, plain LXC — NO Docker layer). Scope: relay AND mirror
+  both moved (full Mac independence; relays bind **loopback only**, GitHub is
+  the only public surface). What landed: Python 3.13.5 (trixie) boots both
+  relays (relay 8788 demo/CSV + relay-api 8789 `source: api`, 8,024 stations,
+  ~2 min first sync, 0 failures); source at `/root/workspace/fuelboard-{relay,relay-api}`
+  (venvs + pip, `.env` chmod 600); deploy key `fuelboard_deploy` +
+  `github-fuelboard-data` ssh config + `fuelboard-data` clone at
+  `/root/workspace/fuelboard-data` (origin = ssh alias, green + synced);
+  `mirror_push.py` → `/root/scripts/mirror_push.py` (RELAY line already
+  `127.0.0.1:8789`); systemd `fuelboard-relay.service` +
+  `fuelboard-relay-api.service` (Restart=always, `--host 127.0.0.1`) +
+  `fuelboard-mirror.service` (oneshot) + `.timer` (10:00 + 16:00, Persistent,
+  armed — next Mon 10:00); first live push VERIFIED from outside
+  (commit `735a292`, latest.json `data_updated 16:50:53Z`); Mac launchd
+  `com.apt.fuelboard-{relay,relay-api,mirror}` unloaded + plists parked in
+  `~/Library/LaunchAgents/fuelboard-migrated-to-ct/`; editor 8790 + IPA 8765
+  stay on the Mac; price watchdog `relay_price_watchdog.py` now fetches via
+  SSH (`~/.ssh/fuelboard_ct` → `/root/scripts/watchdog_fetch.py`). Logs via
+  `journalctl -u fuelboard-*` on the CT; SSH into CT: `ssh -i ~/.ssh/fuelboard_ct root@192.168.1.113`.
+  **Open: rootfs is 2 GB (1.1 GB free) — mirror retention ~940 MB will get
+  tight; rootfs grown to 8 GB on pve 2026-08-16 (5.9 GB free).**
+
 - [x] **Siri: "Cheapest [fuel] near me"** — `AppShortcutsProvider` + `CheapestFuelIntent`
   (App Intents, iOS 16+), dialog + price-card snippet, cached full-UK dump first
   with freshness label ("as of 6am"), last-known-location fallback. Constraint:
   fresh-data path needs a reachable source off-LAN — cached answers work anywhere
-  the app has previously fetched (see P3 data mirror). Interim: the relay on
-  Tailscale (100.120.217.98:8789) is reachable off-LAN for testing; relay will
-  move to a permanent box or the GitHub mirror long-term. *DONE — radius-scoped
+  the app has previously fetched (the GitHub mirror serves this now). *DONE —
+  radius-scoped
   lookup `037c241` (real-data regression: GULF HISTON 100.9p 132 mi away),
   per-fuel literal-word shortcuts `e55078c`, names = app words `a3b6f37`, plus
   Directions-to-cheapest `caadf18` + spoken hand-off `aed99e3`.*
 - [ ] **Siri: "Closest [fuel] station"** — same plumbing as cheapest, sort by
   distance instead of price. Free second phrase in the same `AppShortcutsProvider`.
+- [x] **Favourites Trends graph** — price history chart for starred stations.
+  Swift Charts (iOS 26 target) line chart in the Favourites tab; one series per
+  favourite, fuel-scoped (station, fuel) pairs map 1:1 to the archive. Default =
+  absolute price lines; toggle "vs cheapest favourite" re-baselines to 0 as signed
+  pence (mirrors the Cheapest/Closest delta pattern users already know). Reuse the
+  capsule fuel picker; range control 7/30/90 days; respects the price-display
+  toggle; honest empty-state copy in Localizable.strings ("Prices are recorded from
+  each refresh — check back in a few days"). No widget in v1 (one-kind rule).
+  Depends on the P0 archive. *DONE 2026-08-15, merged to main 2026-08-16:
+  `Shared/FuelHistory.swift` (FuelHistoryStore: day math, slim day decode w/ shared
+  band, series + deltaSeries, app-group favourites-only cache, parallel per-day
+  fetches) + `FuelBoard/TrendsView.swift` (chart, fuel capsule, 7/30/90, Price/vs
+  cheapest, per-station legend, empty/loading/retry states) + toolbar entry in
+  FavouritesView + strings. 83 tests incl. URL regression (appendingPathComponent
+  — URL(string:relativeTo:) dropped /main, all fetches 404'd). Sim-verified:
+  favourites rows + TOP/deltas; sheet controls + honest empty state w/ live first-
+  snapshot date. Pending: lines render once ≥2 snapshots (archive warming daily,
+  ~Aug 17).*
 
 ## P2 — Later
 
@@ -62,13 +106,30 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
   scene (CPListTemplate) for navigation deep-links.
 - [ ] **Alert region tuning** — make alert trigger radius + dedup window
   user-configurable (currently fixed 300 m trigger / 1 per station per hour).
+- [ ] **Price-drop alerts: threshold control + Check now** — keep the current
+  cache-first / 12 h refresh policy, but add a per-alert sensitivity control
+  for favourite price-drop alerts instead of a fetch-frequency slider. Scope:
+  `Minimum change` picker (e.g. 0.5p / 1.0p / 2.0p), plus a `Check now`
+  action in the Alerts tab that forces a fetch and immediately re-evaluates the
+  cheapest-favourite alert. Copy should set expectation honestly: standard
+  mode checks when FuelBoard refreshes prices (up to twice daily).
+- [ ] **Price-drop alerts: optional frequent-check mode** — if the app ever
+  relaxes the current "twice daily max" data policy, expose this as a clearly
+  separate mode rather than a freeform frequency slider. Example framing:
+  `Standard` (current behaviour) vs `Frequent` (best-effort extra checks),
+  with conservative caps (e.g. every 4–6 h, not hourly) and copy that does not
+  promise exact timing under iOS background scheduling.
 - [ ] **Pull-to-refresh spinner state** — surface refresh in-flight state
   (currently `refreshable` fires but no visible progress in the row list).
-- [ ] **Offline first-run** — first launch without network currently shows empty
-  states; bundle a sample dump so the app demos offline.
+- [x] **Offline first-run** — bundled REAL 8,022-station dump (`FuelBoardDump`,
+  refreshed by `scripts/refresh_bundled_dump.sh`) is the no-network last resort
+  in the live chain (P0, 2026-08-16); first launch demos the full dataset offline.
 - [ ] **Localization** — UK English only today; audit string catalog for l10n.
 - [ ] **Dark mode polish** — verify brand logos (white-circle clips) and RAG dot
   contrast under dark appearance on-device.
+- [ ] **Trends: national average overlay + per-day min/max** — the full dump is
+  already held, so the UK/regional average line is computable locally; archive can
+  store per-day min/max so the chart shows intraday spikes, not just the daily point.
 
 ## P3 — Ideas / Research
 
@@ -78,19 +139,55 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
 - [ ] **App Intents testing** — AppIntentsTesting (iOS 27) for intent coverage
   instead of XCUITest when the Siri features land.
 
-- [ ] **Production data mirror (GitHub)** — relay pushes the synced dump
-  (`stations.json` + `latest.json` version pointer) to a PUBLIC GitHub repo; the
-  app fetches `raw.githubusercontent.com` with the LAN relay as fallback source.
-  Public repo required for App Review (reviewer must fetch the data themselves);
-  HTTPS/ATS fine; plain JSON data is not "remote code" (2.5.2-safe); bundle a small
-  fallback dump so the app never demos empty. Needs GitHub PAT (aptonline account).
-- [ ] **Fuel-price prediction** — trend from historical dumps (relay could keep a
-  rolling archive) to show "price tends up/down".
+- [ ] **Fuel-price prediction** — "price tends up/down" arrow derived from the
+  price-history archive (P0). Cheap once the archive + Trends graph exist; keep a
+  separate phase. Backlog ancestry: this was the original "relay could keep a
+  rolling archive" idea — the archive is now P0 and the Trends graph (P1) is its
+  visible half.
+- [ ] **Foresight Live Activity (heading-aware next station)** — investigate a
+  driving-time surface that predicts the likely next station ahead of the user
+  from cached data only (no extra source-data refresh on motion). Best v1 shape:
+  Live Activity option, not widget-first, because widget space/refresh budgets
+  are tight and the lock-screen/CarPlay compact slot better matches the use case.
+  Prefer ONE FuelBoard Live Activity with a mode selector (e.g. `Nearby cheapest`
+  vs `Foresight / next ahead`) rather than trying to run two simultaneous
+  FuelBoard activities; iOS can support multiple activities, but FuelBoard's
+  current implementation is single-activity and the compact surfaces are too
+  constrained for two competing driving modes anyway. Viable MVP: infer heading
+  from recent motion/course, keep only stations in a forward cone, score
+  candidates by forward distance + lateral offset, and show the next-ahead
+  station with all three fuel prices or a compact rotating/focused fuel
+  treatment if space allows. Key caveat: heading is not full route awareness,
+  so avoid overpromising "the next station you will reach" on motorways/opposite
+  carriageways; frame as "next ahead" / "likely next stop" unless route-quality
+  heuristics improve. Must include hysteresis/speed thresholds to avoid flapping,
+  and should be tested specifically against compact Live Activity/CarPlay layouts
+  where space is extremely limited.
+- [ ] **Widget sparkline** — medium-widget mini sparkline of a favourite's 30-day
+  trend, after the Trends UI lands (one-kind rule preserved).
 - [ ] **Price alerts for a specific station** — notify when a starred station's
   price drops below a user threshold.
+- [ ] **Price-drop alerts: mode = Cheapest favourite / All favourites** — keep
+  `Cheapest favourite` as the default low-noise mode, but explore an optional
+  `All favourites` mode for one fuel. Guardrails if built: threshold required,
+  per-station dedupe based on last-alerted price (not just time), and combine
+  multiple drops from one refresh into a single summary notification rather
+  than one alert per station.
 - [ ] **Share sheet** — share "Cheapest Unleaded near me" as text/image card.
-- [ ] **Watch app** — glanceable cheapest-price complication (WatchKit + shared
-  app-group store; watch target would need to be added to the project).
+- [ ] **Watch app v1 — favourites + Check now** — small Apple Watch companion,
+  not a phone-app clone. Favourites-first home screen: fuel picker, `Cheapest
+  favourite` summary card, top few favourites for that fuel, last-updated time,
+  and a prominent `Check now` action that forces a refresh + re-evaluates
+  favourite prices. Keep the watch UX pull-based and glanceable; avoid implying
+  high-frequency background refresh. Shared-store architecture preferred over a
+  second watch-only data model.
+- [ ] **Watch complications / Smart Stack** — complication/widget surfaces for
+  the same watch concept: show the cheapest favourite price, fuel, and short
+  station name at a glance. Keep copy minimal and honest about freshness.
+- [ ] **Watch app v2 — favourite detail + handoff** — tap a favourite row for a
+  detail screen (station, brand, price, last updated) with actions like
+  `Directions` and `Open on iPhone`. Reuse existing maps handoff patterns where
+  possible instead of inventing watch-only navigation logic.
 - [ ] **App Clip** — 10 MB budget for "find cheapest fuel nearby" without install.
 - [ ] **Widget picker: dual-unit distance labels** — the Edit-Widget Distance row
   label is cached by the system at sheet-render time and only re-resolves on
@@ -109,6 +206,20 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
 
 ## Done (recent)
 
+- [x] **GitHub price-history mirror + LIVE provider chain (P0, DONE 2026-08-16)** —
+  push side (relay → public `aptonline/fuelboard-data`, daily 10:00 launchd, SSH
+  deploy key, 180-day retention) + history read side (Trends, P1) + **live chain
+  (`feature/p0-live-chain`)**: `MirrorFuelProvider` fetches CURRENT prices from
+  raw.githubusercontent (latest.json → history/<day>.json, app-group day-cache) →
+  **GitHub FIRST everywhere** (alert checks + widget too — the relay is
+  unreachable from any consumer phone and attempting it would fire the Local
+  Network prompt); LAN relay joins ONLY behind the hidden dev flag
+  `fuelboard.relayFallback` (Settings → Debug, off by default); bundled REAL
+  dump (`FuelBoardDump` dataset, refreshed by `scripts/refresh_bundled_dump.sh`)
+  is the app's no-network last resort. `FuelBeacon` fire-and-forget X-Client app
+  ping fires only with the dev flag on. **Local Network permission removed from
+  onboarding entirely** — data page is informational, replay on cellular can no
+  longer hang. 95 tests.
 - [x] Switch dataset to govuk API data — official Fuel Finder OAuth API via
   relay-api :8789 (source: api, ~8,012 stations); app baseURL → :8789; credentials
   live in relay `.env` only, never in the IPA

Config/App-Info.plist

@@ -16,6 +16,8 @@
 	<string>$(PRODUCT_NAME)</string>
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleURLTypes</key>
 	<array>
 		<dict>
@@ -27,22 +29,25 @@
 			</array>
 		</dict>
 	</array>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
 	<key>CFBundleVersion</key>
-	<string>1</string>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
-	<key>NSLocationWhenInUseUsageDescription</key>
-	<string>FuelBoard uses your location to find the cheapest nearby petrol stations.</string>
+	<key>NSLocalNetworkUsageDescription</key>
+	<string>FuelBoard can optionally connect to the FuelBoard Relay on your local network for faster alerts during development.</string>
 	<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
 	<string>FuelBoard uses Always location to alert you when you approach the cheapest station nearby.</string>
-	<key>NSLocalNetworkUsageDescription</key>
-	<string>FuelBoard connects to the FuelBoard Relay on your local network to download the latest fuel prices.</string>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>FuelBoard uses your location to find the cheapest nearby petrol stations.</string>
 	<key>NSSupportsLiveActivities</key>
 	<true/>
+	<key>BGTaskSchedulerPermittedIdentifiers</key>
+	<array>
+		<string>com.apt.fuelboard.smart-refresh</string>
+	</array>
 	<key>UIBackgroundModes</key>
 	<array>
+		<string>fetch</string>
 		<string>location</string>
 	</array>
 	<key>UILaunchScreen</key>

Config/WatchApp.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.application-groups</key>
+	<array>
+		<string>group.com.apt.fuelboard</string>
+	</array>
+</dict>
+</plist>

Config/WatchExtension-Info.plist

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>FuelBoardWatch</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionAttributes</key>
+		<dict>
+			<key>WKAppBundleIdentifier</key>
+			<string>com.apt.fuelboard.watchapp</string>
+		</dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.watchkit</string>
+	</dict>
+</dict>
+</plist>

Config/WatchWrapper-Info.plist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>FuelBoard</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>FuelBoard</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+	</array>
+	<key>WKCompanionAppBundleIdentifier</key>
+	<string>com.apt.fuelboard</string>
+	<key>WKWatchKitApp</key>
+	<true/>
+</dict>
+</plist>

Config/Widget-Info.plist

@@ -17,15 +17,15 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
+	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleVersion</key>
-	<string>1</string>
-	<key>NSLocationWhenInUseUsageDescription</key>
-	<string>FuelBoard uses your location to show the cheapest nearby petrol stations.</string>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSExtension</key>
 	<dict>
 		<key>NSExtensionPointIdentifier</key>
 		<string>com.apple.widgetkit-extension</string>
 	</dict>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>FuelBoard uses your location to show the cheapest nearby petrol stations.</string>
 </dict>
 </plist>

FuelBoard.xcodeproj/project.pbxproj

@@ -1,7 +1,4 @@
 // !$*UTF8*$!
-// FuelBoard — hand-crafted project (objectVersion 77, synchronized folders).
-// Targets: FuelBoard (app) + FuelBoardWidgets (widget extension, embedded).
-// Shared/ is a synchronized root group included in BOTH targets.
 {
 	archiveVersion = 1;
 	classes = {
@@ -10,10 +7,26 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		ADCE5B5A3033A32C008C131C /* FuelBoardWatch Watch App.app in Embed Watch Content */ = {isa = PBXBuildFile; fileRef = ADCE5B4F3033A329008C131C /* FuelBoardWatch Watch App.app */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
+		ADCE5B623033A32D008C131C /* FuelBoardWatch Watch App Extension.appex in Embed App Extensions */ = {isa = PBXBuildFile; fileRef = ADCE5B633033A32D008C131C /* FuelBoardWatch Watch App Extension.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
 		BB0000000000000000000001 /* FuelBoardWidgets.appex in Embed App Extensions */ = {isa = PBXBuildFile; fileRef = BB0000000000000000000002 /* FuelBoardWidgets.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
+		ADCE5B643033A32D008C131C /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = BB0000000000000000000004 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = ADCE5B4E3033A329008C131C;
+			remoteInfo = "FuelBoardWatch Watch App Extension";
+		};
+		ADCE5B6F3033A32F008C131C /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = BB0000000000000000000004 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = ADCE5B673033A32D008C131C;
+			remoteInfo = "FuelBoardWatch Watch App";
+		};
 		BB0000000000000000000003 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = BB0000000000000000000004 /* Project object */;
@@ -24,6 +37,28 @@
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
+		ADCE5B5B3033A32C008C131C /* Embed Watch Content */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "$(CONTENTS_FOLDER_PATH)/Watch";
+			dstSubfolderSpec = 16;
+			files = (
+				ADCE5B5A3033A32C008C131C /* FuelBoardWatch Watch App.app in Embed Watch Content */,
+			);
+			name = "Embed Watch Content";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		ADCE5B653033A32D008C131C /* Embed App Extensions */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 13;
+			files = (
+				ADCE5B623033A32D008C131C /* FuelBoardWatch Watch App Extension.appex in Embed App Extensions */,
+			);
+			name = "Embed App Extensions";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		BB0000000000000000000006 /* Embed App Extensions */ = {
 			isa = PBXCopyFilesBuildPhase;
 			buildActionMask = 2147483647;
@@ -38,11 +73,23 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		ADCE5B4F3033A329008C131C /* FuelBoardWatch Watch App.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "FuelBoardWatch Watch App.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+		ADCE5B633033A32D008C131C /* FuelBoardWatch Watch App Extension.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = "FuelBoardWatch Watch App Extension.appex"; sourceTree = BUILT_PRODUCTS_DIR; };
 		BB0000000000000000000002 /* FuelBoardWidgets.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = FuelBoardWidgets.appex; sourceTree = BUILT_PRODUCTS_DIR; };
 		BB0000000000000000000007 /* FuelBoard.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = FuelBoard.app; sourceTree = BUILT_PRODUCTS_DIR; };
 /* End PBXFileReference section */
 
 /* Begin PBXFileSystemSynchronizedRootGroup section */
+		ADCE5B503033A329008C131C /* FuelBoardWatch Watch App */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			path = "FuelBoardWatch Watch App";
+			sourceTree = "<group>";
+		};
+		ADCE5B663033A32D008C131C /* FuelBoardWatch Wrapper */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			path = "FuelBoardWatch Wrapper";
+			sourceTree = "<group>";
+		};
 		BB0000000000000000000008 /* FuelBoard */ = {
 			isa = PBXFileSystemSynchronizedRootGroup;
 			path = FuelBoard;
@@ -61,6 +108,20 @@
 /* End PBXFileSystemSynchronizedRootGroup section */
 
 /* Begin PBXFrameworksBuildPhase section */
+		ADCE5B4C3033A329008C131C /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		ADCE5B6D3033A32E008C131C /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		BB000000000000000000000B /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
@@ -84,6 +145,8 @@
 				BB0000000000000000000008 /* FuelBoard */,
 				BB0000000000000000000009 /* FuelBoardWidgets */,
 				BB000000000000000000000A /* Shared */,
+				ADCE5B663033A32D008C131C /* FuelBoardWatch Wrapper */,
+				ADCE5B503033A329008C131C /* FuelBoardWatch Watch App */,
 				BB000000000000000000000E /* Products */,
 			);
 			sourceTree = "<group>";
@@ -93,6 +156,8 @@
 			children = (
 				BB0000000000000000000007 /* FuelBoard.app */,
 				BB0000000000000000000002 /* FuelBoardWidgets.appex */,
+				ADCE5B4F3033A329008C131C /* FuelBoardWatch Watch App.app */,
+				ADCE5B633033A32D008C131C /* FuelBoardWatch Watch App Extension.appex */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -100,30 +165,50 @@
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
-		BB000000000000000000000F /* FuelBoard */ = {
+		ADCE5B4E3033A329008C131C /* FuelBoardWatch Watch App Extension */ = {
 			isa = PBXNativeTarget;
-			buildConfigurationList = BB0000000000000000000010 /* Build configuration list for PBXNativeTarget "FuelBoard" */;
+			buildConfigurationList = ADCE5B593033A32B008C131C /* Build configuration list for PBXNativeTarget "FuelBoardWatch Watch App Extension" */;
 			buildPhases = (
-				BB0000000000000000000011 /* Sources */,
-				BB000000000000000000000B /* Frameworks */,
-				BB0000000000000000000012 /* Resources */,
-				BB0000000000000000000006 /* Embed App Extensions */,
+				ADCE5B4B3033A329008C131C /* Sources */,
+				ADCE5B4C3033A329008C131C /* Frameworks */,
+				ADCE5B4D3033A329008C131C /* Resources */,
 			);
 			buildRules = (
 			);
 			dependencies = (
-				BB0000000000000000000013 /* PBXTargetDependency */,
 			);
 			fileSystemSynchronizedGroups = (
-				BB0000000000000000000008 /* FuelBoard */,
-				BB000000000000000000000A /* Shared */,
+				ADCE5B503033A329008C131C /* FuelBoardWatch Watch App */,
 			);
-			name = FuelBoard;
+			name = "FuelBoardWatch Watch App Extension";
 			packageProductDependencies = (
 			);
-			productName = FuelBoard;
-			productReference = BB0000000000000000000007 /* FuelBoard.app */;
-			productType = "com.apple.product-type.application";
+			productName = "FuelBoardWatch Watch App Extension";
+			productReference = ADCE5B633033A32D008C131C /* FuelBoardWatch Watch App Extension.appex */;
+			productType = "com.apple.product-type.watchkit2-extension";
+		};
+		ADCE5B673033A32D008C131C /* FuelBoardWatch Watch App */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = ADCE5B6A3033A32D008C131C /* Build configuration list for PBXNativeTarget "FuelBoardWatch Watch App" */;
+			buildPhases = (
+				ADCE5B6E3033A32E008C131C /* Resources */,
+				ADCE5B653033A32D008C131C /* Embed App Extensions */,
+				ADCE5B6D3033A32E008C131C /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				ADCE5B683033A32D008C131C /* PBXTargetDependency */,
+			);
+			fileSystemSynchronizedGroups = (
+				ADCE5B663033A32D008C131C /* FuelBoardWatch Wrapper */,
+			);
+			name = "FuelBoardWatch Watch App";
+			packageProductDependencies = (
+			);
+			productName = "FuelBoardWatch Watch App";
+			productReference = ADCE5B4F3033A329008C131C /* FuelBoardWatch Watch App.app */;
+			productType = "com.apple.product-type.application.watchapp2";
 		};
 		BB0000000000000000000005 /* FuelBoardWidgets */ = {
 			isa = PBXNativeTarget;
@@ -148,6 +233,33 @@
 			productReference = BB0000000000000000000002 /* FuelBoardWidgets.appex */;
 			productType = "com.apple.product-type.app-extension";
 		};
+		BB000000000000000000000F /* FuelBoard */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = BB0000000000000000000010 /* Build configuration list for PBXNativeTarget "FuelBoard" */;
+			buildPhases = (
+				BB0000000000000000000011 /* Sources */,
+				BB000000000000000000000B /* Frameworks */,
+				BB0000000000000000000012 /* Resources */,
+				ADCE5B5B3033A32C008C131C /* Embed Watch Content */,
+				BB0000000000000000000006 /* Embed App Extensions */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				ADCE5B703033A32F008C131C /* PBXTargetDependency */,
+				BB0000000000000000000013 /* PBXTargetDependency */,
+			);
+			fileSystemSynchronizedGroups = (
+				BB0000000000000000000008 /* FuelBoard */,
+				BB000000000000000000000A /* Shared */,
+			);
+			name = FuelBoard;
+			packageProductDependencies = (
+			);
+			productName = FuelBoard;
+			productReference = BB0000000000000000000007 /* FuelBoard.app */;
+			productType = "com.apple.product-type.application";
+		};
 /* End PBXNativeTarget section */
 
 /* Begin PBXProject section */
@@ -155,15 +267,18 @@
 			isa = PBXProject;
 			attributes = {
 				BuildIndependentTargetsInParallel = 1;
-				LastSwiftUpdateCheck = 1600;
+				LastSwiftUpdateCheck = 2630;
 				LastUpgradeCheck = 1600;
 				TargetAttributes = {
-					BB000000000000000000000F = {
-						CreatedOnToolsVersion = 16.0;
+					ADCE5B4E3033A329008C131C = {
+						CreatedOnToolsVersion = 26.3;
 					};
 					BB0000000000000000000005 = {
 						CreatedOnToolsVersion = 16.0;
 					};
+					BB000000000000000000000F = {
+						CreatedOnToolsVersion = 16.0;
+					};
 				};
 			};
 			buildConfigurationList = BB0000000000000000000017 /* Build configuration list for PBXProject "FuelBoard" */;
@@ -182,11 +297,27 @@
 			targets = (
 				BB000000000000000000000F /* FuelBoard */,
 				BB0000000000000000000005 /* FuelBoardWidgets */,
+				ADCE5B673033A32D008C131C /* FuelBoardWatch Watch App */,
+				ADCE5B4E3033A329008C131C /* FuelBoardWatch Watch App Extension */,
 			);
 		};
 /* End PBXProject section */
 
 /* Begin PBXResourcesBuildPhase section */
+		ADCE5B4D3033A329008C131C /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		ADCE5B6E3033A32E008C131C /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		BB0000000000000000000012 /* Resources */ = {
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
@@ -204,6 +335,13 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
+		ADCE5B4B3033A329008C131C /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		BB0000000000000000000011 /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
@@ -221,6 +359,16 @@
 /* End PBXSourcesBuildPhase section */
 
 /* Begin PBXTargetDependency section */
+		ADCE5B683033A32D008C131C /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = ADCE5B4E3033A329008C131C /* FuelBoardWatch Watch App Extension */;
+			targetProxy = ADCE5B643033A32D008C131C /* PBXContainerItemProxy */;
+		};
+		ADCE5B703033A32F008C131C /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = ADCE5B673033A32D008C131C /* FuelBoardWatch Watch App */;
+			targetProxy = ADCE5B6F3033A32F008C131C /* PBXContainerItemProxy */;
+		};
 		BB0000000000000000000013 /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = BB0000000000000000000005 /* FuelBoardWidgets */;
@@ -229,6 +377,266 @@
 /* End PBXTargetDependency section */
 
 /* Begin XCBuildConfiguration section */
+		ADCE5B573033A32B008C131C /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_ENTITLEMENTS = Config/WatchApp.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = "Config/WatchExtension-Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.0;
+				MTL_FAST_MATH = YES;
+				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.watchapp.watchkitextension;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = watchos;
+				SKIP_INSTALL = YES;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)";
+				SWIFT_APPROACHABLE_CONCURRENCY = YES;
+				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 4;
+				WATCHOS_DEPLOYMENT_TARGET = 26.2;
+			};
+			name = Debug;
+		};
+		ADCE5B583033A32B008C131C /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_ENTITLEMENTS = Config/WatchApp.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = "Config/WatchExtension-Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.0;
+				MTL_FAST_MATH = YES;
+				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.watchapp.watchkitextension;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = watchos;
+				SKIP_INSTALL = YES;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_APPROACHABLE_CONCURRENCY = YES;
+				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 4;
+				WATCHOS_DEPLOYMENT_TARGET = 26.2;
+			};
+			name = Release;
+		};
+		ADCE5B6B3033A32D008C131C /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = "Config/WatchWrapper-Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.0;
+				MTL_FAST_MATH = YES;
+				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.watchapp;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = watchos;
+				SKIP_INSTALL = YES;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)";
+				SWIFT_APPROACHABLE_CONCURRENCY = YES;
+				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 4;
+				WATCHOS_DEPLOYMENT_TARGET = 26.2;
+			};
+			name = Debug;
+		};
+		ADCE5B6C3033A32D008C131C /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = "Config/WatchWrapper-Info.plist";
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.0;
+				MTL_FAST_MATH = YES;
+				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.watchapp;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = watchos;
+				SKIP_INSTALL = YES;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_APPROACHABLE_CONCURRENCY = YES;
+				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 4;
+				WATCHOS_DEPLOYMENT_TARGET = 26.2;
+			};
+			name = Release;
+		};
 		BB0000000000000000000018 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
@@ -291,14 +699,15 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CODE_SIGN_ENTITLEMENTS = Config/App.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
 				GENERATE_INFOPLIST_FILE = NO;
-				INFOPLIST_FILE = Config/App-Info.plist;
+				INFOPLIST_FILE = "Config/App-Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.0.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -313,14 +722,15 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CODE_SIGN_ENTITLEMENTS = Config/App.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
 				GENERATE_INFOPLIST_FILE = NO;
-				INFOPLIST_FILE = Config/App-Info.plist;
+				INFOPLIST_FILE = "Config/App-Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.0.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_EMIT_LOC_STRINGS = YES;
@@ -335,15 +745,16 @@
 				APPLICATION_EXTENSION_API_ONLY = YES;
 				CODE_SIGN_ENTITLEMENTS = Config/Widget.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
 				GENERATE_INFOPLIST_FILE = NO;
-				INFOPLIST_FILE = Config/Widget-Info.plist;
+				INFOPLIST_FILE = "Config/Widget-Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.0.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.widgets;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
@@ -359,15 +770,16 @@
 				APPLICATION_EXTENSION_API_ONLY = YES;
 				CODE_SIGN_ENTITLEMENTS = Config/Widget.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 20;
+				DEVELOPMENT_TEAM = F3BE6NE7U3;
 				GENERATE_INFOPLIST_FILE = NO;
-				INFOPLIST_FILE = Config/Widget-Info.plist;
+				INFOPLIST_FILE = "Config/Widget-Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.0.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.apt.fuelboard.widgets;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
@@ -380,11 +792,20 @@
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
-		BB0000000000000000000017 /* Build configuration list for PBXProject "FuelBoard" */ = {
+		ADCE5B593033A32B008C131C /* Build configuration list for PBXNativeTarget "FuelBoardWatch Watch App Extension" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
-				BB0000000000000000000018 /* Debug */,
-				BB0000000000000000000019 /* Release */,
+				ADCE5B573033A32B008C131C /* Debug */,
+				ADCE5B583033A32B008C131C /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		ADCE5B6A3033A32D008C131C /* Build configuration list for PBXNativeTarget "FuelBoardWatch Watch App" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				ADCE5B6B3033A32D008C131C /* Debug */,
+				ADCE5B6C3033A32D008C131C /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
@@ -407,6 +828,15 @@
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
+		BB0000000000000000000017 /* Build configuration list for PBXProject "FuelBoard" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				BB0000000000000000000018 /* Debug */,
+				BB0000000000000000000019 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
 /* End XCConfigurationList section */
 	};
 	rootObject = BB0000000000000000000004 /* Project object */;

FuelBoard/AlertsView.swift

@@ -12,6 +12,8 @@ struct AlertsView: View {
     @Binding var enabled: Bool
     @Binding var radius: Double   // stored in km (monitor + storage)
     @Binding var fuel: FuelType   // the fuel alerts monitor for
+    @Binding var favouriteDropEnabled: Bool
+    @Binding var favouriteDropFuel: FuelType
     /// Whether alerts mirror the Stations-tab search distance (capped at 8 mi).
     @Binding var followsSearch: Bool
     /// Whether the "cheapest nearby" Live Activity is shown on the Lock Screen
@@ -30,6 +32,7 @@ struct AlertsView: View {
     let distanceUnit: DistanceUnit
     let monitoredCount: Int
     let lastAlert: String?
+    let onCheckFavouriteDropNow: () -> Void
 
     /// The Stations-tab search distance shown in the user's unit, e.g.
     /// "5 miles" or "8 km" — for the "Follow search" rows.
@@ -46,6 +49,34 @@ struct AlertsView: View {
         return "\(shown) \(distanceUnit.label(for: Double(shown)))"
     }
 
+    /// Situational guidance for the currently-selected alert radius, shown
+    /// under the picker so users know what each choice is best for. Labels
+    /// mirror the picker row text (unit-aware) and explain the trade-off:
+    /// smaller radii ping more often but later; larger radii ping rarely in
+    /// town but earlier from afar.
+    private var alertRadiusGuidance: String {
+        switch alertChoice.wrappedValue {
+        case .followSearch:
+            return "Set-and-forget: alerts behave exactly like the Stations-tab search distance (capped at 8 miles for reliable geofencing)."
+        case .fixed(let value):
+            let optionLabel = "\(value) \(distanceUnit.label(for: Double(value)))"
+            let body: String
+            switch value {
+            case 1:
+                body = "Town driving. Fires most often — you're rarely inside the circle for long, so pings are meaningful. Best for stop-start local trips."
+            case 2:
+                body = "City or suburb commute. Slightly earlier heads-up than the smallest option; still fires regularly around town."
+            case 3:
+                body = "Mixed driving. Middle ground: heads-up a few minutes out, still works in most towns."
+            case 5:
+                body = "A-roads and motorway exits. Wide early warning for longer trips — but in town it rarely fires, because you're usually already inside the circle."
+            default:
+                body = "Long-distance journeys. Maximum reach: a ping when a cheap station is coming up from far out. In town this essentially never fires."
+            }
+            return "\(optionLabel) — \(body)"
+        }
+    }
+
     private enum AlertRadiusChoice: Hashable {
         case followSearch
         case fixed(Int)
@@ -103,7 +134,22 @@ struct AlertsView: View {
         NavigationStack {
             List {
                 Section {
-                    Toggle("Cheapest-station alerts", isOn: $enabled)
+                    Toggle("Cheapest favourite", isOn: $favouriteDropEnabled)
+                    Picker("Fuel", selection: $favouriteDropFuel) {
+                        ForEach(FuelType.allCases) { fuel in
+                            Text(fuel.displayName).tag(fuel)
+                        }
+                    }
+                    Button("Check now", action: onCheckFavouriteDropNow)
+                        .disabled(!favouriteDropEnabled)
+                } header: {
+                    Text("Price-drop alerts")
+                } footer: {
+                    Text("Watches your cheapest saved favourite for the fuel you pick here. FuelBoard alerts when a different favourite becomes the cheapest, or when your current cheapest favourite drops by at least 1.0p. This is separate from the nearby-geofence alert, so you can monitor favourites without extra location noise.")
+                }
+
+                Section {
+                    Toggle("Cheapest station", isOn: $enabled)
                     Picker("Fuel", selection: $fuel) {
                         ForEach(FuelType.allCases) { fuel in
                             Text(fuel.displayName).tag(fuel)
@@ -115,15 +161,18 @@ struct AlertsView: View {
                             Text("\(value) \(distanceUnit.label(for: Double(value)))").tag(AlertRadiusChoice.fixed(value))
                         }
                     }
+                    Text(alertRadiusGuidance)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
                     if enabled && monitoredCount == 0 {
                         Text("No stations monitored yet — open the Stations tab to load prices first.")
                             .font(.caption)
                             .foregroundStyle(.secondary)
                     }
                 } header: {
-                    Text("Cheapest-station alerts")
+                    Text("Proximity alerts")
                 } footer: {
-                    Text("When you approach a station that is the cheapest within the radius, FuelBoard sends a notification — even with the app closed. Nearby stations selling \(fuel.displayName.lowercased()) are watched — favourites get priority — and each station alerts at most once per hour. Follow search mirrors the Stations-tab distance, capped at 8 miles for reliable geofencing.")
+                    Text("When you approach a station that is the cheapest within the radius, FuelBoard sends a notification — even with the app closed. Nearby stations selling \(fuel.displayName.lowercased()) are watched — favourites get priority — and each station alerts at most once per hour. Follow search mirrors the Stations-tab distance, capped at 8 miles for reliable geofencing. Smaller radii ping more often but later; larger radii ping rarely in town but earlier from afar.")
                 }
 
                 if enabled, let lastAlert {
@@ -134,7 +183,7 @@ struct AlertsView: View {
                 }
 
                 Section {
-                    Toggle("Live Activity", isOn: $liveActivityEnabled)
+                    Toggle("Cheapest station", isOn: $liveActivityEnabled)
                     Picker("Fuel", selection: $liveActivityFuel) {
                         ForEach(FuelType.allCases) { fuel in
                             Text(fuel.displayName).tag(fuel)

FuelBoard/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -29,6 +29,138 @@
       "idiom": "universal",
       "platform": "ios",
       "size": "1024x1024"
+    },
+    {
+      "filename": "Watch-NotificationCenter-48.png",
+      "idiom": "watch",
+      "role": "notificationCenter",
+      "scale": "2x",
+      "size": "24x24",
+      "subtype": "38mm"
+    },
+    {
+      "filename": "Watch-NotificationCenter-55.png",
+      "idiom": "watch",
+      "role": "notificationCenter",
+      "scale": "2x",
+      "size": "27.5x27.5",
+      "subtype": "42mm"
+    },
+    {
+      "filename": "Watch-NotificationCenter-66.png",
+      "idiom": "watch",
+      "role": "notificationCenter",
+      "scale": "2x",
+      "size": "33x33",
+      "subtype": "45mm"
+    },
+    {
+      "filename": "Watch-CompanionSettings-58.png",
+      "idiom": "watch",
+      "role": "companionSettings",
+      "scale": "2x",
+      "size": "29x29"
+    },
+    {
+      "filename": "Watch-CompanionSettings-87.png",
+      "idiom": "watch",
+      "role": "companionSettings",
+      "scale": "3x",
+      "size": "29x29"
+    },
+    {
+      "filename": "Watch-AppLauncher-80.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "40x40",
+      "subtype": "38mm"
+    },
+    {
+      "filename": "Watch-AppLauncher-88.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "44x44",
+      "subtype": "40mm"
+    },
+    {
+      "filename": "Watch-AppLauncher-92.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "46x46",
+      "subtype": "41mm"
+    },
+    {
+      "filename": "Watch-AppLauncher-100.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "50x50",
+      "subtype": "44mm"
+    },
+    {
+      "filename": "Watch-AppLauncher-102.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "51x51",
+      "subtype": "45mm"
+    },
+    {
+      "filename": "Watch-AppLauncher-108.png",
+      "idiom": "watch",
+      "role": "appLauncher",
+      "scale": "2x",
+      "size": "54x54",
+      "subtype": "49mm"
+    },
+    {
+      "filename": "Watch-QuickLook-172.png",
+      "idiom": "watch",
+      "role": "quickLook",
+      "scale": "2x",
+      "size": "86x86",
+      "subtype": "38mm"
+    },
+    {
+      "filename": "Watch-QuickLook-196.png",
+      "idiom": "watch",
+      "role": "quickLook",
+      "scale": "2x",
+      "size": "98x98",
+      "subtype": "42mm"
+    },
+    {
+      "filename": "Watch-QuickLook-216.png",
+      "idiom": "watch",
+      "role": "quickLook",
+      "scale": "2x",
+      "size": "108x108",
+      "subtype": "44mm"
+    },
+    {
+      "filename": "Watch-QuickLook-234.png",
+      "idiom": "watch",
+      "role": "quickLook",
+      "scale": "2x",
+      "size": "117x117",
+      "subtype": "45mm"
+    },
+    {
+      "filename": "Watch-QuickLook-258.png",
+      "idiom": "watch",
+      "role": "quickLook",
+      "scale": "2x",
+      "size": "129x129",
+      "subtype": "49mm"
+    },
+    {
+      "filename": "Watch-Marketing-1024.png",
+      "idiom": "watch-marketing",
+      "scale": "1x",
+      "size": "1024x1024"
     }
   ],
   "info": {

FuelBoard/Assets.xcassets/AppIconPreview.imageset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "filename" : "AppIconPreview.png",
+      "idiom" : "universal",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

FuelBoard/Assets.xcassets/AppIconPreviewDark.imageset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "filename" : "AppIconPreviewDark.png",
+      "idiom" : "universal",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

FuelBoard/Assets.xcassets/FuelBoardDump.dataset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  },
+  "data" : [
+    {
+      "filename" : "fuelboard_dump.json",
+      "idiom" : "universal"
+    }
+  ]
+}

FuelBoard/Assets.xcassets/PreviewWallpaper.imageset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "filename" : "PreviewWallpaper.jpg",
+      "idiom" : "universal",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

FuelBoard/Assets.xcassets/brand_circle_k.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_circle_k_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_circle_k_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_essar.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_essar_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_essar_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_gleaner.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_gleaner_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_gleaner_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_highland_fuels.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_highland_fuels_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_highland_fuels_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_maxol.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_maxol_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_maxol_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_murco.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_murco_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_murco_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_spar.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_spar_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_spar_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_the_co_operative.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_the_co_operative_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_the_co_operative_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_valero.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_valero_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_valero_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/Assets.xcassets/brand_welcome_break.imageset/Contents.json

@@ -0,0 +1,18 @@
+{
+  "images": [
+    {
+      "filename": "brand_welcome_break_2x.png",
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "filename": "brand_welcome_break_3x.png",
+      "idiom": "universal",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}

FuelBoard/BundledDumpProvider.swift

@@ -0,0 +1,28 @@
+// BundledDumpProvider.swift — no-network last resort (P0 live chain).
+//
+// A REAL snapshot of the mirror dump is bundled into the app (FuelBoardDump
+// dataset, refreshed before builds by scripts/refresh_bundled_dump.sh) so the
+// app never demos empty and App Review always sees real data even fully
+// offline. Same relay envelope, so the shared decode applies unchanged.
+
+import UIKit
+
+enum BundledDumpProvider {
+    /// The bundled real snapshot, decoded with the shared relay decode —
+    /// nil only if the asset is missing or corrupt (callers then fall back
+    /// to the England-wide sample set).
+    static var stations: [FuelStation]? {
+        guard let asset = NSDataAsset(name: "FuelBoardDump") else { return nil }
+        return try? FuelPriceProvider.decodeStations(from: asset.data)
+    }
+
+    /// The GOV.UK `data_updated` stamp from the bundled envelope (ISO 8601).
+    /// Labels the offline-data banner honestly ("Offline data from 15 Aug")
+    /// instead of presenting the build's snapshot as live.
+    static var dataUpdatedStamp: String? {
+        guard let asset = NSDataAsset(name: "FuelBoardDump"),
+              let obj = try? JSONSerialization.jsonObject(with: asset.data)
+                  as? [String: Any] else { return nil }
+        return obj["data_updated"] as? String
+    }
+}

FuelBoard/ContentView.swift

@@ -2,18 +2,32 @@ import SwiftUI
 import CoreLocation
 import WidgetKit
 
+/// The single floating notification banner. Network/offline state and tip
+/// outcomes all funnel through ONE style and render via the same chrome in
+/// ContentView — never pushing layout, always overlaid.
+enum AppBanner: Hashable {
+    case offlineDump(date: String)
+    case connectionProblem
+    case tip(TipStore.TipOutcome)
+}
+
 struct ContentView: View {
     @Environment(\.scenePhase) private var scenePhase
 
     @State private var stations: [FuelStation] = FuelStore.loadStations()
     @State private var selectedFuel: FuelType = FuelStore.loadSelectedFuel()
+    @State private var dataRefreshMode: DataRefreshMode = FuelStore.loadDataRefreshMode()
     @State private var sortMode: SortMode = FuelStore.loadSortMode()
     @State private var stationLimit: Int = FuelStore.loadStationLimit()
     @State private var distanceUnit: DistanceUnit = FuelStore.loadDistanceUnit()
+    @State private var priceDisplayStyle: PriceDisplayStyle = FuelStore.loadPriceDisplayStyle()
+    @State private var stationTapAction: StationTapAction = FuelStore.loadStationTapAction()
     @State private var favourites: [FavouriteEntry] = FuelStore.loadFavourites()
     @State private var alertsEnabled: Bool = FuelStore.loadAlertsEnabled()
     @State private var alertsRadius: Double = FuelStore.loadAlertsRadius()
     @State private var alertsFuel: FuelType = FuelStore.loadAlertsFuel()
+    @State private var favouriteDropAlertsEnabled: Bool = FuelStore.loadFavouriteDropAlertsEnabled()
+    @State private var favouriteDropAlertsFuel: FuelType = FuelStore.loadFavouriteDropAlertsFuel()
     @State private var alertsFollowsSearch: Bool = FuelStore.loadAlertsFollowsSearch()
     @State private var liveActivityEnabled: Bool = FuelStore.loadLiveActivityEnabled()
     @State private var liveActivityFuel: FuelType = FuelStore.loadLiveActivityFuel()
@@ -29,11 +43,75 @@ struct ContentView: View {
     private var effectiveAlertsRadiusKM: Double {
         FuelStore.effectiveAlertsRadiusKM(followsSearch: alertsFollowsSearch, manualKM: alertsRadius)
     }
+
+    private func installLocationUpdateHook() {
+        locationManager.onLocationUpdate = { [weak monitor] in
+            monitor?.update(stations: stations, favourites: refreshedFavourites,
+                            fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
+            // The Live Activity follows the same wake-ups — this hook
+            // fires on every fix incl. background significant-change
+            // wake-ups, so the Lock Screen pill stays live while driving.
+            updateLiveActivity()
+            refreshRoadDistancesIfNeeded()
+        }
+    }
+
+    /// Kicks off a (throttled) Apple-Maps road-distance recompute for the
+    /// stations around the current fix. The app owns routing — the widget and
+    /// Live Activity only read the cached result. Falls back to the last saved
+    /// location so it can run before the first fresh GPS fix arrives.
+    private func refreshRoadDistancesIfNeeded() {
+        let origin = location ?? FuelStore.loadLocation()
+        guard let origin else { return }
+        Task {
+            await RoadDistanceService.refreshIfNeeded(
+                stations: stations,
+                lat: origin.lat,
+                lng: origin.lng
+            )
+        }
+    }
+
+    private func ensureBackgroundMotionTrackingIfNeeded() {
+        if alertsEnabled || liveActivityEnabled {
+            locationManager.startBackgroundTracking()
+        }
+    }
+
     @State private var isLoading = false
     @State private var statusMessage = ""
+    /// What data is on screen, driving which (if any) status banner shows
+    /// above the tabs:
+    ///  - `.live`: fetched or cached data — nothing to say.
+    ///  - `.offlineDump(date)`: serving the BUNDLED no-network snapshot —
+    ///    the banner labels it honestly with the snapshot's own date.
+    ///  - `.connectionProblem`: fetch failed but a saved cache is showing —
+    ///    the banner says to check connectivity (tap = retry).
+    enum DataSourceStatus: Equatable {
+        case live
+        case offlineDump(date: String)
+        case connectionProblem
+    }
+    @State private var dataStatus: DataSourceStatus = .live
     @State private var showOnboarding = false
+    @State private var showWidgetMock = false
+    @State private var selectedTab = 0
     @State private var locationManager = LocationManager()
     @StateObject private var monitor = ProximityMonitor()
+    /// Owns tip purchases; the single instance is shared down to Settings.
+    /// Its transient outcome rides the SAME status-banner chrome as the
+    /// network/offline strip (ContentView renders it above the tabs).
+    @StateObject private var tipStore = TipStore()
+
+    // --- Explicit banner animation state (robust fade-out) ---
+    // SwiftUI's removal transition for the banner proved unreliable here
+    // (the tip faded to nothing only in the cross-nil case, and even then
+    // inconsistently). Drive opacity/offset explicitly instead so a
+    // dismissal ALWAYS fades + slides up on ANY banner change.
+    @State private var currentBanner: AppBanner?
+    @State private var bannerOpacity: Double = 0
+    @State private var bannerOffset: CGFloat = 0
+    @State private var bannerClearTask: Task<Void, Never>?
 
     /// The pool the list draws from. In Cheapest mode the chosen miles radius
     /// bounds it ("best price within X miles"); in Closest mode the radius is
@@ -136,87 +214,169 @@ struct ContentView: View {
     }
 
     var body: some View {
-        TabView {
-            StationsView(
-                stations: displayedStations,
-                totalCount: sortedStations.count,
-                isLoading: isLoading,
-                selectedFuel: $selectedFuel,
-                sortMode: $sortMode,
-                stationLimit: $stationLimit,
-                distanceUnit: distanceUnit,
-                baselinePrice: baselinePrice,
-                topStationID: topStationID,
-                location: location,
-                favouriteIDs: favouriteIDs,
-                onToggleFavourite: toggleFavourite,
-                onRefresh: { await refresh(force: true) }
-            )
-            .tabItem { Label("Stations", systemImage: "fuelpump.fill") }
-
-            FavouritesView(
-                favourites: refreshedFavourites,
-                selectedFuel: selectedFuel,
-                location: location,
-                distanceUnit: distanceUnit,
-                onToggleFavourite: toggleFavourite,
-                onReorder: reorderFavourites
-            )
-            .tabItem { Label("Favourites", systemImage: "star.fill") }
-
-            AlertsView(
-                enabled: $alertsEnabled,
-                radius: $alertsRadius,
-                fuel: $alertsFuel,
-                followsSearch: $alertsFollowsSearch,
-                liveActivityEnabled: $liveActivityEnabled,
-                liveActivityFuel: $liveActivityFuel,
-                liveActivityRadiusMiles: $liveActivityRadiusMiles,
-                liveActivityFollowsSearch: $liveActivityFollowsSearch,
-                stationLimit: stationLimit,
-                distanceUnit: distanceUnit,
-                monitoredCount: monitor.monitoredStationIDs.count,
-                lastAlert: monitor.lastAlert
-            )
-            .tabItem { Label("Alerts", systemImage: "bell.fill") }
-
-            settingsTab
+        configuredContent
     }
+
+    private var configuredContent: AnyView {
+        interactionObservedContent
+    }
+
+    private var presentedContent: AnyView {
+        AnyView(
+            mainContent
                 .fullScreenCover(isPresented: $showOnboarding) {
                     OnboardingView {
                         showOnboarding = false
                     }
                 }
+                .fullScreenCover(isPresented: $showWidgetMock) {
+                    WidgetMockScreen()
+                }
                 .sheet(item: $monitor.pendingStationMap) { request in
                     StationMapView(request: request)
                 }
+                .sheet(item: $monitor.pendingDetailStation) { station in
+                    StationDetailView(
+                        station: station,
+                        location: location,
+                        distanceUnit: distanceUnit
+                    )
+                }
+                .onReceive(NotificationCenter.default.publisher(for: .fuelBoardShowStationDetail)) { note in
+                    let info = note.userInfo ?? [:]
+                    if let id = info["stationID"] as? String,
+                       let station = stations.first(where: { $0.id == id }) {
+                        monitor.pendingDetailStation = station
+                        return
+                    }
+                    // Station left the cache — fall back to the map sheet so
+                    // the tap still shows something.
+                    if let lat = info["stationLat"] as? Double,
+                       let lng = info["stationLng"] as? Double {
+                        let name = info["stationName"] as? String ?? "Station"
+                        monitor.pendingStationMap = StationMapRequest(
+                            name: name, latitude: lat, longitude: lng
+                        )
+                    }
+                }
+        )
+    }
+
+    private var lifecycleObservedContent: AnyView {
+        AnyView(
+            presentedContent
                 .onAppear {
+            // Launch-arg hooks for the screenshot/UI-test harness (same
+            // pattern as StationsView's `-showKeySheet`): `-tab <name>`
+            // opens the given tab; `-skipOnboarding` skips onboarding
+            // without touching the stored flag.
+            let args = ProcessInfo.processInfo.arguments
+#if DEBUG
+            showWidgetMock = args.contains("-widgets")
+            // `-seedFavourite <substring>` pins the first matching station
+            // for Unleaded via the normal save path (keychain + app group)
+            // so screenshot captures can show a populated Favourites tab.
+            // Repeatable: each occurrence adds another favourite (QA temp).
+            // Optional ":fuel" suffix (e10|e5|diesel) picks the
+            // fuel, so the fuel-aware Trends open can be verified (QA temp).
+            let seedQueries = args.enumerated()
+                .filter { $0.element == "-seedFavourite" }
+                .compactMap { i, _ in
+                    i + 1 < args.count ? args[i + 1] : nil
+                }
+            if !seedQueries.isEmpty {
+                let stations = FuelStore.loadStations()
+                var favs = seedQueries.compactMap { query in
+                    let parts = query.split(separator: ":", maxSplits: 1)
+                    let name = String(parts[0])
+                    let fuel = parts.count > 1
+                        ? FuelType(rawValue: String(parts[1])) ?? .e10
+                        : FuelType.e10
+                    return stations.first { $0.name.localizedCaseInsensitiveContains(name) }
+                        .map { FavouriteEntry(station: $0, fuel: fuel) }
+                }
+                if favs.isEmpty, let q = seedQueries.first,
+                   let s = stations.first(where: { $0.name.localizedCaseInsensitiveContains(q.split(separator: ":").first.map(String.init) ?? q) }) {
+                    favs = [FavouriteEntry(station: s, fuel: .e10)]
+                }
+                if !favs.isEmpty {
+                    FuelStore.saveFavourites(favs)
+                    WatchSyncManager.shared.pushSnapshot()
+                }
+            }
+            if let i = args.firstIndex(of: "-tab"), i + 1 < args.count {
+                switch args[i + 1] {
+                case "favourites": selectedTab = 1
+                case "alerts": selectedTab = 2
+                case "settings": selectedTab = 3
+                default: selectedTab = 0
+                }
+            }
+            // QA temp: `-fuel <e10|e5|diesel>` sets the app-wide selected
+            // fuel so the fuel-aware Trends open can be verified (simulates
+            // the user having switched to the diesel tab).
+            if let i = args.firstIndex(of: "-fuel"), i + 1 < args.count,
+               let f = FuelType(rawValue: args[i + 1]) {
+                selectedFuel = f
+                FuelStore.saveSelectedFuel(f)
+            }
+            // `-forceOfflineDump` / `-forceConnectionProblem` simulate the two
+            // failure legs for the screenshot harness. The auto-refresh below
+            // is skipped so the banner stays up (a live fetch would clear it).
+            if args.contains("-forceOfflineDump") {
+                stations = BundledDumpProvider.stations ?? SampleFuelProvider.sampleStations
+                dataStatus = .offlineDump(date: FuelStore.offlineDataLabel(from: BundledDumpProvider.dataUpdatedStamp) ?? "")
+            }
+            if args.contains("-forceConnectionProblem") {
+                stations = FuelStore.loadStations().isEmpty
+                    ? (BundledDumpProvider.stations ?? SampleFuelProvider.sampleStations)
+                    : FuelStore.loadStations()
+                dataStatus = .connectionProblem
+            }
+#else
+            showWidgetMock = false
+#endif
             // Onboarding runs first on a fresh install — it owns the initial
             // permission prompts (location, notifications, and the data/local
             // network probe on the Data page). Location tracking and the first
             // network fetch start once it's done.
-            if FuelStore.loadHasCompletedOnboarding() {
+            // Launch-arg hook (UI-testing/screenshot harness, same pattern as
+            // StationsView's `-showKeySheet`): skip onboarding without
+            // touching the stored flag.
+#if DEBUG
+            let shouldSkipOnboarding = args.contains("-skipOnboarding")
+#else
+            let shouldSkipOnboarding = false
+#endif
+            if !FuelStore.shouldShowOnboarding()
+                || shouldSkipOnboarding {
                 locationManager.startForegroundTracking()
-                // Geofences must follow the user even in the background:
-                // wire the delegate hook (fires on every fix incl. background
-                // significant-change wake-ups) to re-register the region
-                // window around the new position. SwiftUI onChange alone
-                // never runs while suspended, so alerts would otherwise stay
-                // frozen around the last foreground fix.
-                locationManager.onLocationUpdate = { [weak monitor] in
-                    monitor?.update(stations: stations, favourites: refreshedFavourites,
-                                    fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
-                    // The Live Activity follows the same wake-ups — this hook
-                    // fires on every fix incl. background significant-change
-                    // wake-ups, so the Lock Screen pill stays live while driving.
-                    updateLiveActivity()
-                }
+                // Geofences and the Live Activity must follow the user even in
+                // the background: wire the delegate hook (fires on every fix
+                // incl. background significant-change wake-ups) so SwiftUI's
+                // foreground-only onChange isn't the only update path.
+                installLocationUpdateHook()
+                ensureBackgroundMotionTrackingIfNeeded()
                 monitor.update(stations: stations, favourites: refreshedFavourites,
                                fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
                 monitor.setEnabled(alertsEnabled)
                 updateLiveActivity()
+                // Compute road distances early (throttled; falls back to the
+                // last saved location) so distance surfaces are road-matched
+                // as soon as stations are available.
+                refreshRoadDistancesIfNeeded()
                 // Refresh only when the cache is stale (twice-a-day policy).
+                // Skipped under the force-* hooks so the banner stays up.
+#if DEBUG
+                let shouldSkipInitialRefresh = args.contains("-forceOfflineDump")
+                    || args.contains("-forceConnectionProblem")
+                    || args.contains("-forceHistoryFailure")
+#else
+                let shouldSkipInitialRefresh = false
+#endif
+                if !shouldSkipInitialRefresh {
                     Task { await refresh() }
+                }
             } else {
                 showOnboarding = true
             }
@@ -231,6 +391,8 @@ struct ContentView: View {
             // empty on a brand-new install.
             if !showing, FuelStore.loadHasCompletedOnboarding() {
                 locationManager.startForegroundTracking()
+                installLocationUpdateHook()
+                ensureBackgroundMotionTrackingIfNeeded()
                 monitor.update(stations: stations, favourites: refreshedFavourites,
                                fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
                 updateLiveActivity()
@@ -248,7 +410,11 @@ struct ContentView: View {
                 monitor.update(stations: stations, favourites: refreshedFavourites,
                                fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
                 updateLiveActivity()
-                // No network fetch on foreground — pull-to-refresh is the override.
+                refreshRoadDistancesIfNeeded()
+                if FuelStore.hasPendingWatchRefreshRequest {
+                    Task { await handlePendingWatchRefreshRequest() }
+                }
+                // No network fetch on foreground unless the watch explicitly requests one.
             } else {
                 locationManager.stopForegroundTracking()
             }
@@ -257,17 +423,26 @@ struct ContentView: View {
             if let newLocation {
                 location = newLocation
                 FuelStore.saveLocation(lat: newLocation.lat, lng: newLocation.lng)
+                WatchSyncManager.shared.pushSnapshot()
                 WidgetCenter.shared.reloadAllTimelines()
                 // Geofences follow the user's position, but the station list is
                 // NOT re-fetched on every movement (cached, twice-a-day policy).
                 monitor.update(stations: stations, favourites: refreshedFavourites,
                                fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
                 updateLiveActivity()
+                refreshRoadDistancesIfNeeded()
             }
         }
+        )
+    }
+
+    private var interactionObservedContent: AnyView {
+        AnyView(
+            lifecycleObservedContent
                 .onChange(of: selectedFuel) { _, _ in
             // No re-fetch needed — one response carries E5/E10/DIESEL prices.
             WidgetCenter.shared.reloadAllTimelines()
+            WatchSyncManager.shared.pushSnapshot()
         }
         .onChange(of: stationLimit) { _, newValue in
             // Distance filter is LOCAL math now — the cache holds the full-UK
@@ -288,9 +463,7 @@ struct ContentView: View {
             monitor.setEnabled(newValue)
             monitor.update(stations: stations, favourites: refreshedFavourites,
                            fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
-            if newValue {
-                locationManager.startBackgroundTracking()
-            }
+            ensureBackgroundMotionTrackingIfNeeded()
         }
         .onChange(of: alertsRadius) { _, newValue in
             FuelStore.saveAlertsRadius(newValue)
@@ -311,10 +484,17 @@ struct ContentView: View {
             monitor.update(stations: stations, favourites: refreshedFavourites,
                            fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
         }
+        .onChange(of: favouriteDropAlertsEnabled) { _, newValue in
+            FuelStore.saveFavouriteDropAlertsEnabled(newValue)
+        }
+        .onChange(of: favouriteDropAlertsFuel) { _, newValue in
+            FuelStore.saveFavouriteDropAlertsFuel(newValue)
+        }
         .onChange(of: liveActivityEnabled) { _, newValue in
             // Toggling the Live Activity on starts it with the current best
             // station; toggling off ends any running activity.
             FuelStore.saveLiveActivityEnabled(newValue)
+            ensureBackgroundMotionTrackingIfNeeded()
             updateLiveActivity()
         }
         .onChange(of: liveActivityFuel) { _, newValue in
@@ -342,13 +522,220 @@ struct ContentView: View {
                                fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
             }
         }
+        .onChange(of: priceDisplayStyle) { _, newValue in
+            // The pill carries its own display style in content state — push
+            // an update so the running activity re-renders in the new style
+            // immediately. Pass the style explicitly: SettingsView saves it
+            // in its own onChange, whose ordering vs this one isn't guaranteed,
+            // so reading storage here could push the OLD style.
+            updateLiveActivity(priceDisplayStyleOverride: newValue)
+        }
+        )
+    }
+
+    /// The one banner to show right now. Network/offline and tip outcomes all
+    /// funnel here and render through the SAME floating chrome. A transient
+    /// tip (auto-dismissed by TipStore) takes precedence over the persistent
+    /// network state for its ~3.5 s.
+    private var activeBanner: AppBanner? {
+        if let outcome = tipStore.outcome { return .tip(outcome) }
+        switch dataStatus {
+        case .live: return nil
+        case .offlineDump(let date): return .offlineDump(date: date)
+        case .connectionProblem: return .connectionProblem
+        }
+    }
+
+    private var mainContent: some View {
+        GeometryReader { geo in
+            ZStack(alignment: .top) {
+                rootTabView
+                if let banner = currentBanner {
+                    // Floating near the top of the screen, over the nav area —
+                    // overlays content (never pushes it) and sits above the
+                    // main content so it doesn't cover or block the list/pill
+                    // beneath it. Opacity/offset are driven explicitly by
+                    // reflectBanner so the fade-out reliably animates.
+                    floatingBanner(banner)
+                        .padding(.top, geo.safeAreaInsets.top + 10)
+                        .opacity(bannerOpacity)
+                        .offset(y: bannerOffset)
+                }
+            }
+        }
+        .task(id: activeBanner) {
+            // Fires on launch with the current banner AND whenever it changes —
+            // unlike onChange(computed) which can miss the first non-nil value
+            // when dataStatus is set slightly after the view appears.
+            reflectBanner(activeBanner)
+        }
+    }
+
+    /// Explicitly animates the banner in/out — a robust replacement for the
+    /// SwiftUI removal transition (which was silently not firing). Handles:
+    ///  - first appearance → fade + settle down from slightly above
+    ///  - any content change (tip→network, new tip) → fade the old out, then
+    ///    fade the new in — so a tip ALWAYS visibly fades away
+    ///  - dismissal → fade out + slide up, then clear after the fade
+    private func reflectBanner(_ newBanner: AppBanner?) {
+        guard newBanner != currentBanner else { return }
+        bannerClearTask?.cancel()
+        if let newBanner {
+            if currentBanner == nil {
+                present(newBanner)
+            } else {
+                // Crossfade: slide+fade the current out, then present the new.
+                withAnimation(.easeOut(duration: 0.2)) {
+                    bannerOpacity = 0
+                    bannerOffset = -28
+                }
+                bannerClearTask = Task { @MainActor in
+                    try? await Task.sleep(nanoseconds: 250_000_000)
+                    guard !Task.isCancelled else { return }
+                    present(newBanner)
+                }
+            }
+        } else {
+            withAnimation(.easeOut(duration: 0.35)) {
+                bannerOpacity = 0
+                bannerOffset = -28
+            }
+            bannerClearTask = Task { @MainActor in
+                try? await Task.sleep(nanoseconds: 350_000_000)
+                guard !Task.isCancelled else { return }
+                currentBanner = nil
+                bannerOpacity = 0
+                bannerOffset = 0
+            }
+        }
+    }
+
+    /// Fade a banner in from slightly above and settle it into place.
+    private func present(_ banner: AppBanner) {
+        currentBanner = banner
+        bannerOpacity = 0
+        bannerOffset = -16
+        withAnimation(.easeOut(duration: 0.3)) {
+            bannerOpacity = 1
+            bannerOffset = 0
+        }
+    }
+
+    private var rootTabView: some View {
+        TabView(selection: $selectedTab) {
+            stationsTab
+                .tabItem { Label("Stations", systemImage: "fuelpump.fill") }
+                .tag(0)
+
+            favouritesTab
+                .tabItem { Label("Favourites", systemImage: "star.fill") }
+                .tag(1)
+
+            alertsTab
+                .tabItem { Label("Alerts", systemImage: "bell.fill") }
+                .tag(2)
+
+            settingsTab
+                .tag(3)
+        }
+    }
+
+    /// The banner title for the bundled-snapshot case: date when the stamp
+    /// parsed, plain "Offline data" otherwise.
+    private func offlineTitle(date: String) -> String {
+        date.isEmpty
+            ? NSLocalizedString("Offline data", comment: "")
+            : String(format: NSLocalizedString("Offline data from %@", comment: ""), date)
+    }
+
+    /// ONE floating banner style for all notifications. Network/offline and
+    /// tip outcomes share the same chrome; only the tap action differs —
+    /// network → retry the fetch, tip → dismiss (TipStore auto-dismisses too).
+    @ViewBuilder
+    private func floatingBanner(_ banner: AppBanner) -> some View {
+        switch banner {
+        case .offlineDump(let date):
+            let title = offlineTitle(date: date)
+            statusBannerCard(
+                icon: "wifi.slash", tint: .orange, title: title,
+                subtitle: NSLocalizedString("Pull to refresh on the Stations tab", comment: ""),
+                trailingIcon: "arrow.clockwise",
+                accessibilityLabel: date.isEmpty
+                    ? NSLocalizedString("Offline data. Pull to refresh on the Stations tab", comment: "")
+                    : String(format: NSLocalizedString("Offline data from %@. Pull to refresh on the Stations tab", comment: ""), date)
+            ) {
+                Task { await refresh(force: true) }
+            }
+        case .connectionProblem:
+            statusBannerCard(
+                icon: "wifi.exclamationmark", tint: .red,
+                title: NSLocalizedString("Check your internet connection", comment: ""),
+                subtitle: NSLocalizedString("Tap to try again", comment: ""),
+                trailingIcon: "arrow.clockwise",
+                accessibilityLabel: NSLocalizedString("Check your internet connection. Tap to try again", comment: "")
+            ) {
+                Task { await refresh(force: true) }
+            }
+        case .tip(let outcome):
+            statusBannerCard(
+                icon: outcome.icon, tint: outcome.tint, title: outcome.message, subtitle: nil,
+                trailingIcon: "xmark", accessibilityLabel: outcome.message
+            ) {
+                withAnimation(.easeOut(duration: 0.2)) { tipStore.dismissOutcome() }
+            }
+        }
+    }
+
+    /// The single floating-banner chrome shared by every notification
+    /// (network/offline + tip). Overlaid — never in flow — so it never moves
+    /// the content beneath it.
+    private func statusBannerCard(icon: String, tint: Color, title: String, subtitle: String?,
+                                  trailingIcon: String, accessibilityLabel: String,
+                                  action: @escaping () -> Void) -> some View {
+        Button(action: action) {
+            HStack(spacing: 10) {
+                Image(systemName: icon)
+                    .font(.system(size: 17, weight: .semibold))
+                    .foregroundStyle(tint)
+                    .frame(width: 30)
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(title)
+                        .font(.subheadline.weight(.semibold))
+                        .foregroundStyle(.primary)
+                    if let subtitle {
+                        Text(subtitle)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
+                Spacer()
+                Image(systemName: trailingIcon)
+                    .font(.system(size: 14, weight: .semibold))
+                    .foregroundStyle(tint)
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 10)
+            .background(
+                RoundedRectangle(cornerRadius: 12, style: .continuous)
+                    .fill(Color(.secondarySystemGroupedBackground))
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 12, style: .continuous)
+                            .stroke(tint.opacity(0.35), lineWidth: 1)
+                    )
+                    .shadow(color: .black.opacity(0.08), radius: 8, y: 3)
+            )
+            .padding(.horizontal, 12)
+        }
+        .contentShape(Rectangle())
+        .buttonStyle(.plain)
+        .accessibilityLabel(accessibilityLabel)
     }
 
     /// Pushes the current best-in-radius station into the Live Activity.
     /// No-op (or ends the activity) when the toggle is off or there's no
     /// location/data yet. Uses the Live Activity's OWN fuel + radius (set in
     /// Settings) — independent of the Stations-tab fuel/distance.
-    private func updateLiveActivity() {
+    private func updateLiveActivity(priceDisplayStyleOverride: PriceDisplayStyle? = nil) {
         // "Follow search" mirrors the Stations-tab distance exactly (no cap —
         // the pill only displays, it doesn't geofence).
         let radiusKM = liveActivityFollowsSearch
@@ -359,7 +746,71 @@ struct ContentView: View {
             fuel: liveActivityFuel,
             radiusKM: radiusKM,
             location: location,
-            enabled: liveActivityEnabled
+            enabled: liveActivityEnabled,
+            priceDisplayStyle: priceDisplayStyleOverride
+        )
+    }
+
+    /// The Stations tab, extracted from `body` so the TabView expression stays
+    /// within the compiler's type-check budget.
+    private var stationsTab: some View {
+        StationsView(
+            stations: displayedStations,
+            totalCount: sortedStations.count,
+            isLoading: isLoading,
+            selectedFuel: $selectedFuel,
+            sortMode: $sortMode,
+            stationLimit: $stationLimit,
+            distanceUnit: distanceUnit,
+            priceDisplayStyle: priceDisplayStyle,
+            baselinePrice: baselinePrice,
+            topStationID: topStationID,
+            location: location,
+            favouriteIDs: favouriteIDs,
+            stationTapAction: stationTapAction,
+            onToggleFavourite: toggleFavourite,
+            onRefresh: { await refresh(force: true) }
+        )
+    }
+
+    /// The Favourites tab, extracted from `body` for the same type-check
+    /// budget reason.
+    private var favouritesTab: some View {
+        FavouritesView(
+            favourites: refreshedFavourites,
+            selectedFuel: selectedFuel,
+            location: location,
+            distanceUnit: distanceUnit,
+            priceDisplayStyle: priceDisplayStyle,
+            stationTapAction: stationTapAction,
+            onToggleFavourite: toggleFavourite,
+            onReorder: reorderFavourites,
+            onHistoryUnavailable: { if dataStatus == .live { dataStatus = .connectionProblem } },
+            onHistoryRecovered: { if dataStatus == .connectionProblem { dataStatus = .live } }
+        )
+    }
+
+    /// The Alerts tab, extracted from `body` so the TabView expression stays
+    /// within the compiler's type-check budget.
+    private var alertsTab: some View {
+        AlertsView(
+            enabled: $alertsEnabled,
+            radius: $alertsRadius,
+            fuel: $alertsFuel,
+            favouriteDropEnabled: $favouriteDropAlertsEnabled,
+            favouriteDropFuel: $favouriteDropAlertsFuel,
+            followsSearch: $alertsFollowsSearch,
+            liveActivityEnabled: $liveActivityEnabled,
+            liveActivityFuel: $liveActivityFuel,
+            liveActivityRadiusMiles: $liveActivityRadiusMiles,
+            liveActivityFollowsSearch: $liveActivityFollowsSearch,
+            stationLimit: stationLimit,
+            distanceUnit: distanceUnit,
+            monitoredCount: monitor.monitoredStationIDs.count,
+            lastAlert: monitor.lastAlert,
+            onCheckFavouriteDropNow: {
+                Task { await refresh(force: true) }
+            }
         )
     }
 
@@ -367,7 +818,11 @@ struct ContentView: View {
     /// within the compiler's type-check budget.
     private var settingsTab: some View {
         SettingsView(
+            tipStore: tipStore,
             distanceUnit: $distanceUnit,
+            priceDisplayStyle: $priceDisplayStyle,
+            stationTapAction: $stationTapAction,
+            dataRefreshMode: $dataRefreshMode,
             alertsFuel: alertsFuel,
             alertsRadiusKM: alertsRadius,
             testAlertResult: monitor.lastTestResult,
@@ -378,7 +833,12 @@ struct ContentView: View {
             debugStatus: monitor.debugStatus,
             appCheapest: appCheapestStatus,
             regionError: monitor.lastRegionError,
-            monitoredCount: monitor.monitoredStationIDs.count
+            monitoredCount: monitor.monitoredStationIDs.count,
+            alertLog: monitor.alertLog,
+            regionEventCount: monitor.regionEventCount,
+            debugFenceIdentifier: monitor.debugFenceIdentifier,
+            onDebugFence: { monitor.registerDebugFenceAroundMe() },
+            onClearDebugFence: { monitor.clearDebugFence() }
         )
         .tabItem { Label("Settings", systemImage: "gearshape.fill") }
     }
@@ -391,6 +851,7 @@ struct ContentView: View {
             favourites.append(key)
         }
         FuelStore.saveFavourites(favourites)
+        WatchSyncManager.shared.pushSnapshot()
         WidgetCenter.shared.reloadAllTimelines()
         monitor.update(stations: stations, favourites: refreshedFavourites,
                        fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
@@ -402,11 +863,17 @@ struct ContentView: View {
     private func reorderFavourites(_ newOrder: [FavouriteEntry]) {
         favourites = newOrder
         FuelStore.saveFavourites(favourites)
+        WatchSyncManager.shared.pushSnapshot()
         WidgetCenter.shared.reloadAllTimelines()
         monitor.update(stations: stations, favourites: refreshedFavourites,
                        fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
     }
 
+    private func handlePendingWatchRefreshRequest() async {
+        guard FuelStore.hasPendingWatchRefreshRequest else { return }
+        await refresh(force: true)
+    }
+
     /// Fetches fresh prices, but only when the cache is stale — unless
     /// `force` is true (pull-to-refresh is the manual override).
     private func refresh(force: Bool = false) async {
@@ -416,6 +883,7 @@ struct ContentView: View {
         isLoading = true
         defer { isLoading = false }
         do {
+            let previousFavouriteSnapshots = FuelStore.loadFavouriteAlertSnapshots()
             let fetched = try await FuelPriceProvider.active.fetchStations(
                 near: location?.lat, lng: location?.lng,
                 fuel: selectedFuel,
@@ -424,9 +892,14 @@ struct ContentView: View {
             stations = fetched
             FuelStore.saveStations(fetched)
             FuelStore.saveLastRefresh()
-            // Persist relay envelope metadata (source, station count, GOV.UK
-            // dataset update time) for the Settings → About section.
-            if let meta = RelayFuelProvider.latestMeta {
+            if force, FuelStore.hasPendingWatchRefreshRequest {
+                FuelStore.markWatchRefreshHandled()
+            }
+            WatchSyncManager.shared.pushSnapshot()
+            // Persist envelope metadata (source, station count, GOV.UK
+            // dataset update time) for the Settings → About section — the
+            // live chain records whichever leg served the fetch.
+            if let meta = LiveChainProvider.latestMeta {
                 FuelStore.saveRelayMeta(meta)
             }
             // Keep the keychain favourites fresh with the new prices — the
@@ -434,11 +907,38 @@ struct ContentView: View {
             // channel shared on SideStore free), so stale star-time snapshots
             // would otherwise show old prices.
             FuelStore.saveFavourites(refreshedFavourites)
+            monitor.evaluateFavouritePriceDropAlert(
+                favourites: refreshedFavourites,
+                previousSnapshots: previousFavouriteSnapshots,
+                monitoredFuel: favouriteDropAlertsFuel,
+                enabled: favouriteDropAlertsEnabled
+            )
             WidgetCenter.shared.reloadAllTimelines()
             statusMessage = "Loaded \(fetched.count) stations · \(Date().formatted(date: .omitted, time: .shortened))"
+            // Live data restored — any status banner no longer applies.
+            dataStatus = .live
         } catch {
-            statusMessage = "Live fetch failed: \(error.localizedDescription). Showing cached/sample data."
-            stations = FuelStore.loadStations().isEmpty ? SampleFuelProvider.sampleStations : FuelStore.loadStations()
+            if force, FuelStore.hasPendingWatchRefreshRequest {
+                FuelStore.markWatchRefreshHandled()
+            }
+            statusMessage = "Live fetch failed: \(error.localizedDescription). Showing cached data."
+            if FuelStore.loadStations().isEmpty {
+                // No cached prices — last resort is the bundled REAL dump
+                // (stale but genuine), then the demo sample set. The banner
+                // labels the bundled snapshot honestly with its own date.
+                if let dump = BundledDumpProvider.stations {
+                    stations = dump
+                    dataStatus = .offlineDump(date: FuelStore.offlineDataLabel(from: BundledDumpProvider.dataUpdatedStamp) ?? "")
+                } else {
+                    stations = SampleFuelProvider.sampleStations
+                    dataStatus = .live
+                }
+            } else {
+                // Saved prices are still on screen — but the fetch failed, so
+                // say so: a stale cache must not look like a live app.
+                stations = FuelStore.loadStations()
+                dataStatus = .connectionProblem
+            }
         }
         // Keep monitor geofences in sync with the freshest data.
         monitor.update(stations: stations, favourites: refreshedFavourites,
@@ -455,10 +955,13 @@ struct StationRow: View {
     let fuel: FuelType
     let location: Coordinate?
     let distanceUnit: DistanceUnit
+    let priceDisplayStyle: PriceDisplayStyle
     let baselinePrice: Double?
     let isTopResult: Bool
     let isFavourite: Bool
+    var tapAction: StationTapAction = .openMap
     var onToggleFavourite: () -> Void = {}
+    var onShowDetails: (FuelStation) -> Void = { _ in }
 
     private var ragColor: Color {
         guard let price = station.prices[fuel], let baselinePrice else { return .gray }
@@ -478,6 +981,21 @@ struct StationRow: View {
         return String(format: "%+.1fp", delta)
     }
 
+    private func handleTap() {
+        switch tapAction {
+        case .openMap:
+            if let url = station.mapsDirectionsURL {
+                UIApplication.shared.open(url)
+            }
+        case .showDetails:
+            showDetails()
+        }
+    }
+
+    private func showDetails() {
+        onShowDetails(station)
+    }
+
     var body: some View {
         HStack(spacing: 12) {
             // LEFT — round brand logo (or generic fuel pump fallback)
@@ -489,14 +1007,14 @@ struct StationRow: View {
                         .padding(5)
                 } else {
                     Image(systemName: "fuelpump.fill")
-                        .font(.system(size: 22))
-                        .foregroundStyle(.white)
+                        .font(.system(size: 22, weight: .semibold))
+                        .foregroundStyle(Color.black.opacity(0.82))
                 }
             }
             .frame(width: 46, height: 46)
-            .background(Circle().fill(.white))
+            .background(Circle().fill(Color.white))
             .clipShape(Circle())
-            .overlay(Circle().stroke(Color.primary.opacity(0.08), lineWidth: 1))
+            .overlay(Circle().stroke(Color.primary.opacity(0.10), lineWidth: 1))
             .shadow(color: .black.opacity(0.08), radius: 2, y: 1)
 
             // MIDDLE — name, full address, distance
@@ -514,6 +1032,12 @@ struct StationRow: View {
                             .background(Capsule().fill(.blue.opacity(0.15)))
                             .foregroundStyle(.blue)
                     }
+                    ForEach(StationNotice.notices(for: station)) { notice in
+                        Image(systemName: notice.symbolName)
+                            .font(.caption2.weight(.semibold))
+                            .foregroundStyle(.secondary)
+                            .accessibilityLabel(notice.title)
+                    }
                 }
                 Text("\(station.address), \(station.postcode)")
                     .font(.caption)
@@ -521,7 +1045,7 @@ struct StationRow: View {
                     .lineLimit(1)
                     .truncationMode(.tail)
                 if let location {
-                    Text(distanceUnit.format(station.distanceKM(to: location.lat, lng2: location.lng)))
+                    Text(distanceUnit.format(FuelStore.displayDistanceKM(station: station, userLat: location.lat, userLng: location.lng)))
                         .font(.caption2)
                         .foregroundStyle(.secondary)
                         .monospacedDigit()
@@ -536,9 +1060,7 @@ struct StationRow: View {
                         Circle()
                             .fill(ragColor)
                             .frame(width: 8, height: 8)
-                        Text(String(format: "£%.3f", price / 100))
-                            .font(.title3.bold().monospaced())
-                            .monospacedDigit()
+                        FuelStore.priceTextAttributed(price, style: priceDisplayStyle, size: 20, weight: .bold)
                     }
                     if let deltaText {
                         Text(deltaText)
@@ -558,11 +1080,8 @@ struct StationRow: View {
             .buttonStyle(.borderless)
         }
         .contentShape(Rectangle())
-        .onTapGesture {
-            if let url = station.mapsDirectionsURL {
-                UIApplication.shared.open(url)
-            }
-        }
+        .onTapGesture(perform: handleTap)
+        .onLongPressGesture(perform: showDetails)
     }
 }
 

FuelBoard/FavouritesView.swift

@@ -13,9 +13,15 @@ struct FavouritesView: View {
     let selectedFuel: FuelType
     let location: Coordinate?
     let distanceUnit: DistanceUnit
+    let priceDisplayStyle: PriceDisplayStyle
+    let stationTapAction: StationTapAction
     var onToggleFavourite: (FuelStation, FuelType) -> Void = { _, _ in }
     /// Persists a reordered favourites array (after drag-and-drop).
     var onReorder: ([FavouriteEntry]) -> Void = { _ in }
+    /// Propagated from ContentView — Trends' history failure with no data
+    /// raises the global connection banner; recovery clears it.
+    var onHistoryUnavailable: (() -> Void)? = nil
+    var onHistoryRecovered: (() -> Void)? = nil
 
     /// Fuel types that currently have at least one favourite — these are the
     /// only tabs shown (a fuel with no favourites gets no tab).
@@ -29,6 +35,12 @@ struct FavouritesView: View {
     /// favourites (e.g. the last one is un-starred while viewing it).
     @State private var fuel: FuelType = .e10
 
+    /// Trends sheet (price history chart) presentation state.
+    @State private var showTrends = false
+
+    /// Station picked for the More-info sheet (tap action = showDetails).
+    @State private var detailStation: FuelStation?
+
     private var activeFuel: FuelType {
         availableFuels.contains(fuel) ? fuel : (availableFuels.first ?? .e10)
     }
@@ -56,14 +68,22 @@ struct FavouritesView: View {
          selectedFuel: FuelType,
          location: Coordinate?,
          distanceUnit: DistanceUnit,
+         priceDisplayStyle: PriceDisplayStyle,
+         stationTapAction: StationTapAction,
          onToggleFavourite: @escaping (FuelStation, FuelType) -> Void = { _, _ in },
-         onReorder: @escaping ([FavouriteEntry]) -> Void = { _ in }) {
+         onReorder: @escaping ([FavouriteEntry]) -> Void = { _ in },
+         onHistoryUnavailable: (() -> Void)? = nil,
+         onHistoryRecovered: (() -> Void)? = nil) {
         self.favourites = favourites
         self.selectedFuel = selectedFuel
         self.location = location
         self.distanceUnit = distanceUnit
+        self.priceDisplayStyle = priceDisplayStyle
+        self.stationTapAction = stationTapAction
         self.onToggleFavourite = onToggleFavourite
         self.onReorder = onReorder
+        self.onHistoryUnavailable = onHistoryUnavailable
+        self.onHistoryRecovered = onHistoryRecovered
         _fuel = State(initialValue: selectedFuel)
     }
 
@@ -111,10 +131,13 @@ struct FavouritesView: View {
                                 fuel: activeFuel,
                                 location: location,
                                 distanceUnit: distanceUnit,
+                                priceDisplayStyle: priceDisplayStyle,
                                 baselinePrice: cheapestPrice,
                                 isTopResult: index == 0,
                                 isFavourite: activeFuelFavouriteIDs.contains(station.id),
-                                onToggleFavourite: { onToggleFavourite(station, activeFuel) }
+                                tapAction: stationTapAction,
+                                onToggleFavourite: { onToggleFavourite(station, activeFuel) },
+                                onShowDetails: { detailStation = $0 }
                             )
                         }
                         .onMove(perform: moveFavourite)
@@ -136,9 +159,42 @@ struct FavouritesView: View {
             .navigationTitle("Favourites")
             .toolbar {
                 if !favourites.isEmpty {
+                    ToolbarItemGroup(placement: .topBarTrailing) {
+                        Button {
+                            showTrends = true
+                        } label: {
+                            Image(systemName: "chart.xyaxis.line")
+                                .accessibilityLabel("Trends")
+                        }
                         EditButton()
                     }
                 }
             }
+            .sheet(isPresented: $showTrends) {
+                TrendsView(
+                    favourites: favourites,
+                    selectedFuel: activeFuel,
+                    priceDisplayStyle: priceDisplayStyle,
+                    onHistoryUnavailable: onHistoryUnavailable,
+                    onHistoryRecovered: onHistoryRecovered
+                )
+            }
+            .sheet(item: $detailStation) { station in
+                StationDetailView(
+                    station: station,
+                    location: location,
+                    distanceUnit: distanceUnit
+                )
+            }
+            .onAppear {
+#if DEBUG
+                // QA hook: launch with `-showTrends` to open the sheet
+                // without a tap (same pattern as -showKeySheet).
+                if ProcessInfo.processInfo.arguments.contains("-showTrends") {
+                    showTrends = true
+                }
+#endif
+            }
+        }
     }
 }

FuelBoard/FuelBoardApp.swift

@@ -1,13 +1,64 @@
+import ActivityKit
+import BackgroundTasks
 import SwiftUI
 
 @main
 struct FuelBoardApp: App {
+    init() {
+        WatchSyncManager.shared.activate()
+        #if DEBUG
+        // QA hook (Debug builds only): `-qaLiveActivity e10|e5|diesel` starts a
+        // Live Activity with a long station name so the Lock Screen / island
+        // layout can be rendered in the Simulator for visual QA.
+        let args = ProcessInfo.processInfo.arguments
+        if let idx = args.firstIndex(of: "-qaLiveActivity"),
+           args.indices.contains(idx + 1),
+           let fuel = FuelType(rawValue: args[idx + 1]) {
+            startQALiveActivity(fuel: fuel)
+        }
+        #endif
+    }
+
     var body: some Scene {
         WindowGroup {
             ContentView()
                 .onOpenURL(perform: handleOpenURL)
+                .onReceive(NotificationCenter.default.publisher(for: .fuelBoardWatchRefreshRequested)) { _ in
+                    WatchSyncManager.shared.pushSnapshot()
                 }
         }
+        .backgroundTask(.appRefresh(SmartDataRefreshScheduler.taskIdentifier)) {
+            await SmartDataRefreshCoordinator.runBackgroundProbe()
+        }
+    }
+
+    #if DEBUG
+    private func startQALiveActivity(fuel: FuelType) {
+        let state = FuelBoardLiveActivityAttributes.ContentState(
+            fuel: fuel,
+            stationID: "qa-phoenix",
+            stationName: "Phoenix Filling Stations",
+            brand: "Phoenix",
+            pricePence: 1499,
+            priceDisplayStyle: FuelStore.loadPriceDisplayStyle(),
+            distanceKM: 8.0,
+            lat: 51.5,
+            lng: -0.12,
+            updatedAt: Date()
+        )
+        let attrs = FuelBoardLiveActivityAttributes()
+        do {
+            let activity = try Activity.request(
+                attributes: attrs,
+                content: .init(state: state, staleDate: nil),
+                pushType: nil
+            )
+            print("QA-LIVE-ACTIVITY STARTED id=\(activity.id)")
+        } catch {
+            print("QA-LIVE-ACTIVITY FAILED: \(error)")
+        }
+    }
+    #endif
 
     /// Handles deep links that end up in the app. Widget taps arrive here in
     /// two cases:
@@ -18,9 +69,40 @@ struct FuelBoardApp: App {
     /// `http://maps.apple.com` form is also handled, from very old timelines.
     /// In CarPlay the widget uses the same `maps://` URL, which routes to
     /// Apple Maps without ever launching this app.
+    /// A `fuelboard://station?stationID=…&lat=…&lng=…&name=…` link (from a
+    /// widget or Live Activity tap when Settings → Tap station = More info)
+    /// posts a notification that ContentView observes to present the detail
+    /// sheet (falling back to the map sheet when the station has left
+    /// the cache).
     private func handleOpenURL(_ url: URL) {
-        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
-              let items = components.queryItems
+        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        else { return }
+
+        if components.scheme == "fuelboard",
+           components.host == "station" {
+            let items = components.queryItems ?? []
+            var userInfo: [String: Any] = [:]
+            if let id = items.first(where: { $0.name == "stationID" })?.value {
+                userInfo["stationID"] = id
+            }
+            if let lat = items.first(where: { $0.name == "lat" })?.value.flatMap(Double.init) {
+                userInfo["stationLat"] = lat
+            }
+            if let lng = items.first(where: { $0.name == "lng" })?.value.flatMap(Double.init) {
+                userInfo["stationLng"] = lng
+            }
+            if let name = items.first(where: { $0.name == "name" })?.value {
+                userInfo["stationName"] = name
+            }
+            NotificationCenter.default.post(
+                name: .fuelBoardShowStationDetail,
+                object: nil,
+                userInfo: userInfo
+            )
+            return
+        }
+
+        guard let items = components.queryItems
         else { return }
 
         // Preferred: maps://?daddr=lat,lng&t=d (also covers http://maps.apple.com).

FuelBoard/LiveActivityManager.swift

@@ -28,12 +28,15 @@ enum LiveActivityManager {
 
     /// Recomputes the cheapest-in-radius station and updates the activity.
     /// Passing `enabled: false` (or no usable data) ends any running activity.
+    /// `priceDisplayStyle` overrides the saved style (used when the setting
+    /// just changed and the save may not have landed yet); nil = read storage.
     static func update(
         stations: [FuelStation],
         fuel: FuelType,
         radiusKM: Double,
         location: Coordinate?,
-        enabled: Bool
+        enabled: Bool,
+        priceDisplayStyle: PriceDisplayStyle? = nil
     ) {
         guard enabled, let location else {
             end()
@@ -53,7 +56,8 @@ enum LiveActivityManager {
             stationName: best.name,
             brand: best.brand,
             pricePence: price,
-            distanceKM: best.distanceKM(to: location.lat, lng2: location.lng),
+            priceDisplayStyle: priceDisplayStyle ?? FuelStore.loadPriceDisplayStyle(),
+            distanceKM: FuelStore.displayDistanceKM(station: best, userLat: location.lat, userLng: location.lng),
             lat: best.lat,
             lng: best.lng,
             updatedAt: Date()

FuelBoard/OnboardingView.swift

@@ -47,40 +47,30 @@ struct OnboardingView: View {
                 .padding(.horizontal, 20)
                 .padding(.bottom, 24)
         }
-        // Auto-advance once the user grants a permission — the prompt itself
-        // only fires when the Continue button is tapped (after reading the
-        // page's description), never when the page merely appears.
+        // Auto-advance once the user grants a permission.
         .onChange(of: prompter.locationGranted) { _, granted in
             if granted, page == 1 { page = 2 }
         }
         .onChange(of: prompter.notificationsGranted) { _, granted in
             if granted, page == 2 { page = 3 }
         }
-        .onChange(of: prompter.dataGranted) { _, granted in
-            if granted, page == 3 {
-                // The probe result lands while the Local Network prompt is
-                // still dismissing, so without a beat the green "Connected"
-                // tick is skipped and the page jumps straight to Done —
-                // unlike the Location/Notifications pages where the granted
-                // tick is visible. Hold the tick on screen, then advance.
-                Task { @MainActor in
-                    try? await Task.sleep(nanoseconds: 800_000_000)
-                    if page == 3 { page = 4 }
-                }
-            }
-        }
-        // Replay path (test button / returning user): the Local Network
-        // permission is already decided, so probe silently up front. The
-        // probe fires no prompt once the permission is granted or denied —
-        // only the FIRST attempt (undetermined) shows the system alert, and
-        // that only happens on first run. By the time the data page appears
-        // its status is known, so it shows the green tick (or denied text)
-        // immediately, matching the Location and Notifications pages.
-        .onAppear {
-            if FuelStore.loadHasCompletedOnboarding() {
-                prompter.preflightDataAccess()
+        // Fire each permission when the user LEAVES its page by advancing
+        // forward (swipe or Continue) — by then the screen has been read.
+        // Never on arrival: a fast swipe can't stack prompts before a page
+        // is seen. Forward-only: swiping back never fires. Idempotent —
+        // an already-determined permission just refreshes, so the
+        // auto-advance path and replays stay clean (no duplicate alerts).
+        .onChange(of: page) { oldPage, newPage in
+            guard newPage > oldPage else { return }
+            if oldPage == 1 {
+                prompter.requestLocation()
+            } else if oldPage == 2 {
+                prompter.requestNotifications()
             }
         }
+        // No data-permission step: prices download from the internet (GitHub
+        // mirror) with no permission at all — Local Network was removed from
+        // the app when the relay left the consumer chain.
         .background(
             LinearGradient(
                 colors: [Color(.systemBackground), Color.accentColor.opacity(0.06)],
@@ -95,7 +85,7 @@ struct OnboardingView: View {
     private var welcomePage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
+            AnimatedOnboardingIcon(tint: .accentColor) {
                 // The app icon itself, with the standard iOS rounded-corner
                 // treatment (~22% of the size), so onboarding matches the
                 // Home Screen.
@@ -118,7 +108,7 @@ struct OnboardingView: View {
                 .padding(.horizontal, 32)
                 .padding(.top, 12)
 
-            featureRow(icon: "globe.europe.africa.fill", text: "England-wide prices — 8,000+ stations, updated twice a day")
+            featureRow(icon: "globe.europe.africa.fill", text: "UK-wide prices — 8,000+ stations, updated twice a day")
             featureRow(icon: "scope", text: "Cheapest within your chosen radius, or closest station first")
             featureRow(icon: "star.fill", text: "Favourites with instant price comparison")
             featureRow(icon: "chart.bar.fill", text: "Green/amber/red rating vs the best nearby price")
@@ -132,8 +122,7 @@ struct OnboardingView: View {
     private var locationPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
-                Circle().fill(Color.blue.opacity(0.12)).frame(width: 96, height: 96)
+            AnimatedOnboardingIcon(tint: .blue, motion: .locationArrow) {
                 Image(systemName: "location.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.blue)
@@ -164,8 +153,7 @@ struct OnboardingView: View {
     private var notificationsPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
-                Circle().fill(Color.orange.opacity(0.12)).frame(width: 96, height: 96)
+            AnimatedOnboardingIcon(tint: .orange, motion: .alarmBell) {
                 Image(systemName: "bell.badge.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.orange)
@@ -196,8 +184,7 @@ struct OnboardingView: View {
     private var dataPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
-                Circle().fill(Color.teal.opacity(0.12)).frame(width: 96, height: 96)
+            AnimatedOnboardingIcon(tint: .teal, motion: .downloadArrow) {
                 Image(systemName: "arrow.down.circle.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.teal)
@@ -207,47 +194,17 @@ struct OnboardingView: View {
             Text("Prices, ready when you are")
                 .font(.largeTitle.bold())
 
-            Text("FuelBoard downloads the latest prices from a relay on your local network — the full UK dataset, refreshed twice a day. Local network access is needed for that first download.")
+            Text("FuelBoard downloads the latest prices from the internet automatically — the full UK dataset, refreshed twice a day. No extra permissions needed.")
                 .font(.body)
                 .foregroundStyle(.secondary)
                 .multilineTextAlignment(.center)
                 .padding(.horizontal, 32)
                 .padding(.top, 12)
 
-            dataStatusLabel
-                .padding(.top, 24)
-
             Spacer()
         }
     }
 
-    @ViewBuilder
-    private var dataStatusLabel: some View {
-        if prompter.dataLoading {
-            VStack(spacing: 10) {
-                ProgressView()
-                Text("Waiting for network permission…")
-                    .font(.footnote)
-                    .foregroundStyle(.secondary)
-            }
-        } else if prompter.dataGranted {
-            // Same confirmation styling as the Location/Notifications pages.
-            Label("Connected", systemImage: "checkmark.circle.fill")
-                .foregroundStyle(.green)
-                .font(.subheadline)
-        } else if prompter.dataDenied {
-            Text("Local network access was denied — prices won't load until it's allowed, but you can keep using FuelBoard.")
-                .font(.footnote)
-                .foregroundStyle(.secondary)
-                .multilineTextAlignment(.center)
-                .padding(.horizontal, 32)
-        } else {
-            Text("The system prompt will appear next.")
-                .font(.footnote)
-                .foregroundStyle(.secondary)
-        }
-    }
-
     private var donePage: some View {
         VStack(spacing: 0) {
             Spacer()
@@ -288,39 +245,31 @@ struct OnboardingView: View {
             ) {
                 if prompter.locationDenied {
                     openSettings()
-                } else if !prompter.locationGranted {
-                    // The system prompt fires HERE — after the user has read
-                    // the description and tapped Continue — not on page appear.
-                    prompter.requestLocation()
+                } else if prompter.locationGranted {
+                    page = 2  // already decided — just move on
                 } else {
-                    page = 2
+                    // Fire the system prompt NOW, while this page is still on
+                    // screen (after it's been read) and BEFORE advancing — so
+                    // the prompt never covers the next page's animation. Auto-
+                    // advance on grant moves us on once the user responds;
+                    // denying leaves the page's "Open Settings" path.
+                    prompter.requestLocation()
                 }
             }
         case 2:
             primaryButton(
                 prompter.notificationsDenied ? "Continue without alerts" : (prompter.notificationsGranted ? "Continue" : "Allow Notifications")
             ) {
-                if prompter.notificationsDenied {
-                    page = 3
-                } else if !prompter.notificationsGranted {
-                    prompter.requestNotifications()
+                if prompter.notificationsDenied || prompter.notificationsGranted {
+                    page = 3  // decided either way — move on
                 } else {
-                    page = 3
+                    // Same rule as Location: prompt now, before advancing.
+                    prompter.requestNotifications()
                 }
             }
         case 3:
-            primaryButton(prompter.dataLoading ? "Waiting…" : "Continue") {
-                if prompter.dataGranted || prompter.dataDenied {
-                    // Prompt answered (allowed or denied) — move on to the
-                    // final slide. Never dead-end on an Open Settings button.
-                    page = 4
-                } else if !prompter.dataLoading {
-                    // Fires the Local Network prompt + relay probe here,
-                    // after the user has read the page and tapped Continue.
-                    prompter.requestDataAccess()
-                }
-            }
-            .disabled(prompter.dataLoading)
+            // No permission on this page — prices need none. Straight on.
+            primaryButton("Continue") { page = 4 }
         default:
             primaryButton("Start Using FuelBoard") { finish() }
         }
@@ -339,15 +288,15 @@ struct OnboardingView: View {
     private func featureRow(icon: String, text: LocalizedStringKey) -> some View {
         HStack(spacing: 12) {
             Image(systemName: icon)
-                .font(.system(size: 16, weight: .semibold))
+                .font(.system(size: 20, weight: .semibold))
                 .foregroundStyle(Color.accentColor)
-                .frame(width: 28)
+                .frame(width: 32)
             Text(text)
                 .font(.subheadline)
             Spacer(minLength: 0)
         }
         .padding(.horizontal, 36)
-        .padding(.vertical, 5)
+        .padding(.vertical, 10)
     }
 
     private func permissionStatusLabel(granted: Bool, denied: Bool, deniedText: LocalizedStringKey) -> some View {
@@ -382,21 +331,107 @@ struct OnboardingView: View {
     }
 }
 
+private struct AnimatedOnboardingIcon<Content: View>: View {
+    enum Motion {
+        case gentle
+        case locationArrow
+        case alarmBell
+        case downloadArrow
+    }
+
+    let tint: Color
+    var motion: Motion = .gentle
+    @ViewBuilder var content: Content
+
+    @State private var settled = false
+    @State private var iconRotation: Double = 0
+    @State private var iconOffsetY: CGFloat = 0
+    @State private var iconScale: CGFloat = 0.92
+
+    var body: some View {
+        ZStack {
+            Circle()
+                .fill(tint.opacity(0.10))
+                .frame(width: 108, height: 108)
+                .scaleEffect(settled ? 1.0 : 0.94)
+
+            Circle()
+                .stroke(tint.opacity(0.18), lineWidth: 1)
+                .frame(width: 118, height: 118)
+                .scaleEffect(settled ? 1.03 : 0.97)
+                .opacity(settled ? 1.0 : 0.55)
+
+            content
+                .scaleEffect(iconScale)
+                .rotationEffect(.degrees(iconRotation))
+                .offset(y: iconOffsetY)
+        }
+        .shadow(color: tint.opacity(0.12), radius: settled ? 12 : 4, y: settled ? 6 : 2)
+        .animation(.spring(response: 0.55, dampingFraction: 0.82), value: settled)
+        .onAppear {
+            playAnimation()
+        }
+    }
+
+    private func playAnimation() {
+        settled = false
+        iconRotation = 0
+        iconOffsetY = 4
+        iconScale = 0.92
+
+        switch motion {
+        case .gentle:
+            withAnimation(.spring(response: 0.55, dampingFraction: 0.82)) {
+                settled = true
+                iconOffsetY = 0
+                iconScale = 1.0
+            }
+
+        case .locationArrow:
+            iconRotation = -120
+            withAnimation(.linear(duration: 0.45)) {
+                settled = true
+                iconRotation = 24
+                iconOffsetY = 0
+                iconScale = 1.02
+            }
+            withAnimation(.spring(response: 0.45, dampingFraction: 0.62).delay(0.45)) {
+                iconRotation = 0
+                iconScale = 1.0
+            }
+
+        case .alarmBell:
+            settled = true
+            iconOffsetY = 0
+            iconScale = 1.0
+            withAnimation(.linear(duration: 0.10)) { iconRotation = -14 }
+            withAnimation(.linear(duration: 0.10).delay(0.10)) { iconRotation = 14 }
+            withAnimation(.linear(duration: 0.10).delay(0.20)) { iconRotation = -10 }
+            withAnimation(.linear(duration: 0.10).delay(0.30)) { iconRotation = 10 }
+            withAnimation(.spring(response: 0.34, dampingFraction: 0.72).delay(0.40)) { iconRotation = 0 }
+
+        case .downloadArrow:
+            iconOffsetY = -22
+            withAnimation(.easeIn(duration: 0.22)) {
+                settled = true
+                iconScale = 1.0
+                iconOffsetY = 8
+            }
+            withAnimation(.spring(response: 0.42, dampingFraction: 0.62).delay(0.22)) {
+                iconOffsetY = 0
+            }
+        }
+    }
+}
+
 /// Owns the system permission requests during onboarding and publishes
 /// their outcomes so the pages can reflect them live.
 @MainActor
-final class OnboardingPermissionPrompter: NSObject, ObservableObject, @preconcurrency CLLocationManagerDelegate {
+final class OnboardingPermissionPrompter: NSObject, ObservableObject, CLLocationManagerDelegate {
     @Published private(set) var locationGranted = false
     @Published private(set) var locationDenied = false
     @Published private(set) var notificationsGranted = false
     @Published private(set) var notificationsDenied = false
-    @Published private(set) var dataGranted = false
-    @Published private(set) var dataDenied = false
-    @Published private(set) var dataLoading = false
-
-    /// Held while the Local Network permission prompt is pending — keeps the
-    /// bare TCP connect alive until the user answers (nil after resolve).
-    private var dataConnection: NWConnection?
 
     private let manager = CLLocationManager()
 
@@ -421,11 +456,14 @@ final class OnboardingPermissionPrompter: NSObject, ObservableObject, @preconcur
             Task { @MainActor in
                 switch settings.authorizationStatus {
                 case .notDetermined:
-                    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, _ in
-                        Task { @MainActor in
+                    do {
+                        let granted = try await UNUserNotificationCenter.current()
+                            .requestAuthorization(options: [.alert, .sound, .badge])
                         self.notificationsGranted = granted
                         self.notificationsDenied = !granted
-                        }
+                    } catch {
+                        self.notificationsGranted = false
+                        self.notificationsDenied = true
                     }
                 case .authorized:
                     self.notificationsGranted = true
@@ -438,125 +476,9 @@ final class OnboardingPermissionPrompter: NSObject, ObservableObject, @preconcur
         }
     }
 
-    /// Triggers the Local Network permission prompt WITHOUT loading any data.
-    /// iOS shows the prompt on the first attempt to reach a local-network
-    /// address, so a bare TCP connect to the relay host:port is enough — no
-    /// HTTP request, no payload, nothing to wait on. Once the user answers
-    /// the prompt the connect either succeeds (granted) or fails (denied);
-    /// either way onboarding proceeds. The full dataset download happens
-    /// AFTER onboarding completes (ContentView's forced refresh).
-    func requestDataAccess() {
-        guard !dataLoading else { return }
-        dataLoading = true
-        dataDenied = false
-        let baseURL = RelayFuelProvider().baseURL
-        guard let host = baseURL.host,
-              let port = baseURL.port else {
-            dataLoading = false
-            dataDenied = true
-            return
-        }
-        let connection = NWConnection(
-            host: NWEndpoint.Host(host),
-            port: NWEndpoint.Port(rawValue: UInt16(port))!,
-            using: .tcp
-        )
-        dataConnection = connection
-        connection.stateUpdateHandler = { [weak self] state in
-            Task { @MainActor in
-                guard let self else { return }
-                switch state {
-                case .ready:
-                    // Connect succeeded — local network allowed.
-                    self.dataConnection = nil
-                    self.dataLoading = false
-                    self.dataGranted = true
-                    self.dataDenied = false
-                case .failed, .cancelled:
-                    // Connect failed (denied, or relay unreachable). Either
-                    // way we do NOT dead-end: onboarding continues.
-                    self.dataConnection = nil
-                    self.dataLoading = false
-                    self.dataGranted = false
-                    self.dataDenied = true
-                default:
-                    break // .preparing / .waiting — prompt pending, hold on
-                }
-            }
-        }
-        connection.start(queue: .main)
-        // Safety timeout: if the prompt is ignored or the connect stalls, drop
-        // back to the enabled Continue button instead of an endless spinner.
-        Task { @MainActor [weak self] in
-            try? await Task.sleep(nanoseconds: 12_000_000_000)
-            guard let self, self.dataLoading else { return }
-            self.dataLoading = false
-            self.dataGranted = false
-            self.dataDenied = true
-            self.dataConnection = nil
-            connection.cancel()
-        }
-    }
-
-    /// Replay pre-flight: determines the Local Network status WITHOUT any
-    /// user-visible check. Once the permission is decided (granted or denied)
-    /// a probe resolves silently — granted connects in milliseconds, denied
-    /// reports `.waiting` with `unsatisfiedReason == .localNetworkDenied`.
-    /// Only the FIRST-ever attempt (undetermined) shows the system alert; in
-    /// that case we cancel and leave the state unknown so the data page's
-    /// Continue triggers the prompt in context. First run never calls this.
-    func preflightDataAccess() {
-        guard !dataLoading, !dataGranted, !dataDenied else { return }
-        dataLoading = true
-        let baseURL = RelayFuelProvider().baseURL
-        guard let host = baseURL.host,
-              let port = baseURL.port else {
-            dataLoading = false
-            return
-        }
-        let connection = NWConnection(
-            host: NWEndpoint.Host(host),
-            port: NWEndpoint.Port(rawValue: UInt16(port))!,
-            using: .tcp
-        )
-        dataConnection = connection
-        connection.stateUpdateHandler = { [weak self] state in
-            Task { @MainActor in
-                guard let self else { return }
-                switch state {
-                case .ready:
-                    self.dataConnection = nil
-                    self.dataLoading = false
-                    self.dataGranted = true
-                    self.dataDenied = false
-                case .waiting:
-                    if connection.currentPath?.unsatisfiedReason == .localNetworkDenied {
-                        // Denied in Settings — resolved silently, no prompt.
-                        self.dataConnection = nil
-                        self.dataLoading = false
-                        self.dataGranted = false
-                        self.dataDenied = true
-                    } else {
-                        // Prompt pending (permission undetermined — only
-                        // possible after a reinstall, where the onboarding
-                        // flag persisted but the permission reset). Cancel so
-                        // page 4's Continue fires the prompt in context.
-                        self.dataConnection = nil
-                        self.dataLoading = false
-                        connection.cancel()
-                    }
-                case .failed, .cancelled:
-                    self.dataConnection = nil
-                    self.dataLoading = false
-                    self.dataGranted = false
-                    self.dataDenied = true
-                default:
-                    break // .preparing — probe starting, hold on
-                }
-            }
-        }
-        connection.start(queue: .main)
-    }
+    /// Replay pre-flight: NO data permission exists anymore — prices download
+    /// from the internet with no prompt, so there is nothing to preflight.
+    /// (The LAN relay left the consumer chain; Local Network is gone.)
 
     nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
         Task { @MainActor in

FuelBoard/PrivacyInfo.xcprivacy

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeLocation</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeDiagnostics</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+		</dict>
+	</array>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>1C8F.1</string>
+			</array>
+		</dict>
+	</array>
+</dict>
+</plist>

FuelBoard/ProximityMonitor.swift

@@ -18,6 +18,27 @@ struct DebugLocationStatus: Equatable {
     var cheapestDistanceKM: Double?
 }
 
+/// One recorded event in the live alert trace (Settings → Debug). Lets the
+/// tester see exactly which stage of the alert chain ran — whether a region
+/// event arrived at all, which gate (if any) suppressed the alert, and when
+/// an alert was scheduled. In-memory only: resets on relaunch.
+struct AlertLogEntry: Identifiable, Equatable {
+    enum Kind: String, Equatable {
+        /// A geofence entry event reached the monitor (didEnterRegion).
+        case entry
+        /// A gate blocked the alert (dedup, not-cheapest, station missing…).
+        case gate
+        /// A non-recoverable failure (fresh-price fetch threw).
+        case error
+        /// An alert was scheduled with UNUserNotificationCenter.
+        case fired
+    }
+    let id = UUID()
+    let date: Date
+    let kind: Kind
+    let text: String
+}
+
 /// App-view cheapest for the Debug section: mirrors EXACTLY what the Stations
 /// list computes (selected fuel, stationLimit radius, current location), so
 /// the debug "Cheapest in range" row matches the TOP badge in the app —
@@ -58,10 +79,14 @@ struct TieChoice {
 /// entering the winner's circle — not at the forecourt.
 @MainActor
 final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLocationManagerDelegate, UNUserNotificationCenterDelegate {
+    private static let favouriteDropThresholdPence: Double = 1.0
     @Published var monitoredStationIDs: [String] = []
     @Published var lastAlert: String?
     @Published private(set) var lastTestResult: String?
     @Published var pendingStationMap: StationMapRequest?
+    /// Station tapped via notification when Settings → Tap station = More info.
+    /// ContentView presents this as a StationDetailView sheet.
+    @Published var pendingDetailStation: FuelStation?
     /// Debug-only snapshot for the Settings → Debug section. Recomputed on
     /// every location/stations change via `refreshDebugStatus()`.
     @Published private(set) var debugStatus: DebugLocationStatus?
@@ -69,6 +94,17 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
     /// → Debug so a silently-failed `startMonitoring` (region budget exceeded,
     /// auth not granted, radius too large) is visible instead of invisible.
     @Published private(set) var lastRegionError: String?
+    /// Live alert trace (Settings → Debug): every stage the chain reached,
+    /// newest first, capped at 8. Empty = no region event has ever arrived.
+    @Published private(set) var alertLog: [AlertLogEntry] = []
+    /// How many `didEnterRegion` callbacks this session — proof the geofences
+    /// actually fire (vs. a gate silently blocking every alert).
+    @Published private(set) var regionEventCount = 0
+    /// Identifier of the armed debug fence (Settings → Debug → "Register
+    /// 100 m fence"), nil when not armed. The fence is a 100 m circle at the
+    /// current location that exists only to prove iOS delivers region events
+    /// on this install; entering it fires a plain notification, no gates.
+    @Published private(set) var debugFenceIdentifier: String?
 
     private let manager = CLLocationManager()
     private var stations: [FuelStation] = []
@@ -119,7 +155,10 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
 
         refreshDebugStatus()
 
-        for region in manager.monitoredRegions {
+        // Drop every region EXCEPT the debug fence (if armed) — the fence is
+        // a fixed 100 m circle at a fixed point that must survive re-registration
+        // churn; stations re-register from scratch every pass.
+        for region in manager.monitoredRegions where !region.identifier.hasPrefix("debug-fence") {
             manager.stopMonitoring(for: region)
         }
         monitoredStationIDs = []
@@ -173,6 +212,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                 manager.stopMonitoring(for: region)
             }
             monitoredStationIDs = []
+            debugFenceIdentifier = nil
         } else {
             requestPermissions()
             // Re-register geofences from restored cache immediately.
@@ -182,6 +222,88 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
 
     var isEnabled: Bool { enabled }
 
+    /// Compares the latest refreshed favourites against the persisted cheapest-
+    /// favourite baseline for one fuel and schedules a notification when the
+    /// winner changes or the current winner drops by a meaningful amount.
+    func evaluateFavouritePriceDropAlert(
+        favourites: [FavouriteEntry],
+        previousSnapshots: [FuelType: FavouriteAlertSnapshot],
+        monitoredFuel: FuelType,
+        enabled: Bool
+    ) {
+        var snapshots = previousSnapshots
+        guard let current = FuelStore.cheapestFavourite(in: favourites, fuel: monitoredFuel),
+              let currentPrice = current.station.prices[monitoredFuel] else {
+            snapshots.removeValue(forKey: monitoredFuel)
+            FuelStore.saveFavouriteAlertSnapshots(snapshots)
+            return
+        }
+
+        let currentSnapshot = FavouriteAlertSnapshot(
+            fuel: monitoredFuel,
+            stationID: current.station.id,
+            stationName: current.station.name,
+            price: currentPrice
+        )
+
+        defer {
+            snapshots[monitoredFuel] = currentSnapshot
+            FuelStore.saveFavouriteAlertSnapshots(snapshots)
+        }
+
+        guard enabled else { return }
+        guard let previous = previousSnapshots[monitoredFuel] else { return }
+
+        let winnerChanged = previous.stationID != currentSnapshot.stationID
+        let priceDropped = previous.stationID == currentSnapshot.stationID
+            && currentSnapshot.price <= previous.price - Self.favouriteDropThresholdPence
+
+        guard winnerChanged || priceDropped else { return }
+        fireFavouriteDropAlert(current: current, previous: previous, price: currentPrice, winnerChanged: winnerChanged)
+    }
+
+    /// Records a stage in the live alert trace, newest first, capped at 8.
+    private func logAlert(_ kind: AlertLogEntry.Kind, _ text: String) {
+        alertLog.insert(AlertLogEntry(date: Date(), kind: kind, text: text), at: 0)
+        if alertLog.count > 8 { alertLog.removeLast() }
+    }
+
+    // MARK: - Debug fence
+
+    /// Debug-only (Settings → Debug → "Register 100 m fence"): arms a 100 m
+    /// circle around the last known fix purely to prove iOS delivers region
+    /// events on this install. Stepping 100 m away and back should tick
+    /// "Region events this session" and fire a plain notification — no alert
+    /// gates apply. If that produces nothing, region delivery is broken at the
+    /// system level and no amount of alert-logic fixing will help.
+    func registerDebugFenceAroundMe() {
+        guard let fix = FuelStore.loadLocationWithDate() else {
+            logAlert(.error, "debug fence — no location fix yet (wait for one, then retry)")
+            return
+        }
+        clearDebugFence()
+        let id = "debug-fence-\(UUID().uuidString.prefix(8))"
+        let region = CLCircularRegion(
+            center: CLLocationCoordinate2D(latitude: fix.coordinate.lat, longitude: fix.coordinate.lng),
+            radius: 100,
+            identifier: id
+        )
+        region.notifyOnEntry = true
+        region.notifyOnExit = false
+        manager.startMonitoring(for: region)
+        debugFenceIdentifier = id
+        logAlert(.entry, "debug fence armed — 100 m circle at current location (step away and back in)")
+    }
+
+    func clearDebugFence() {
+        guard let id = debugFenceIdentifier else { return }
+        for region in manager.monitoredRegions where region.identifier == id {
+            manager.stopMonitoring(for: region)
+        }
+        debugFenceIdentifier = nil
+        logAlert(.gate, "debug fence cleared")
+    }
+
     /// Recomputes the Settings → Debug location snapshot from current state.
     /// "In range" uses the SAME criteria as live alerts: stations selling the
     /// monitored fuel within the alert radius of the last known location.
@@ -250,6 +372,20 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
 
     nonisolated func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
         Task { @MainActor in
+            // Trace: prove the geofence event itself arrived. This is the
+            // single point that distinguishes "no region delivery" from
+            // "delivery fine, a gate blocked the alert".
+            self.regionEventCount += 1
+            self.logAlert(.entry, "didEnterRegion — \(region.identifier)")
+            // Debug fence (Settings → Debug): exists only to prove iOS
+            // delivers region events on this install. Entering it fires a
+            // plain notification with no alert gates — if the counter ticks
+            // and a banner shows after stepping out and back, delivery works.
+            if region.identifier.hasPrefix("debug-fence") {
+                self.logAlert(.fired, "debug fence entered — iOS delivered the region event (100 m)")
+                self.sendPlainTestNotification()
+                return
+            }
             self.handleEntry(region)
         }
     }
@@ -277,10 +413,16 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
         // Fall back to cached data on background wake (stations may not be
         // fetched yet when the app is relaunched by a region event).
         if stations.isEmpty { stations = FuelStore.loadStations() }
-        guard let station = stations.first(where: { $0.id == stationID }) else { return }
+        guard let station = stations.first(where: { $0.id == stationID }) else {
+            logAlert(.gate, "region \(stationID) — station not in loaded list (Stations tab not fetched yet?)")
+            return
+        }
 
         // Dedup: one alert per station per hour.
-        if let last = lastNotified[stationID], Date().timeIntervalSince(last) < 3600 { return }
+        if let last = lastNotified[stationID], Date().timeIntervalSince(last) < 3600 {
+            logAlert(.gate, "\(station.name) — dedup: already alerted \(Int(Date().timeIntervalSince(last) / 60)) min ago")
+            return
+        }
 
         Task {
             do {
@@ -293,9 +435,16 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                     $0.prices[fuel] != nil &&
                     $0.distanceKM(to: station.lat, lng2: station.lng) <= radiusKM
                 }
-                guard let cheapest = withinRadius.min(by: { $0.prices[fuel]! < $1.prices[fuel]! }),
-                      cheapest.id == station.id,
-                      let price = cheapest.prices[fuel] else { return }
+                guard let cheapest = withinRadius.min(by: { $0.prices[fuel]! < $1.prices[fuel]! }) else {
+                    logAlert(.gate, "\(station.name) — no \(fuel.displayName.lowercased()) sellers within \(String(format: "%.1f", radiusKM)) km after fresh fetch")
+                    return
+                }
+                guard cheapest.id == station.id else {
+                    logAlert(.gate, "\(station.name) — not cheapest: \(cheapest.name) at \(String(format: "%.1fp", cheapest.prices[fuel]!)) is cheaper within the radius")
+                    return
+                }
+                // withinRadius guarantees the fuel exists on every candidate.
+                guard let price = cheapest.prices[fuel] else { return }
 
                 // Ties: all stations in radius at the same cheapest price.
                 let tied = FuelStore.tiedStations(
@@ -306,7 +455,9 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                 fireAlert(for: cheapest, price: price, ties: tied)
                 lastNotified[stationID] = Date()
             } catch {
-                // Silent — geofence state stays valid for next entry.
+                // Trace the silent catch — a relay failure drops the alert
+                // with no banner, which previously looked like "no alert".
+                logAlert(.error, "\(station.name) — fresh-price fetch failed: \(error.localizedDescription)")
             }
         }
     }
@@ -341,9 +492,35 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
             content.body = "\(station.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
             addAlertRequest(content: content, station: station)
         }
+        logAlert(.fired, "alert scheduled — \(brand) · \(String(format: "%.1fp", price))")
         lastAlert = "\(brand) · \(String(format: "%.1fp", price)) · \(distanceText) away"
     }
 
+    private func fireFavouriteDropAlert(
+        current: FavouriteEntry,
+        previous: FavouriteAlertSnapshot,
+        price: Double,
+        winnerChanged: Bool
+    ) {
+        let content = UNMutableNotificationContent()
+        content.sound = .default
+        let fuel = current.fuel
+        let previousPriceText = String(format: "%.1fp", previous.price)
+        let currentPriceText = String(format: "%.1fp", price)
+
+        if winnerChanged {
+            content.title = "New cheapest \(fuel.displayName.lowercased()) favourite"
+            content.body = "\(current.station.name) is now your cheapest favourite at \(currentPriceText), ahead of \(previous.stationName)."
+        } else {
+            content.title = "Cheapest favourite just dropped"
+            content.body = "\(current.station.name) fell from \(previousPriceText) to \(currentPriceText) for \(fuel.displayName.lowercased())."
+        }
+
+        addAlertRequest(content: content, station: current.station)
+        logAlert(.fired, "favourite alert scheduled — \(current.station.name) · \(currentPriceText)")
+        lastAlert = "Favourite · \(current.station.name) · \(currentPriceText)"
+    }
+
     /// Adds a notification whose tap opens directions to `station`. The
     /// station's coordinates ride in `userInfo` so the tap handler can route
     /// to Apple Maps (or an in-app fallback), and a map snapshot with a pin is
@@ -531,6 +708,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                 content.body = "\(choices.count) stations at \(String(format: "%.1fp", price)) within \(unit.format(radiusKM)). Pick one for directions."
                 let baseResult = "\(fuel.displayName) · \(choices.count) tied at \(String(format: "%.1fp", price)) · radius \(unit.format(radiusKM))"
                 lastTestResult = baseResult
+                logAlert(.fired, "test alert scheduled — \(choices.count) tied at \(String(format: "%.1fp", price))")
                 addAlertRequest(content: content, station: candidate, ties: choices) { status in
                     self.lastTestResult = "\(baseResult) · \(status)"
                 }
@@ -539,6 +717,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                 content.body = "\(candidate.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
                 let baseResult = "\(fuel.displayName) · \(brand) · \(String(format: "%.1fp", price)) · \(distanceText) away · radius \(unit.format(radiusKM))"
                 lastTestResult = baseResult
+                logAlert(.fired, "test alert scheduled — \(brand) · \(String(format: "%.1fp", price))")
                 addAlertRequest(content: content, station: candidate) { status in
                     self.lastTestResult = "\(baseResult) · \(status)"
                 }
@@ -555,6 +734,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
             content.sound = .default
             let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
             UNUserNotificationCenter.current().add(request)
+            logAlert(.fired, "test alert scheduled — no \(fuel.displayName.lowercased()) candidate, fallback copy sent")
             lastTestResult = sellers.isEmpty
                 ? "No stations loaded — open the Stations tab first"
                 : "No \(fuel.displayName.lowercased()) seller within \(unit.format(radiusKM))"
@@ -588,6 +768,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
             content.title = "\(brand) — plain test notification"
             content.body = "\(nearest.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
             content.sound = .default
+            logAlert(.fired, "plain test notification scheduled — \(brand)")
             addAlertRequest(content: content, station: nearest)
         } else {
             content.title = "FuelBoard test notification"
@@ -595,6 +776,7 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
             content.sound = .default
             let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
             UNUserNotificationCenter.current().add(request)
+            logAlert(.fired, "plain test notification scheduled — no station data")
         }
     }
 
@@ -612,9 +794,11 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
         }
     }
 
-    /// Tapping a notification opens Apple Maps directions to the station from
-    /// the user's current location. If Apple Maps can't be opened (e.g. inside
-    /// LiveContainer), an in-app map sheet with directions is shown instead.
+    /// Tapping a notification honours Settings → Tap station: Open map opens
+    /// Apple Maps directions to the station from the user's current location;
+    /// More info opens the station's detail sheet in the app instead. If Apple
+    /// Maps can't be opened (e.g. inside LiveContainer), an in-app map sheet
+    /// with directions is shown instead.
     ///
     /// When the notification carried tie-choice action buttons, the tapped
     /// button's identifier ("tie_0", "tie_1", …) selects the corresponding
@@ -639,9 +823,9 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
                let tieName = ties[index]["name"] as? String,
                let tieLat = ties[index]["lat"] as? Double,
                let tieLng = ties[index]["lng"] as? Double {
-                openDirections(to: tieName, latitude: tieLat, longitude: tieLng)
+                routeNotificationTap(name: tieName, latitude: tieLat, longitude: tieLng)
             } else if !isTie, let name, let lat, let lng {
-                openDirections(to: name, latitude: lat, longitude: lng)
+                routeNotificationTap(name: name, latitude: lat, longitude: lng)
             }
             // Tie body tap: intentionally no directions — the user must pick
             // an option button to choose a station.
@@ -649,6 +833,25 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
         }
     }
 
+    /// Routes a resolved notification tap through the user's Tap station
+    /// preference: Open map → Apple Maps; More info → in-app detail sheet
+    /// (falling back to the map sheet when the station isn't in cache).
+    @MainActor
+    private func routeNotificationTap(name: String, latitude: Double, longitude: Double) {
+        guard FuelStore.loadStationTapAction() == .showDetails else {
+            openDirections(to: name, latitude: latitude, longitude: longitude)
+            return
+        }
+        if let station = stations.first(where: { $0.lat == latitude && $0.lng == longitude })
+            ?? stations.first(where: { $0.name == name }) {
+            pendingDetailStation = station
+        } else {
+            // Station not in cache (e.g. data refreshed since the alert fired)
+            // — fall back to the map sheet so the tap still shows something.
+            pendingStationMap = StationMapRequest(name: name, latitude: latitude, longitude: longitude)
+        }
+    }
+
     /// Opens Apple Maps with driving directions to the station; falls back to
     /// the in-app map sheet when the hand-off fails.
     @MainActor

FuelBoard/RoadDistanceService.swift

@@ -0,0 +1,98 @@
+// RoadDistanceService.swift — computes Apple-Maps-matched ROAD distances for
+// nearby stations and caches them (keychain) so widgets + Live Activity can
+// show real driving distance instead of straight-line haversine.
+//
+// Runs only in the APP: MKDirections is network-bound and the widget extension
+// has a tiny execution budget + a ~40-70/day refresh budget, so routing belongs
+// here, not in the widget. The widget/Live Activity just read the cache.
+//
+// Throttling: recompute at most every `throttleMinutes`, or when the user has
+// moved `moveThresholdMeters` from where the cache was built. Bounded to the
+// `candidatesPerPass` nearest stations so a pass stays a handful of route calls.
+
+import Foundation
+import MapKit
+import WidgetKit
+
+enum RoadDistanceService {
+    /// Upper bound on stations routed per pass, so a pass stays a bounded set of
+    /// route calls. Raised from 12 so stations past the old nearest-12 cutoff
+    /// still get real road distances instead of a straight-line fallback.
+    static let candidatesPerPass = 40
+    /// Only route stations within this straight-line radius (km). Covers the
+    /// largest search radius the UI exposes (15 mi ≈ 24.1 km) plus margin, so
+    /// every station a widget/Live Activity/list can actually show gets routed.
+    static let maxRadiusKM: Double = 25
+    /// Don't route again more often than this (minutes).
+    static let throttleMinutes: Double = 10
+    /// Recompute when the user moves more than this (metres) from the last
+    /// source location.
+    static let moveThresholdMeters: Double = 400
+
+    /// Refreshes the cached road distances for the in-radius stations around
+    /// `lat`/`lng`. Throttled by time + distance; safe to call on every fix.
+    static func refreshIfNeeded(stations: [FuelStation], lat: Double, lng: Double) async {
+        guard !stations.isEmpty else { return }
+
+        // Throttle: keep cached values when fresh and the user hasn't moved far.
+        if let cache = FuelStore.loadRoadDistances() {
+            let elapsed = Date().timeIntervalSince1970 - cache.updatedAt
+            let movedMeters = haversineMeters(cache.sourceLat, cache.sourceLng, lat, lng)
+            if elapsed < throttleMinutes * 60 && movedMeters < moveThresholdMeters {
+                return
+            }
+        }
+
+        // Candidate stations: the nearest-by-straight-line subset that the UI
+        // could actually display, capped so a pass stays bounded.
+        let nearest = stations
+            .sorted { $0.distanceKM(to: lat, lng2: lng) < $1.distanceKM(to: lat, lng2: lng) }
+            .prefix(candidatesPerPass)
+            .filter { $0.distanceKM(to: lat, lng2: lng) <= maxRadiusKM }
+
+        let origin = CLLocationCoordinate2D(latitude: lat, longitude: lng)
+        var entries: [String: CachedRoadDistance] = [:]
+        for station in nearest {
+            let dest = CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng)
+            if let meters = await roadMeters(from: origin, to: dest) {
+                // Store the exact pin that was routed so the display layer can
+                // refuse to serve this value if the station later appears with
+                // a different coordinate (corrected pin / other data source).
+                entries[station.id] = CachedRoadDistance(meters: meters,
+                                                         lat: station.lat,
+                                                         lng: station.lng)
+            }
+        }
+        guard !entries.isEmpty else { return }
+
+        FuelStore.saveRoadDistances(sourceLat: lat, sourceLng: lng, entries: entries)
+        // Wake the widgets so the new road distances surface immediately.
+        WidgetCenter.shared.reloadAllTimelines()
+    }
+
+    /// Driving distance (metres) between two coordinates via Apple Maps routing.
+    private static func roadMeters(from: CLLocationCoordinate2D, to: CLLocationCoordinate2D) async -> Double? {
+        let request = MKDirections.Request()
+        request.source = MKMapItem(placemark: MKPlacemark(coordinate: from))
+        request.destination = MKMapItem(placemark: MKPlacemark(coordinate: to))
+        request.transportType = .automobile
+        request.requestsAlternateRoutes = false
+        do {
+            let response = try await MKDirections(request: request).calculate()
+            return response.routes.first?.distance
+        } catch {
+            return nil
+        }
+    }
+
+    /// Straight-line haversine distance between two coordinates, in metres.
+    private static func haversineMeters(_ lat1: Double, _ lng1: Double, _ lat2: Double, _ lng2: Double) -> Double {
+        let r = 6371000.0
+        let dLat = (lat2 - lat1) * .pi / 180
+        let dLng = (lng2 - lng1) * .pi / 180
+        let a = sin(dLat / 2) * sin(dLat / 2) +
+                cos(lat1 * .pi / 180) * cos(lat2 * .pi / 180) *
+                sin(dLng / 2) * sin(dLng / 2)
+        return r * 2 * atan2(sqrt(a), sqrt(1 - a))
+    }
+}

FuelBoard/SettingsView.swift

@@ -13,7 +13,13 @@ import WidgetKit
 /// freshness) is debug-only too — moved here so release builds don't expose
 /// relay plumbing.
 struct SettingsView: View {
+    /// Shared tip-purchase store — owned by ContentView so its outcome can
+    /// ride the app-wide status banner (above the tabs), not a local card.
+    @ObservedObject var tipStore: TipStore
     @Binding var distanceUnit: DistanceUnit
+    @Binding var priceDisplayStyle: PriceDisplayStyle
+    @Binding var stationTapAction: StationTapAction
+    @Binding var dataRefreshMode: DataRefreshMode
     /// The fuel + radius currently configured for alerts (mirrors the Alerts
     /// tab) so the test notification matches what real alerts will say.
     var alertsFuel: FuelType = .e10
@@ -40,14 +46,25 @@ struct SettingsView: View {
     /// Live geofence count (monitor.monitoredStationIDs.count) — Debug-only
     /// status; the user-facing Alerts tab no longer exposes fence plumbing.
     var monitoredCount: Int = 0
+    /// Live alert trace (monitor.alertLog) — every stage the alert chain
+    /// reached this session (region event / gate / scheduled). Debug-only.
+    var alertLog: [AlertLogEntry] = []
+    /// Region events received this session (monitor.regionEventCount).
+    var regionEventCount: Int = 0
+    /// Debug fence state (monitor.debugFenceIdentifier) — armed vs cleared.
+    var debugFenceIdentifier: String?
+    /// Arms a 100 m fence at the current location (monitor.registerDebugFenceAroundMe).
+    var onDebugFence: () -> Void = {}
+    /// Clears the armed fence (monitor.clearDebugFence).
+    var onClearDebugFence: () -> Void = {}
 
-    @StateObject private var tipStore = TipStore()
-    @State private var showTipAlert = false
-    @State private var tipAlertMessage = ""
     @State private var testAlertMessage: String?
     /// Hidden developer flag — the Debug section only appears when on. Toggled
     /// by tapping the About → Version row five times (NOT a user-facing switch).
     @State private var debugMode: Bool = FuelStore.loadDebugMode()
+    /// Dev-only: re-inserts the LAN relay into the live chain (off by default —
+    /// consumers must never attempt local-network access).
+    @State private var relayFallbackEnabled: Bool = FuelStore.loadRelayFallbackEnabled()
     @State private var versionTapCount = 0
     @State private var lastVersionTap = Date.distantPast
     /// Widget diagnostics: the extension's last makeEntry beacon PER intent
@@ -88,18 +105,70 @@ struct SettingsView: View {
                     .onChange(of: distanceUnit) { _, newValue in
                         FuelStore.saveDistanceUnit(newValue)
                         WidgetCenter.shared.reloadAllTimelines()
+                        WatchSyncManager.shared.pushSnapshot()
+                    }
+                    Picker("Price display", selection: $priceDisplayStyle) {
+                        ForEach(PriceDisplayStyle.allCases) { style in
+                            Text(style.displayName).tag(style)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+                    .onChange(of: priceDisplayStyle) { _, newValue in
+                        FuelStore.savePriceDisplayStyle(newValue)
+                        WidgetCenter.shared.reloadAllTimelines()
+                        WatchSyncManager.shared.pushSnapshot()
                     }
                 } header: {
                     Text("Units")
                 } footer: {
-                    Text("Distances and search radii across the app, widget and alerts are shown in this unit.")
+                    Text("Distances and search radii across the app, widget and alerts are shown in this unit. Prices can be shown as on a station sign (129.9) or in pounds and pence (£1.29⁹/L).")
+                }
+
+                Section {
+                    Picker("Tap station", selection: $stationTapAction) {
+                        ForEach(StationTapAction.allCases) { action in
+                            Text(action.displayName).tag(action)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+                    .onChange(of: stationTapAction) { _, newValue in
+                        FuelStore.saveStationTapAction(newValue)
+                    }
+                } header: {
+                    Text("Tap action")
+                } footer: {
+                    Text("Tapping a station either opens directions straight away or shows its details first.")
+                }
+
+                Section {
+                    Picker("Data checking", selection: $dataRefreshMode) {
+                        ForEach(DataRefreshMode.allCases) { mode in
+                            Text(mode.displayName).tag(mode)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+                    .onChange(of: dataRefreshMode) { _, newValue in
+                        FuelStore.saveDataRefreshMode(newValue)
+                        SmartDataRefreshScheduler.scheduleNextIfNeeded()
+                        WatchSyncManager.shared.pushSnapshot()
+                    }
+                    VStack(alignment: .leading, spacing: 8) {
+                        Text(dataRefreshMode.summary)
+                        Text("Background checks are best-effort and happen only when iOS allows, so timing is not exact.")
+                            .foregroundStyle(.secondary)
+                    }
+                    .font(.footnote)
+                } header: {
+                    Text("Data checking")
+                } footer: {
+                    Text("Standard saves battery and refreshes price data up to twice daily. Smart checks for newer data more often in the background and only refreshes full prices when an update is available.")
                 }
 
                 Section {
                     Button {
                         onShowOnboarding()
                     } label: {
-                        Label("Show introduction", systemImage: "sparkles")
+                        Label("Show introduction", systemImage: "arrow.clockwise.circle")
                     }
                 } footer: {
                     Text("Replay the welcome screen, including the location and notification permission prompts.")
@@ -107,6 +176,10 @@ struct SettingsView: View {
 
                 if debugMode {
                     Section {
+                        Toggle("LAN relay fallback (dev)", isOn: $relayFallbackEnabled)
+                            .onChange(of: relayFallbackEnabled) { _, enabled in
+                                FuelStore.saveRelayFallbackEnabled(enabled)
+                            }
                         Button {
                             sendTestAlert()
                         } label: {
@@ -200,7 +273,7 @@ struct SettingsView: View {
                     } header: {
                         Text("Data source")
                     } footer: {
-                        Text("Connection shows whether prices come from the official Fuel Finder API or the CSV mirror. Data updated is the latest price change reported by the GOV.UK server itself.")
+                        Text("Connection shows the source of the current prices (CSV mirror or API). Data updated is the latest price change reported by the GOV.UK server itself. Prices use the UK Fuel Finder dataset (Open Government Licence) and refresh up to twice a day.")
                     }
 
                     Section {
@@ -217,26 +290,103 @@ struct SettingsView: View {
                     } header: {
                         Text("Geofence monitoring")
                     }
+
+                    Section {
+                        if debugFenceIdentifier != nil {
+                            LabeledContent("Debug fence", value: "armed (100 m)")
+                            Text("Step 100 m away from your current position, then walk back in. 'Region events this session' should tick and a plain notification fires — proof iOS delivers region events on this install, with no alert gates involved.")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                            Button("Clear debug fence", role: .destructive) {
+                                onClearDebugFence()
+                            }
+                        } else {
+                            Button("Register 100 m fence at current location") {
+                                onDebugFence()
+                            }
+                            Text("A debug-only circle around your current position that proves geofence delivery end-to-end: step out 100 m and back in, and watch 'Region events this session' tick.")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                    } header: {
+                        Text("Debug fence (delivery test)")
                     }
 
                     Section {
-                    Button {
-                        Task { await tipStore.purchase() }
-                    } label: {
-                        HStack {
-                            Label("Leave a tip", systemImage: "heart.fill")
-                                .foregroundStyle(.pink)
-                            Spacer()
-                            Text(tipStore.displayPrice)
+                        LabeledContent("Region events this session", value: "\(regionEventCount)")
+                        if alertLog.isEmpty {
+                            Text("No alert activity yet — drive across a geofence boundary, or tap the test-alert button above to exercise the chain without a geofence.")
+                                .font(.caption)
                                 .foregroundStyle(.secondary)
+                        } else {
+                            ForEach(alertLog) { entry in
+                                HStack(alignment: .firstTextBaseline) {
+                                    Image(systemName: alertSymbol(for: entry.kind))
+                                        .foregroundStyle(alertColor(for: entry.kind))
+                                    VStack(alignment: .leading, spacing: 1) {
+                                        Text(entry.text)
+                                            .font(.caption2)
+                                            .textSelection(.enabled)
+                                        Text(entry.date, format: .dateTime.hour().minute().second())
+                                            .font(.caption2)
+                                            .foregroundStyle(.tertiary)
+                                    }
+                                }
+                            }
+                        }
+                    } header: {
+                        Text("Alert trace")
+                    } footer: {
+                        Text("One line per stage the live chain reached: a geofence entry, each gate that passed or blocked the alert (dedup, cheapest-within-radius, fresh fetch), then the scheduled alert. If the trace shows 'alert scheduled' but no banner appears, the failure is in notification delivery itself (permission or background delivery), not the alert logic.")
+                    }
+                }
+
+                Section {
+                    VStack(spacing: 10) {
+                        ForEach(TipStore.tiers) { tier in
+                            Button {
+                                Task { await tipStore.purchase(tier) }
+                            } label: {
+                                HStack(spacing: 12) {
+                                    Image(systemName: "fuelpump.fill")
+                                        .font(.title3)
+                                        .foregroundStyle(tier.accent)
+                                        .frame(width: 34)
+                                    VStack(alignment: .leading, spacing: 2) {
+                                        Text(tier.name)
+                                            .font(.headline)
+                                        Text(tier.blurb)
+                                            .font(.caption)
+                                            .foregroundStyle(.secondary)
+                                    }
+                                    Spacer(minLength: 8)
+                                    Text(tipStore.displayPrice(for: tier))
+                                        .font(.headline.weight(.bold))
+                                        .foregroundStyle(tier.accent)
                                         .monospacedDigit()
                                 }
+                                .padding(.horizontal, 14)
+                                .padding(.vertical, 12)
+                                .frame(maxWidth: .infinity, alignment: .leading)
+                                .background(
+                                    RoundedRectangle(cornerRadius: 12)
+                                        .fill(Color(.secondarySystemGroupedBackground))
+                                        .overlay(
+                                            RoundedRectangle(cornerRadius: 12)
+                                                .fill(tier.accent.opacity(0.05))
+                                        )
+                                )
                             }
+                            .buttonStyle(.plain)
                             .disabled(tipStore.purchaseInProgress)
+                        }
+                    }
+                    .listRowBackground(Color.clear)
+                    .listRowInsets(EdgeInsets(top: 4, leading: 16, bottom: 4, trailing: 16))
                 } header: {
                     Text("Support FuelBoard")
                 } footer: {
-                    Text("A small tip helps keep the data relay and app development going. Thank you!")
+                    Text("A tip helps keep this app free and supports development. Thank you")
                 }
 
                 Section {
@@ -253,13 +403,6 @@ struct SettingsView: View {
                     Text("About")
                 }
 
-                if let message = tipStore.message {
-                    Section {
-                        Text(message)
-                            .font(.footnote)
-                            .foregroundStyle(.secondary)
-                    }
-                }
             }
             .navigationTitle("Settings")
             .onAppear {
@@ -302,7 +445,7 @@ struct SettingsView: View {
                 Label("In range", systemImage: "location.circle.fill")
                 Spacer()
                 HStack(spacing: 6) {
-                    if let coord = status.coordinate {
+                    if status.coordinate != nil {
                         Circle()
                             .fill(inRangeColor(status.inRangeCount))
                             .frame(width: 10, height: 10)
@@ -431,6 +574,26 @@ struct SettingsView: View {
         }
     }
 
+    // MARK: - Alert trace rendering
+
+    private func alertSymbol(for kind: AlertLogEntry.Kind) -> String {
+        switch kind {
+        case .entry: return "location.circle.fill"
+        case .gate: return "arrow.right.circle"
+        case .error: return "xmark.octagon.fill"
+        case .fired: return "bell.badge.fill"
+        }
+    }
+
+    private func alertColor(for kind: AlertLogEntry.Kind) -> Color {
+        switch kind {
+        case .entry: return .green
+        case .gate: return .orange
+        case .error: return .red
+        case .fired: return .blue
+        }
+    }
+
     private func sendTestAlert() {
         UNUserNotificationCenter.current().getNotificationSettings { settings in
             Task { @MainActor in
@@ -441,13 +604,17 @@ struct SettingsView: View {
                     testAlertMessage = NSLocalizedString("Notifications are turned off for FuelBoard. Enable them in Settings → Notifications → FuelBoard, then try again.", comment: "")
                 default:
                     // First time — ask, then fire if granted.
-                    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, _ in
                     Task { @MainActor in
+                        do {
+                            let granted = try await UNUserNotificationCenter.current()
+                                .requestAuthorization(options: [.alert, .sound, .badge])
                             if granted {
                                 onTestAlert()
                             } else {
                                 testAlertMessage = NSLocalizedString("Notifications weren't allowed, so no test alert was sent.", comment: "")
                             }
+                        } catch {
+                            testAlertMessage = NSLocalizedString("Couldn't request notification permission right now. Please try again.", comment: "")
                         }
                     }
                 }
@@ -456,65 +623,180 @@ struct SettingsView: View {
     }
 }
 
-/// Loads the £4.99 tip product and drives its purchase.
+/// Loads the three tip tiers and drives their purchases.
 @MainActor
 final class TipStore: ObservableObject {
-    /// Product ID for the £4.99 tip (App Store Connect — consumable).
-    static let productID = "com.apt.fuelboard.tip499"
+    /// A purchasable tip tier (App Store Connect — all consumables).
+    struct TipTier: Identifiable {
+        let id: String          // product ID
+        let name: String
+        let blurb: String
+        let fallbackPrice: String
+        let accent: Color       // card/price accent (matches the fuel palette)
+    }
 
-    @Published private(set) var product: Product?
+    static let tiers: [TipTier] = [
+        TipTier(id: "com.apt.fuelboard.tip099", name: "Splash & Dash",
+                blurb: "Just enough to keep things moving.", fallbackPrice: "£0.99",
+                accent: Color(red: 0.39, green: 0.82, blue: 1.0)),    // #64D2FF
+        TipTier(id: "com.apt.fuelboard.tip299", name: "Half a Tank",
+                blurb: "A generous top-up for development.", fallbackPrice: "£2.99",
+                accent: Color(red: 0.19, green: 0.82, blue: 0.35)),   // #30D158
+        TipTier(id: "com.apt.fuelboard.tip499", name: "Fill 'Er Up",
+                blurb: "Keeping the app on the road.", fallbackPrice: "£4.99",
+                accent: Color(red: 1.0, green: 0.84, blue: 0.04)),    // #FFD60A
+    ]
+
+    /// A banner outcome: the exact copy to show plus its icon + tint.
+    struct TipOutcome: Hashable {
+        let message: String
+        let icon: String
+        let tint: Color
+    }
+
+    @Published private(set) var products: [String: Product] = [:]
     @Published private(set) var purchaseInProgress = false
-    @Published private(set) var message: String?
+    @Published private(set) var outcome: TipOutcome?
 
-    var displayPrice: String {
-        product?.displayPrice ?? "£4.99"
+    /// Auto-dismiss timer for the outcome banner (replaced on each new outcome).
+    private var dismissTask: Task<Void, Never>?
+
+    /// Listens for transactions that complete OUTSIDE the direct purchase()
+    /// call — Ask to Buy approvals, payments finished on another device
+    /// signed into the same Apple ID. Without this, those purchases land in
+    /// the queue but are never finished or acknowledged.
+    private var updatesTask: Task<Void, Never>?
+
+    init() {
+        updatesTask = Task { [weak self] in
+            for await update in Transaction.updates {
+                await self?.handle(update)
+            }
+        }
+    }
+
+    deinit {
+        updatesTask?.cancel()
+        dismissTask?.cancel()
+    }
+
+    private func handle(_ update: VerificationResult<StoreKit.Transaction>) async {
+        // Never deliver or finish an untrusted purchase.
+        guard case .verified(let transaction) = update else { return }
+        // Only acknowledge our own consumables (future products get their own).
+        guard Self.tiers.contains(where: { $0.id == transaction.productID }) else { return }
+        await transaction.finish()
+        showOutcome(
+            NSLocalizedString("Thank you! Your tip has been received. ⛽", comment: ""),
+            icon: "checkmark.circle.fill",
+            tint: Color(red: 0.19, green: 0.82, blue: 0.35)      // #30D158
+        )
+    }
+
+    /// Sets the banner outcome and schedules its auto-dismiss (~3.5 s).
+    /// Re-triggering cancels the previous timer so rapid taps don't collide.
+    private func showOutcome(_ message: String, icon: String, tint: Color) {
+        dismissTask?.cancel()
+        outcome = TipOutcome(message: message, icon: icon, tint: tint)
+        dismissTask = Task { [weak self] in
+            try? await Task.sleep(nanoseconds: 3_500_000_000)
+            guard !Task.isCancelled else { return }
+            withAnimation(.easeOut(duration: 0.25)) { self?.outcome = nil }
+        }
+    }
+
+    /// Tap-to-dismiss — clears the banner and cancels the pending auto-dismiss.
+    func dismissOutcome() {
+        dismissTask?.cancel()
+        dismissTask = nil
+        withAnimation(.easeOut(duration: 0.2)) { outcome = nil }
+    }
+
+    func displayPrice(for tier: TipTier) -> String {
+        products[tier.id]?.displayPrice ?? tier.fallbackPrice
     }
 
     func load() async {
-        // Refreshes product state on every visit so a newly-approved product
-        // (or a restored transaction) is picked up.
+        // Refreshes product state on every visit so newly-approved products
+        // (or restored transactions) are picked up.
         do {
-            let products = try await Product.products(for: [Self.productID])
-            product = products.first
+            let fetched = try await Product.products(for: Self.tiers.map(\.id))
+            merge(fetched)
         } catch {
-            // No product yet (sideloaded build) — the button still shows the
-            // intended price and reports the purchase attempt gracefully.
-            product = nil
+            // No products yet (sideloaded build) — the buttons still show the
+            // intended prices and report purchase attempts gracefully.
+            products = [:]
         }
     }
 
-    func purchase() async {
+    private func merge(_ fetched: [Product]) {
+        products.merge(Dictionary(uniqueKeysWithValues: fetched.map { ($0.id, $0) })) { _, new in new }
+    }
+
+    private func product(for tier: TipTier) async throws -> Product? {
+        if let product = products[tier.id] { return product }
+
+        // TestFlight/App Store Connect product availability can lag the Settings
+        // onAppear load. Re-query the tapped tier before falling back so a newly
+        // approved IAP opens the system purchase sheet instead of showing stale
+        // "not available" copy.
+        let fetched = try await Product.products(for: [tier.id])
+        merge(fetched)
+        return fetched.first { $0.id == tier.id }
+    }
+
+    func purchase(_ tier: TipTier) async {
         guard !purchaseInProgress else { return }
         purchaseInProgress = true
         defer { purchaseInProgress = false }
 
-        // If the product hasn't loaded (e.g. not configured in App Store
-        // Connect yet), still allow the attempt so the user sees a clear
-        // outcome rather than a dead button.
-        guard let product else {
-            message = NSLocalizedString("The tip isn't available in this build yet — check back after an App Store release.", comment: "")
+        do {
+            guard let product = try await product(for: tier) else {
+                showOutcome(
+                    NSLocalizedString("This tip isn't available from the App Store yet. Please try again shortly.", comment: ""),
+                    icon: "info.circle.fill",
+                    tint: Color(.secondaryLabel)
+                )
                 return
             }
 
-        do {
             let result = try await product.purchase()
             switch result {
             case .success(let verification):
                 switch verification {
-                case .verified:
-                    message = NSLocalizedString("Thank you! Your tip has been received. ⛽", comment: "")
+                case .verified(let transaction):
+                    // Consume the consumable — otherwise StoreKit re-delivers
+                    // it through Transaction.updates on every launch.
+                    await transaction.finish()
+                    showOutcome(
+                        NSLocalizedString("Thank you! Your tip has been received. ⛽", comment: ""),
+                        icon: "checkmark.circle.fill",
+                        tint: Color(red: 0.19, green: 0.82, blue: 0.35)      // #30D158
+                    )
                 case .unverified:
-                    message = NSLocalizedString("The purchase couldn't be verified. Please try again.", comment: "")
+                    showOutcome(
+                        NSLocalizedString("The purchase couldn't be verified. Please try again.", comment: ""),
+                        icon: "exclamationmark.triangle.fill",
+                        tint: .orange
+                    )
                 }
             case .userCancelled:
-                message = nil   // silent — the user just closed the sheet
+                dismissOutcome()   // silent — the user just closed the sheet
             case .pending:
-                message = NSLocalizedString("Your tip is pending approval. It'll finish automatically.", comment: "")
+                showOutcome(
+                    NSLocalizedString("Your tip is pending approval. It'll finish automatically.", comment: ""),
+                    icon: "hourglass",
+                    tint: Color(red: 0.39, green: 0.82, blue: 1.0)           // #64D2FF
+                )
             @unknown default:
-                message = nil
+                dismissOutcome()
             }
         } catch {
-            message = String(format: NSLocalizedString("The tip couldn't be completed: %@", comment: ""), error.localizedDescription)
+            showOutcome(
+                String(format: NSLocalizedString("The tip couldn't be completed: %@", comment: ""), error.localizedDescription),
+                icon: "xmark.circle.fill",
+                tint: .red
+            )
         }
     }
 }

FuelBoard/SiriShortcuts.swift

@@ -22,18 +22,6 @@ import SwiftUI
 ///   "super unleaded") so Siri matches how people actually ask. The app UI's
 ///   FuelType.displayName is untouched.
 
-// MARK: - Fuel parameter
-
-extension FuelType: AppEnum {
-    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Fuel"
-
-    static var caseDisplayRepresentations: [FuelType: DisplayRepresentation] = [
-        .e10: "Unleaded",
-        .e5: "Premium",
-        .diesel: "Diesel",
-    ]
-}
-
 // MARK: - Intent
 
 struct CheapestFuelIntent: AppIntent {
@@ -102,14 +90,15 @@ struct CheapestFuelIntent: AppIntent {
 
         let distanceKM = station.distanceKM(to: coordinate.lat, lng2: coordinate.lng)
         let distanceText = FuelStore.loadDistanceUnit().format(distanceKM)
-        let priceText = String(format: "£%.3f", price / 100)
+        let priceText = FuelStore.priceText(price)
+        let priceSpoken = FuelStore.priceTextSpoken(price)
         let freshness = SiriCheapestLookup.freshnessLabel(
             updated: FuelStore.loadDataUpdated(),
             lastRefresh: FuelStore.loadLastRefresh()
         )
         let summary = "\(station.name): \(priceText), \(distanceText)"
         let freshnessClause = freshness.isEmpty ? "" : " — prices \(freshness)"
-        let dialog = "The cheapest \(fuel.displayName.lowercased()) near you is \(station.name) at \(priceText), \(distanceText) away\(freshnessClause)."
+        let dialog = "The cheapest \(fuel.displayName.lowercased()) near you is \(station.name) at \(priceSpoken), \(distanceText) away\(freshnessClause)."
 
         return .result(
             value: summary,
@@ -136,7 +125,7 @@ struct CheapestFuelIntent: AppIntent {
 struct DirectionsToCheapestFuelIntent: AppIntent {
     static var title: LocalizedStringResource = "Directions to Cheapest Fuel Near Me"
     static var description = IntentDescription(
-        "Opens Apple Maps directions to the cheapest station selling a fuel near you, using the latest cached prices."
+        "Opens directions to the cheapest station selling a fuel near you, using the latest cached prices."
     )
 
     @Parameter(title: "Fuel")
@@ -246,7 +235,8 @@ struct FavouriteFuelPriceIntent: AppIntent {
             )
         }
 
-        let priceText = String(format: "£%.3f", price / 100)
+        let priceText = FuelStore.priceText(price)
+        let priceSpoken = FuelStore.priceTextSpoken(price)
         let freshness = SiriCheapestLookup.freshnessLabel(
             updated: FuelStore.loadDataUpdated(),
             lastRefresh: FuelStore.loadLastRefresh()
@@ -270,7 +260,7 @@ struct FavouriteFuelPriceIntent: AppIntent {
             summary = "\(favourite.station.name): \(priceText)"
         }
 
-        let dialog = "Your favourite \(fuelName) station, \(favourite.station.name), is at \(priceText)\(distanceClause)\(freshnessClause)."
+        let dialog = "Your favourite \(fuelName) station, \(favourite.station.name), is at \(priceSpoken)\(distanceClause)\(freshnessClause)."
 
         return .result(
             value: summary,
@@ -295,7 +285,7 @@ struct FavouriteFuelPriceIntent: AppIntent {
 struct DirectionsToFavouriteFuelIntent: AppIntent {
     static var title: LocalizedStringResource = "Directions to Favourite Fuel Station"
     static var description = IntentDescription(
-        "Opens Apple Maps directions to your top favourite station for a fuel."
+        "Opens directions to your top favourite station for a fuel."
     )
 
     @Parameter(title: "Fuel")
@@ -414,7 +404,7 @@ struct FuelMessage: View {
 /// Shortcut slot and adds no phrase.
 struct OpenDirectionsIntent: AppIntent {
     static var title: LocalizedStringResource = "Directions"
-    static var description = IntentDescription("Opens Apple Maps directions to the station.")
+    static var description = IntentDescription("Opens directions to the station.")
     static var isDiscoverable: Bool = false
 
     @Parameter var stationName: String
@@ -499,19 +489,14 @@ struct FuelMessageSnippetIntent: SnippetIntent {
 
 struct FuelBoardShortcuts: AppShortcutsProvider {
     static var appShortcuts: [AppShortcut] {
-        // Generic parameterized shortcut — matches whatever fuel word Siri
-        // resolves. Parameter resolution is flaky on-device ("cheapest diesel"
-        // matched, "cheapest unleaded" didn't), which is why the fixed-fuel
-        // entries below carry the fuel word as LITERAL phrase text.
-        AppShortcut(
-            intent: CheapestFuelIntent(),
-            phrases: [
-                "Ask \(.applicationName) what's the cheapest \(\.$fuel) near me",
-            ],
-            shortTitle: "Cheapest Fuel",
-            systemImageName: "fuelpump"
-        )
-
+        // NOTE (2026-08-20): the generic parameterized shortcut ("cheapest
+        // ${fuel}") was REMOVED. It competed with the fixed-fuel literal-word
+        // shortcuts for the same intent (parameter resolution was already flaky
+        // on-device), which degraded Siri's NLU ranking and caused the
+        // hit-and-miss "can't do that, searching in app" fallback. Now Siri
+        // routes on literal fuel words only, and the freed slot keeps us under
+        // the 10-shortcut cap. Every phrase carries .applicationName (iOS 26
+        // metadata-processor requirement) and mirrors how people actually ask.
         AppShortcut(
             intent: CheapestFuelIntent(fuel: .e10),
             phrases: [
@@ -519,6 +504,10 @@ struct FuelBoardShortcuts: AppShortcutsProvider {
                 "Ask \(.applicationName) for the cheapest petrol near me",
                 "Find the cheapest petrol near me \(.applicationName)",
                 "Find the cheapest unleaded near me \(.applicationName)",
+                "What's the cheapest unleaded near me \(.applicationName)",
+                "What's the cheapest petrol near me \(.applicationName)",
+                "Cheapest unleaded near me \(.applicationName)",
+                "Where's the cheapest petrol \(.applicationName)",
             ],
             shortTitle: "Cheapest Unleaded",
             systemImageName: "fuelpump"

FuelBoard/SmartDataRefresh.swift

@@ -0,0 +1,89 @@
+import BackgroundTasks
+import Foundation
+import WidgetKit
+
+enum SmartDataRefreshScheduler {
+    static let taskIdentifier = "com.apt.fuelboard.smart-refresh"
+
+    static func register() {
+        BGTaskScheduler.shared.register(forTaskWithIdentifier: taskIdentifier, using: nil) { task in
+            guard let task = task as? BGAppRefreshTask else {
+                task.setTaskCompleted(success: false)
+                return
+            }
+            handle(task)
+        }
+    }
+
+    static func scheduleNextIfNeeded() {
+        BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: taskIdentifier)
+        guard FuelStore.loadDataRefreshMode() == .smart else { return }
+        let request = BGAppRefreshTaskRequest(identifier: taskIdentifier)
+        request.earliestBeginDate = Date(timeIntervalSinceNow: FuelStore.smartProbeInterval)
+        do {
+            try BGTaskScheduler.shared.submit(request)
+        } catch {
+            #if DEBUG
+            print("SMART-REFRESH schedule failed: \(error)")
+            #endif
+        }
+    }
+
+    private static func handle(_ task: BGAppRefreshTask) {
+        scheduleNextIfNeeded()
+        let refreshTask = Task {
+            let success = await SmartDataRefreshCoordinator.runBackgroundProbe()
+            task.setTaskCompleted(success: success)
+        }
+        task.expirationHandler = {
+            refreshTask.cancel()
+        }
+    }
+}
+
+enum SmartDataRefreshCoordinator {
+    @discardableResult
+    static func runBackgroundProbe(now: Date = Date()) async -> Bool {
+        guard FuelStore.loadDataRefreshMode() == .smart else { return true }
+        guard FuelStore.isSmartProbeDue(now: now) || FuelStore.loadStations().isEmpty else {
+            return true
+        }
+        FuelStore.saveLastSmartProbe(now)
+        guard !Task.isCancelled else { return false }
+
+        guard let latest = await FuelHistoryStore.fetchLatest() else {
+            return false
+        }
+
+        let latestDay = latest.availableTo ?? latest.date
+        let latestUpdated = latest.dataUpdated
+        let cachedDay = MirrorFuelProvider.loadDumpCache()?.day
+        let savedUpdated = FuelStore.loadDataUpdated()
+        let shouldFetchFullDump = FuelStore.loadStations().isEmpty
+            || !FuelStore.isCacheFresh(now: now)
+            || (latestDay != nil && latestDay != cachedDay)
+            || (latestUpdated != nil && latestUpdated != savedUpdated)
+
+        guard shouldFetchFullDump, !Task.isCancelled else { return true }
+
+        do {
+            let fetched = try await FuelPriceProvider.active.fetchStations(
+                near: nil,
+                lng: nil,
+                fuel: FuelStore.loadSelectedFuel(),
+                radiusKM: nil
+            )
+            guard !Task.isCancelled else { return false }
+            FuelStore.saveStations(fetched)
+            FuelStore.saveLastRefresh(now)
+            await WatchSyncManager.shared.pushSnapshot()
+            if let meta = LiveChainProvider.latestMeta {
+                FuelStore.saveRelayMeta(meta)
+            }
+            WidgetCenter.shared.reloadAllTimelines()
+            return true
+        } catch {
+            return false
+        }
+    }
+}

FuelBoard/StationDetailView.swift

@@ -0,0 +1,89 @@
+import SwiftUI
+import MapKit
+import UIKit
+
+/// Detail sheet for a tapped station (when Settings → Tap station = More info).
+/// Shows a small map preview, the station name, address, distance from the
+/// current location, and a Directions button that opens Apple Maps — the same
+/// destination a direct tap would have opened.
+struct StationDetailView: View {
+    let station: FuelStation
+    let location: Coordinate?
+    let distanceUnit: DistanceUnit
+    @Environment(\.dismiss) private var dismiss
+    @State private var showingReportIssueConfirmation = false
+
+    private let reportIssueURL = URL(string: "https://www.gov.uk/guidance/report-an-error-in-fuel-prices-or-forecourt-details")!
+
+    private var stationCoordinate: CLLocationCoordinate2D {
+        CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng)
+    }
+
+    var body: some View {
+        NavigationStack {
+            List {
+                Section {
+                    Map(position: .constant(.region(MKCoordinateRegion(
+                        center: stationCoordinate,
+                        span: MKCoordinateSpan(latitudeDelta: 0.02, longitudeDelta: 0.02)
+                    )))) {
+                        Marker(station.name, coordinate: stationCoordinate)
+                            .tint(.red)
+                    }
+                    .frame(height: 180)
+                    .clipShape(RoundedRectangle(cornerRadius: 12))
+                    .allowsHitTesting(false)
+                    .listRowInsets(EdgeInsets())
+                }
+                Section {
+                    LabeledContent("Name", value: station.name)
+                    LabeledContent("Address", value: "\(station.address), \(station.postcode)")
+                    if let location {
+                        let km = FuelStore.displayDistanceKM(
+                            station: station, userLat: location.lat, userLng: location.lng
+                        )
+                        LabeledContent("Distance", value: distanceUnit.format(km))
+                            .monospacedDigit()
+                    }
+                    ForEach(StationNotice.notices(for: station)) { notice in
+                        Label(notice.title, systemImage: notice.symbolName)
+                            .font(.subheadline.weight(.semibold))
+                            .foregroundStyle(.orange)
+                            .padding(.horizontal, 10)
+                            .padding(.vertical, 6)
+                            .background(Capsule().fill(Color.orange.opacity(0.14)))
+                    }
+                }
+                Section {
+                    Button {
+                        if let url = station.mapsDirectionsURL {
+                            UIApplication.shared.open(url)
+                        }
+                    } label: {
+                        Label("Directions", systemImage: "arrow.triangle.turn.up.right.diamond.fill")
+                    }
+                    Button(role: .destructive) {
+                        showingReportIssueConfirmation = true
+                    } label: {
+                        Label("Report issue", systemImage: "exclamationmark.bubble.fill")
+                    }
+                }
+            }
+            .navigationTitle(station.name)
+            .navigationBarTitleDisplayMode(.inline)
+            .alert("Report an error?", isPresented: $showingReportIssueConfirmation) {
+                Button("Cancel", role: .cancel) { }
+                Button("Report") {
+                    UIApplication.shared.open(reportIssueURL)
+                }
+            } message: {
+                Text("Are you sure you want to report an error in fuel prices or forecourt details? This will open in your chosen browser.")
+            }
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Done") { dismiss() }
+                }
+            }
+        }
+    }
+}

FuelBoard/StationNotice.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+/// Presentation-only notices derived from existing station metadata.
+///
+/// These do not alter `FuelStation`, persistence, filtering, sorting, or
+/// navigation. They are intentionally small and reusable so additional
+/// informational station notices can be added later from the UI layer.
+enum StationNotice: Identifiable, Equatable {
+    case membershipRequired
+
+    var id: String {
+        switch self {
+        case .membershipRequired: return "membershipRequired"
+        }
+    }
+
+    var title: String {
+        switch self {
+        case .membershipRequired: return "Membership required"
+        }
+    }
+
+    var symbolName: String {
+        switch self {
+        case .membershipRequired: return "creditcard.fill"
+        }
+    }
+
+    static func notices(for station: FuelStation) -> [StationNotice] {
+        isCostco(station) ? [.membershipRequired] : []
+    }
+
+    static func isCostco(_ station: FuelStation) -> Bool {
+        containsCostcoToken(station.brand) || containsCostcoToken(station.name)
+    }
+
+    private static func containsCostcoToken(_ value: String) -> Bool {
+        let tokens = value.uppercased().split { !$0.isLetter && !$0.isNumber }
+        return tokens.contains("COSTCO")
+    }
+}

FuelBoard/StationsView.swift

@@ -10,10 +10,12 @@ struct StationsView: View {
     @Binding var sortMode: SortMode
     @Binding var stationLimit: Int
     let distanceUnit: DistanceUnit
+    let priceDisplayStyle: PriceDisplayStyle
     let baselinePrice: Double?
     let topStationID: String?
     let location: Coordinate?
     let favouriteIDs: Set<String>
+    let stationTapAction: StationTapAction
     var onToggleFavourite: (FuelStation, FuelType) -> Void = { _, _ in }
     var onRefresh: () async -> Void = {}
 
@@ -24,27 +26,43 @@ struct StationsView: View {
     @State private var pageSize = 10
     @State private var visibleCount = 10
 
+    /// Price-rating legend (the "Key") lives in a sheet, opened from the
+    /// info button in the header — keeps the list focused on stations.
+    @State private var showKey = false
+
+    /// Station picked for the More-info sheet (tap action = showDetails).
+    @State private var detailStation: FuelStation?
+
+    /// Bottom-of-tab explainer (moved from the top 2026-08-16): mode/radius/
+    /// directions context + "N/TOTAL stations updated". The numerator is the
+    /// current list pool; the denominator is the full UK station total from
+    /// the last chain fetch (8,022 mirror snapshot) — hidden until known.
+    private var footerCaption: String {
+        let miles = distanceUnit.displayMiles(stationLimit)
+        let unit = distanceUnit.label(for: Double(miles))
+        let fuel = selectedFuel.displayName
+        let mode = sortMode == .closest ? "Closest" : "Cheapest"
+        let tapHint = stationTapAction == .openMap
+            ? "tap a station for directions."
+            : "tap a station for details."
+        let ratio: String
+        if let total = FuelStore.loadStationCount() {
+            ratio = "\(totalCount)/\(total)"
+        } else {
+            ratio = "\(totalCount)"
+        }
+        if location != nil {
+            if sortMode == .closest {
+                return "\(mode) \(fuel) stations — nearest first, best value within \(miles) \(unit) · \(ratio) stations updated"
+            }
+            return "\(mode) \(fuel) within \(miles) \(unit) — \(ratio) stations updated · \(tapHint)"
+        }
+        return "\(mode) \(fuel) — \(ratio) stations updated · \(tapHint)"
+    }
+
     var body: some View {
         NavigationStack {
             List {
-                Section {
-                    if let location {
-                        if sortMode == .closest {
-                            Text("Closest \(selectedFuel.displayName) stations — nearest first, best value within \(distanceUnit.displayMiles(stationLimit)) \(distanceUnit.label(for: Double(distanceUnit.displayMiles(stationLimit)))) · \(totalCount) stations")
-                                .font(.footnote)
-                                .foregroundStyle(.secondary)
-                        } else {
-                            Text("Cheapest \(selectedFuel.displayName) within \(distanceUnit.displayMiles(stationLimit)) \(distanceUnit.label(for: Double(distanceUnit.displayMiles(stationLimit)))) — \(totalCount) stations · tap a station for directions.")
-                                .font(.footnote)
-                                .foregroundStyle(.secondary)
-                        }
-                    } else {
-                        Text("\(sortMode == .closest ? "Closest" : "Cheapest") \(selectedFuel.displayName) — tap a station for directions.")
-                            .font(.footnote)
-                            .foregroundStyle(.secondary)
-                    }
-                }
-
                 Section("Fuel type") {
                     FuelTypeSegmentedPicker(selection: $selectedFuel) { newValue in
                         FuelStore.saveSelectedFuel(newValue)
@@ -90,8 +108,20 @@ struct StationsView: View {
                             Text("Fetching prices…")
                         }
                     } else if stations.isEmpty {
-                        Text("No \(selectedFuel.displayName) stations found.")
+                        let miles = distanceUnit.displayMiles(stationLimit)
+                        let unit = distanceUnit.label(for: Double(miles))
+                        VStack(alignment: .leading, spacing: 6) {
+                            Text(String(format: NSLocalizedString("No %@ stations within %lld %@.", comment: "Empty state when the radius finds nothing nearby"), selectedFuel.displayName, miles, unit))
                                 .foregroundStyle(.secondary)
+                            Text("FuelBoard covers the whole UK — try Closest to browse every station.")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                            Button("Browse all UK stations") {
+                                sortMode = .closest
+                            }
+                            .font(.caption)
+                        }
+                        .padding(.vertical, 4)
                     } else {
                         ForEach(Array(stations.prefix(visibleCount)), id: \.id) { station in
                             StationRow(
@@ -99,10 +129,13 @@ struct StationsView: View {
                                 fuel: selectedFuel,
                                 location: location,
                                 distanceUnit: distanceUnit,
+                                priceDisplayStyle: priceDisplayStyle,
                                 baselinePrice: baselinePrice,
                                 isTopResult: station.id == topStationID,
                                 isFavourite: favouriteIDs.contains(station.id),
-                                onToggleFavourite: { onToggleFavourite(station, selectedFuel) }
+                                tapAction: stationTapAction,
+                                onToggleFavourite: { onToggleFavourite(station, selectedFuel) },
+                                onShowDetails: { detailStation = $0 }
                             )
                         }
 
@@ -125,40 +158,15 @@ struct StationsView: View {
                     }
                 }
 
-                Section("Key") {
-                    HStack(spacing: 8) {
-                        Circle().fill(.green).frame(width: 12, height: 12)
-                        Text("Best value — within 1.5p of the cheapest")
+                // Bottom-of-tab explainer (moved from the top 2026-08-16),
+                // styled like the Favourites tab's cheapest callout: a caption
+                // paragraph in its own section cell.
+                Section {
+                    Text(footerCaption)
                         .font(.caption)
+                        .foregroundStyle(.secondary)
                 }
-                    HStack(spacing: 8) {
-                        Circle().fill(.orange).frame(width: 12, height: 12)
-                        Text("Okay — within 4p of the cheapest")
-                            .font(.caption)
-                    }
-                    HStack(spacing: 8) {
-                        Circle().fill(.red).frame(width: 12, height: 12)
-                        Text("Pricey — more than 4p over the cheapest")
-                            .font(.caption)
-                    }
-                    HStack(spacing: 8) {
-                        Text("TOP")
-                            .font(.caption2.bold())
-                            .padding(.horizontal, 5)
-                            .padding(.vertical, 1)
-                            .background(Capsule().fill(.blue.opacity(0.15)))
-                            .foregroundStyle(.blue)
-                        Text("Top result for the current sort")
-                            .font(.caption)
-                    }
-                    HStack(spacing: 8) {
-                        Image(systemName: "star.fill")
-                            .font(.caption2)
-                            .foregroundStyle(.yellow)
-                        Text("Star a station to add it to Favourites")
-                            .font(.caption)
-                    }
-                }
+
             }
             .refreshable {
                 // Manual override for the twice-a-day cache policy.
@@ -174,7 +182,142 @@ struct StationsView: View {
             // only renders text, which is exactly what we want here.
             .navigationTitle("FuelBoard")
             .navigationBarTitleDisplayMode(.large)
+            .onAppear {
+#if DEBUG
+                // QA hook: launch with `-showKeySheet` to verify the legend
+                // sheet without driving a tap (simctl has no tap command).
+                if ProcessInfo.processInfo.arguments.contains("-showKeySheet") {
+                    showKey = true
                 }
+#endif
+            }
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button {
+                        showKey = true
+                    } label: {
+                        Image(systemName: "info.circle")
+                    }
+                    .accessibilityLabel("Key")
+                }
+            }
+            .sheet(isPresented: $showKey) {
+                NavigationStack {
+                    List {
+                        Section {
+                            VStack(spacing: 10) {
+                                keyCard(
+                                    icon: "checkmark.circle.fill", color: .green,
+                                    title: "Best value", blurb: "Within 1.5p of the cheapest",
+                                    threshold: "≤1.5p")
+                                keyCard(
+                                    icon: "equal.circle.fill", color: .orange,
+                                    title: "Okay", blurb: "Within 4p of the cheapest",
+                                    threshold: "≤4p")
+                                keyCard(
+                                    icon: "exclamationmark.circle.fill", color: .red,
+                                    title: "Pricey", blurb: "More than 4p over the cheapest",
+                                    threshold: ">4p")
+                                Rectangle()
+                                    .fill(Color(.separator))
+                                    .frame(height: 0.5)
+                                    .padding(.vertical, 2)
+                                HStack(spacing: 12) {
+                                    Text("TOP")
+                                        .font(.caption2.bold())
+                                        .padding(.horizontal, 7)
+                                        .padding(.vertical, 3)
+                                        .background(Capsule().fill(.blue.opacity(0.16)))
+                                        .foregroundStyle(.blue)
+                                    Text("Top result for the current sort")
+                                        .font(.subheadline.weight(.semibold))
+                                    Spacer(minLength: 0)
+                                }
+                                .padding(.horizontal, 14)
+                                .padding(.vertical, 12)
+                                .keyCardFill(color: .blue)
+                                HStack(spacing: 12) {
+                                    Image(systemName: "star.fill")
+                                        .font(.title3)
+                                        .foregroundStyle(.yellow)
+                                        .frame(width: 34)
+                                    Text("Star a station to add it to Favourites")
+                                        .font(.subheadline.weight(.semibold))
+                                    Spacer(minLength: 0)
+                                }
+                                .padding(.horizontal, 14)
+                                .padding(.vertical, 12)
+                                .keyCardFill(color: .yellow)
+                                Text("Colours match each station's rating on the list")
+                                    .font(.footnote)
+                                    .foregroundStyle(.secondary)
+                                    .frame(maxWidth: .infinity)
+                                    .padding(.top, 4)
+                            }
+                            .listRowBackground(Color.clear)
+                            .listRowInsets(EdgeInsets(top: 4, leading: 16, bottom: 4, trailing: 16))
+                        }
+                    }
+                    .navigationTitle("Key")
+                    .navigationBarTitleDisplayMode(.inline)
+                    .toolbar {
+                        ToolbarItem(placement: .confirmationAction) {
+                            Button("Done") { showKey = false }
+                        }
+                    }
+                }
+                .presentationDetents([.fraction(0.6)])
+                .presentationBackground(Color(UIColor.systemGroupedBackground))
+            }
+            .sheet(item: $detailStation) { station in
+                StationDetailView(
+                    station: station,
+                    location: location,
+                    distanceUnit: distanceUnit
+                )
+            }
+        }
+    }
+
+    /// One price-rating card for the Key sheet: accent icon, title + blurb,
+    /// and the rating threshold in the accent colour (mirrors the tip cards).
+    private func keyCard(icon: String, color: Color, title: String, blurb: String, threshold: String) -> some View {
+        HStack(spacing: 12) {
+            Image(systemName: icon)
+                .font(.title3)
+                .foregroundStyle(color)
+                .frame(width: 34)
+            VStack(alignment: .leading, spacing: 2) {
+                Text(LocalizedStringKey(title)).font(.headline)
+                Text(LocalizedStringKey(blurb))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+            Spacer(minLength: 8)
+            HStack(spacing: 6) {
+                Circle().fill(color).frame(width: 10, height: 10)
+                Text(threshold)
+                    .font(.headline.weight(.bold))
+                    .foregroundStyle(color)
+                    .monospacedDigit()
+            }
+        }
+        .padding(.horizontal, 14)
+        .padding(.vertical, 10)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .keyCardFill(color: color)
+    }
+}
+
+/// Card background shared by the Key sheet cards — subtle accent tint over
+/// the grouped background, matching the tip-section card style.
+private extension View {
+    func keyCardFill(color: Color) -> some View {
+        background(
+            RoundedRectangle(cornerRadius: 12)
+                .fill(Color(.secondarySystemGroupedBackground))
+                .overlay(RoundedRectangle(cornerRadius: 12).fill(color.opacity(0.08)))
+        )
     }
 }
 
@@ -190,17 +333,6 @@ extension FuelType {
         case .diesel: return "Diesel"
         }
     }
-
-    /// Fuel colour wheel (user-chosen palette): green = unleaded (#30D158),
-    /// yellow = premium (#FFD60A), cyan = diesel (#64D2FF). Used for the
-    /// fuel-type tab icons and the title icon.
-    var tintColor: Color {
-        switch self {
-        case .e10: return Color(red: 48/255.0, green: 209/255.0, blue: 88/255.0)      // #30D158
-        case .e5: return Color(red: 255/255.0, green: 214/255.0, blue: 10/255.0)      // #FFD60A
-        case .diesel: return Color(red: 100/255.0, green: 210/255.0, blue: 255/255.0) // #64D2FF
-        }
-    }
 }
 
 /// Fuel-type selector styled like a segmented control, with a coloured pump
@@ -215,20 +347,26 @@ struct FuelTypeSegmentedPicker: View {
     var fuels: [FuelType] = FuelType.allCases
     var onSelect: (FuelType) -> Void = { _ in }
 
+    @Namespace private var selectionSlider
+
     var body: some View {
         HStack(spacing: 3) {
             ForEach(fuels) { fuel in
                 let isSelected = fuel == selection
                 Button {
+                    withAnimation(.spring(response: 0.42, dampingFraction: 0.78)) {
                         selection = fuel
+                    }
                     onSelect(fuel)
                 } label: {
                     HStack(spacing: 5) {
                         Image(systemName: "fuelpump.fill")
                             .font(.caption2)
                             .foregroundStyle(fuel.tintColor)
+                            .scaleEffect(isSelected ? 1.08 : 0.94)
                         Text(fuel.shortName)
                             .font(.subheadline.weight(isSelected ? .semibold : .regular))
+                            .contentTransition(.opacity)
                     }
                     .foregroundStyle(isSelected ? Color.primary : Color.secondary)
                     .frame(maxWidth: .infinity)
@@ -237,14 +375,29 @@ struct FuelTypeSegmentedPicker: View {
                         if isSelected {
                             Capsule()
                                 .fill(Color(UIColor.systemBackground))
-                                .shadow(color: .black.opacity(0.08), radius: 1, y: 0.5)
+                                .overlay {
+                                    Capsule()
+                                        .stroke(fuel.tintColor.opacity(0.28), lineWidth: 1)
+                                }
+                                .shadow(color: fuel.tintColor.opacity(0.16), radius: 6, y: 2)
+                                .matchedGeometryEffect(id: "fuelSelectionSlider", in: selectionSlider)
                         }
                     }
+                    .scaleEffect(isSelected ? 1.02 : 0.98)
+                    .contentShape(Capsule())
                 }
                 .buttonStyle(.plain)
             }
         }
         .padding(3)
         .background(Capsule().fill(Color(.secondarySystemBackground)))
+        .animation(.spring(response: 0.42, dampingFraction: 0.78), value: selection)
     }
 }
+
+#Preview("Fuel Picker") {
+    @Previewable @State var selectedFuel: FuelType = .e10
+    FuelTypeSegmentedPicker(selection: $selectedFuel)
+        .padding()
+        .background(Color(.systemGroupedBackground))
+}