feat: indicate Costco membership requirement

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,6 +1,7 @@
 build/
 build-release/
 build-sim/
+build-watch/
 .DS_Store
 *.xcuserstate
 xcuserdata/

BACKLOG.md

@@ -13,20 +13,30 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
 
 ## P1 — Soon
 
-- [ ] **Move relay + mirror off the Mac mini (plan for 2026-08-16)** — dedicated
+- [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 ~110, hostname `fuelboard-relay`, 1 core/1 GB/8 GB, static IP
+  (CT **111**, hostname **`fuelboard-relay`**, 1 core/512 MB/2 GB, static IP
-  ~192.168.1.150, plain LXC — NO Docker layer). Scope: relay AND mirror both
+  **192.168.1.113**, plain LXC — NO Docker layer). Scope: relay AND mirror
-  move (full Mac independence; relay binds loopback only, GitHub is the only
+  both moved (full Mac independence; relays bind **loopback only**, GitHub is
-  public surface). Steps: user creates CT on pve → install Python (trixie =
+  the only public surface). What landed: Python 3.13.5 (trixie) boots both
-  3.13 vs Mac 3.14 — verify relay boots) + relay source + `.env` (GOV.UK
+  relays (relay 8788 demo/CSV + relay-api 8789 `source: api`, 8,024 stations,
-  token) → copy deploy key `~/.ssh/fuelboard_deploy` + `github-fuelboard-data`
+  ~2 min first sync, 0 failures); source at `/root/workspace/fuelboard-{relay,relay-api}`
-  ssh config → systemd `fuelboard-relay.service` (Restart=always,
+  (venvs + pip, `.env` chmod 600); deploy key `fuelboard_deploy` +
-  127.0.0.1:8789/8788) + `fuelboard-mirror.timer` (10:00 + 16:00) + service →
+  `github-fuelboard-data` ssh config + `fuelboard-data` clone at
-  relocate `mirror_push.py` (RELAY line → localhost on CT) + fuelboard-data
+  `/root/workspace/fuelboard-data` (origin = ssh alias, green + synced);
-  clone → verify one live push → remove Mac launchd
+  `mirror_push.py` → `/root/scripts/mirror_push.py` (RELAY line already
-  `com.apt.fuelboard-{relay,mirror}`. Open: confirm IP; logs move to
+  `127.0.0.1:8789`); systemd `fuelboard-relay.service` +
-  journalctl.
+  `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
@@ -96,6 +106,19 @@ 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).
 - [x] **Offline first-run** — bundled REAL 8,022-station dump (`FuelBoardDump`,
@@ -121,13 +144,50 @@ Status: TODO / IN PROGRESS / DONE / BLOCKED.
   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
+- [ ] **Watch app v1 — favourites + Check now** — small Apple Watch companion,
-  app-group store; watch target would need to be added to the project).
+  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

Config/App-Info.plist

@@ -30,7 +30,7 @@
 		</dict>
 	</array>
 	<key>CFBundleVersion</key>
-	<string>2</string>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
 	<key>NSLocalNetworkUsageDescription</key>
@@ -41,8 +41,13 @@
 	<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,9 +17,9 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.1</string>
+	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleVersion</key>
-	<string>2</string>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSExtension</key>
 	<dict>
 		<key>NSExtensionPointIdentifier</key>

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 */
+		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;
+		};
+		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;
+		};
 		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 */ = {
 			isa = PBXNativeTarget;
-			buildConfigurationList = BB0000000000000000000010 /* Build configuration list for PBXNativeTarget "FuelBoard" */;
+			buildConfigurationList = ADCE5B593033A32B008C131C /* Build configuration list for PBXNativeTarget "FuelBoardWatch Watch App" */;
 			buildPhases = (
-				BB0000000000000000000011 /* Sources */,
+				ADCE5B4B3033A329008C131C /* Sources */,
-				BB000000000000000000000B /* Frameworks */,
+				ADCE5B4C3033A329008C131C /* Frameworks */,
-				BB0000000000000000000012 /* Resources */,
+				ADCE5B4D3033A329008C131C /* Resources */,
-				BB0000000000000000000006 /* Embed App Extensions */,
 			);
 			buildRules = (
 			);
 			dependencies = (
-				BB0000000000000000000013 /* PBXTargetDependency */,
 			);
 			fileSystemSynchronizedGroups = (
-				BB0000000000000000000008 /* FuelBoard */,
+				ADCE5B503033A329008C131C /* FuelBoardWatch Watch App */,
-				BB000000000000000000000A /* Shared */,
 			);
-			name = FuelBoard;
+			name = "FuelBoardWatch Watch App Extension";
 			packageProductDependencies = (
 			);
-			productName = FuelBoard;
+			productName = "FuelBoardWatch Watch App Extension";
-			productReference = BB0000000000000000000007 /* FuelBoard.app */;
+			productReference = ADCE5B633033A32D008C131C /* FuelBoardWatch Watch App Extension.appex */;
-			productType = "com.apple.product-type.application";
+			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 = {
+					ADCE5B4E3033A329008C131C = {
-						CreatedOnToolsVersion = 16.0;
+						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_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 3;
+				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;
+				CODE_SIGN_ENTITLEMENTS = Config/WatchApp.entitlements;
+				INFOPLIST_FILE = Config/WatchExtension-Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.1;
+				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_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 3;
+				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;
+				CODE_SIGN_ENTITLEMENTS = Config/WatchApp.entitlements;
+				INFOPLIST_FILE = Config/WatchExtension-Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MARKETING_VERSION = 1.0.1;
+				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 = 3;
+				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.1;
+				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 = 3;
+				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.1;
+				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 = 3;
+				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.1;
 				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 = 3;
+				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.1;
 				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 = 3;
+				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.1;
 				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 = 3;
+				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.1;
 				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" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
-				BB0000000000000000000018 /* Debug */,
+				ADCE5B573033A32B008C131C /* Debug */,
-				BB0000000000000000000019 /* Release */,
+				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.
@@ -131,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)
@@ -152,7 +170,7 @@ struct AlertsView: View {
                             .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. Smaller radii ping more often but later; larger radii ping rarely in town but earlier from afar.")
                 }
@@ -165,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

@@ -1,38 +1,170 @@
 {
-  "images" : [
+  "images": [
     {
-      "filename" : "AppIcon.png",
+      "filename": "AppIcon.png",
-      "idiom" : "universal",
+      "idiom": "universal",
-      "platform" : "ios",
+      "platform": "ios",
-      "size" : "1024x1024"
+      "size": "1024x1024"
     },
     {
-      "appearances" : [
+      "appearances": [
         {
-          "appearance" : "luminosity",
+          "appearance": "luminosity",
-          "value" : "dark"
+          "value": "dark"
         }
       ],
-      "filename" : "AppIcon-dark.png",
+      "filename": "AppIcon-dark.png",
-      "idiom" : "universal",
+      "idiom": "universal",
-      "platform" : "ios",
+      "platform": "ios",
-      "size" : "1024x1024"
+      "size": "1024x1024"
     },
     {
-      "appearances" : [
+      "appearances": [
         {
-          "appearance" : "luminosity",
+          "appearance": "luminosity",
-          "value" : "tinted"
+          "value": "tinted"
         }
       ],
-      "filename" : "AppIcon-tinted.png",
+      "filename": "AppIcon-tinted.png",
-      "idiom" : "universal",
+      "idiom": "universal",
-      "platform" : "ios",
+      "platform": "ios",
-      "size" : "1024x1024"
+      "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" : {
+  "info": {
-    "author" : "xcode",
+    "author": "xcode",
-    "version" : 1
+    "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/ContentView.swift

@@ -2,19 +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()
@@ -30,6 +43,41 @@ 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
@@ -50,6 +98,20 @@ struct ContentView: View {
     @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
@@ -152,59 +214,16 @@ struct ContentView: View {
     }
 
     var body: some View {
-        VStack(spacing: 0) {
+        configuredContent
-            switch dataStatus {
-            case .offlineDump(let date):
-                let title = offlineTitle(date: date)
-                statusBanner(
-                    icon: "wifi.slash",
-                    tint: .orange,
-                    title: title,
-                    subtitle: NSLocalizedString("Pull to refresh on the Stations tab", comment: ""),
-                    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)
-                )
-            case .connectionProblem:
-                statusBanner(
-                    icon: "wifi.exclamationmark",
-                    tint: .red,
-                    title: NSLocalizedString("Check your internet connection", comment: ""),
-                    subtitle: NSLocalizedString("Tap to try again", comment: ""),
-                    accessibilityLabel: NSLocalizedString("Check your internet connection. Tap to try again", comment: "")
-                )
-            case .live:
-                EmptyView()
     }
-            TabView(selection: $selectedTab) {
-            stationsTab
-                .tabItem { Label("Stations", systemImage: "fuelpump.fill") }
-                .tag(0)
 
-            favouritesTab
+    private var configuredContent: AnyView {
-                .tabItem { Label("Favourites", systemImage: "star.fill") }
+        interactionObservedContent
-                .tag(1)
-
-            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") }
-            .tag(2)
-
-            settingsTab
-                .tag(3)
     }
+
+    private var presentedContent: AnyView {
+        AnyView(
+            mainContent
                 .fullScreenCover(isPresented: $showOnboarding) {
                     OnboardingView {
                         showOnboarding = false
@@ -216,21 +235,73 @@ struct ContentView: View {
                 .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.
-            if let i = args.firstIndex(of: "-seedFavourite"), i + 1 < args.count {
+            // Repeatable: each occurrence adds another favourite (QA temp).
-                let query = args[i + 1]
+            // Optional ":fuel" suffix (e10|e5|diesel) picks the
-                if let station = FuelStore.loadStations()
+            // fuel, so the fuel-aware Trends open can be verified (QA temp).
-                    .first(where: { $0.name.localizedCaseInsensitiveContains(query) }) {
+            let seedQueries = args.enumerated()
-                    FuelStore.saveFavourites([FavouriteEntry(station: station, fuel: .e10)])
+                .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 {
@@ -241,6 +312,14 @@ struct ContentView: View {
                 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).
@@ -254,6 +333,9 @@ struct ContentView: View {
                     : 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
@@ -261,30 +343,38 @@ struct ContentView: View {
             // Launch-arg hook (UI-testing/screenshot harness, same pattern as
             // StationsView's `-showKeySheet`): skip onboarding without
             // touching the stored flag.
-            if FuelStore.loadHasCompletedOnboarding()
+#if DEBUG
-                || args.contains("-skipOnboarding") {
+            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:
+                // Geofences and the Live Activity must follow the user even in
-                // wire the delegate hook (fires on every fix incl. background
+                // the background: wire the delegate hook (fires on every fix
-                // significant-change wake-ups) to re-register the region
+                // incl. background significant-change wake-ups) so SwiftUI's
-                // window around the new position. SwiftUI onChange alone
+                // foreground-only onChange isn't the only update path.
-                // never runs while suspended, so alerts would otherwise stay
+                installLocationUpdateHook()
-                // frozen around the last foreground fix.
+                ensureBackgroundMotionTrackingIfNeeded()
-                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()
-                }
                 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 !args.contains("-forceOfflineDump") && !args.contains("-forceConnectionProblem") && !args.contains("-forceHistoryFailure") {
+#if DEBUG
+                let shouldSkipInitialRefresh = args.contains("-forceOfflineDump")
+                    || args.contains("-forceConnectionProblem")
+                    || args.contains("-forceHistoryFailure")
+#else
+                let shouldSkipInitialRefresh = false
+#endif
+                if !shouldSkipInitialRefresh {
                     Task { await refresh() }
                 }
             } else {
@@ -301,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()
@@ -318,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()
             }
@@ -327,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
@@ -358,9 +463,7 @@ struct ContentView: View {
             monitor.setEnabled(newValue)
             monitor.update(stations: stations, favourites: refreshedFavourites,
                            fuel: alertsFuel, radiusKM: effectiveAlertsRadiusKM)
-            if newValue {
+            ensureBackgroundMotionTrackingIfNeeded()
-                locationManager.startBackgroundTracking()
-            }
         }
         .onChange(of: alertsRadius) { _, newValue in
             FuelStore.saveAlertsRadius(newValue)
@@ -381,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
@@ -420,8 +530,114 @@ struct ContentView: View {
             // so reading storage here could push the OLD style.
             updateLiveActivity(priceDisplayStyleOverride: newValue)
         }
-        }  // VStack: status banner + TabView
+        )
-        .animation(.spring(response: 0.3, dampingFraction: 0.8), value: dataStatus)
+    }
+
+    /// 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
@@ -432,13 +648,51 @@ struct ContentView: View {
             : String(format: NSLocalizedString("Offline data from %@", comment: ""), date)
     }
 
-    /// Shared status-strip chrome: a tappable card pinned above the tabs.
+    /// ONE floating banner style for all notifications. Network/offline and
-    /// Tapping retries the live fetch from ANY screen — no pull gesture
+    /// tip outcomes share the same chrome; only the tap action differs —
-    /// needed, so the offline banner isn't trapped on the Stations tab.
+    /// network → retry the fetch, tip → dismiss (TipStore auto-dismisses too).
-    private func statusBanner(icon: String, tint: Color, title: String, subtitle: String, accessibilityLabel: String) -> some View {
+    @ViewBuilder
-        Button {
+    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) }
-        } label: {
+            }
+        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))
@@ -448,12 +702,14 @@ struct ContentView: View {
                     Text(title)
                         .font(.subheadline.weight(.semibold))
                         .foregroundStyle(.primary)
+                    if let subtitle {
                         Text(subtitle)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                     }
+                }
                 Spacer()
-                Image(systemName: "arrow.clockwise")
+                Image(systemName: trailingIcon)
                     .font(.system(size: 14, weight: .semibold))
                     .foregroundStyle(tint)
             }
@@ -466,13 +722,13 @@ struct ContentView: View {
                         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)
-            .padding(.bottom, 6)
         }
+        .contentShape(Rectangle())
         .buttonStyle(.plain)
         .accessibilityLabel(accessibilityLabel)
-        .transition(.move(edge: .top).combined(with: .opacity))
     }
 
     /// Pushes the current best-in-radius station into the Live Activity.
@@ -511,6 +767,7 @@ struct ContentView: View {
             topStationID: topStationID,
             location: location,
             favouriteIDs: favouriteIDs,
+            stationTapAction: stationTapAction,
             onToggleFavourite: toggleFavourite,
             onRefresh: { await refresh(force: true) }
         )
@@ -525,6 +782,7 @@ struct ContentView: View {
             location: location,
             distanceUnit: distanceUnit,
             priceDisplayStyle: priceDisplayStyle,
+            stationTapAction: stationTapAction,
             onToggleFavourite: toggleFavourite,
             onReorder: reorderFavourites,
             onHistoryUnavailable: { if dataStatus == .live { dataStatus = .connectionProblem } },
@@ -532,12 +790,39 @@ struct ContentView: View {
         )
     }
 
+    /// 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) }
+            }
+        )
+    }
+
     /// The Settings tab, extracted from `body` so the TabView expression stays
     /// 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,
@@ -566,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)
@@ -577,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 {
@@ -591,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,
@@ -599,6 +892,10 @@ struct ContentView: View {
             stations = fetched
             FuelStore.saveStations(fetched)
             FuelStore.saveLastRefresh()
+            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.
@@ -610,11 +907,20 @@ 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 {
+            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
@@ -653,7 +959,9 @@ struct StationRow: View {
     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 }
@@ -673,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)
@@ -684,14 +1007,14 @@ struct StationRow: View {
                         .padding(5)
                 } else {
                     Image(systemName: "fuelpump.fill")
-                        .font(.system(size: 22))
+                        .font(.system(size: 22, weight: .semibold))
-                        .foregroundStyle(.white)
+                        .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
@@ -709,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)
@@ -716,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()
@@ -751,11 +1080,8 @@ struct StationRow: View {
             .buttonStyle(.borderless)
         }
         .contentShape(Rectangle())
-        .onTapGesture {
+        .onTapGesture(perform: handleTap)
-            if let url = station.mapsDirectionsURL {
+        .onLongPressGesture(perform: showDetails)
-                UIApplication.shared.open(url)
-            }
-        }
     }
 }
 

FuelBoard/FavouritesView.swift

@@ -14,6 +14,7 @@ struct FavouritesView: View {
     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 }
@@ -37,6 +38,9 @@ struct FavouritesView: View {
     /// 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)
     }
@@ -65,6 +69,7 @@ struct FavouritesView: View {
          location: Coordinate?,
          distanceUnit: DistanceUnit,
          priceDisplayStyle: PriceDisplayStyle,
+         stationTapAction: StationTapAction,
          onToggleFavourite: @escaping (FuelStation, FuelType) -> Void = { _, _ in },
          onReorder: @escaping ([FavouriteEntry]) -> Void = { _ in },
          onHistoryUnavailable: (() -> Void)? = nil,
@@ -74,6 +79,7 @@ struct FavouritesView: View {
         self.location = location
         self.distanceUnit = distanceUnit
         self.priceDisplayStyle = priceDisplayStyle
+        self.stationTapAction = stationTapAction
         self.onToggleFavourite = onToggleFavourite
         self.onReorder = onReorder
         self.onHistoryUnavailable = onHistoryUnavailable
@@ -129,7 +135,9 @@ struct FavouritesView: View {
                                 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)
@@ -171,12 +179,21 @@ struct FavouritesView: View {
                     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),
+        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
-              let items = components.queryItems
+        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

@@ -57,7 +57,7 @@ enum LiveActivityManager {
             brand: best.brand,
             pricePence: price,
             priceDisplayStyle: priceDisplayStyle ?? FuelStore.loadPriceDisplayStyle(),
-            distanceKM: best.distanceKM(to: location.lat, lng2: location.lng),
+            distanceKM: FuelStore.displayDistanceKM(station: best, userLat: location.lat, userLng: location.lng),
             lat: best.lat,
             lng: best.lng,
             updatedAt: Date()

FuelBoard/OnboardingView.swift

@@ -85,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.
@@ -122,8 +122,7 @@ struct OnboardingView: View {
     private var locationPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
+            AnimatedOnboardingIcon(tint: .blue, motion: .locationArrow) {
-                Circle().fill(Color.blue.opacity(0.12)).frame(width: 96, height: 96)
                 Image(systemName: "location.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.blue)
@@ -154,8 +153,7 @@ struct OnboardingView: View {
     private var notificationsPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
+            AnimatedOnboardingIcon(tint: .orange, motion: .alarmBell) {
-                Circle().fill(Color.orange.opacity(0.12)).frame(width: 96, height: 96)
                 Image(systemName: "bell.badge.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.orange)
@@ -186,8 +184,7 @@ struct OnboardingView: View {
     private var dataPage: some View {
         VStack(spacing: 0) {
             Spacer()
-            ZStack {
+            AnimatedOnboardingIcon(tint: .teal, motion: .downloadArrow) {
-                Circle().fill(Color.teal.opacity(0.12)).frame(width: 96, height: 96)
                 Image(systemName: "arrow.down.circle.fill")
                     .font(.system(size: 40, weight: .semibold))
                     .foregroundStyle(.teal)
@@ -248,19 +245,27 @@ struct OnboardingView: View {
             ) {
                 if prompter.locationDenied {
                     openSettings()
+                } else if prompter.locationGranted {
+                    page = 2  // already decided — just move on
                 } else {
-                    // The prompt fires on LEAVING this page (onChange(of:
+                    // Fire the system prompt NOW, while this page is still on
-                    // page), forward advance only) — the description is on
+                    // screen (after it's been read) and BEFORE advancing — so
-                    // screen until the user moves on.
+                    // the prompt never covers the next page's animation. Auto-
-                    page = 2
+                    // 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")
             ) {
-                // Prompt fires on leaving this page (same rule as Location).
+                if prompter.notificationsDenied || prompter.notificationsGranted {
-                page = 3
+                    page = 3  // decided either way — move on
+                } else {
+                    // Same rule as Location: prompt now, before advancing.
+                    prompter.requestNotifications()
+                }
             }
         case 3:
             // No permission on this page — prices need none. Straight on.
@@ -326,10 +331,103 @@ 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
@@ -358,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
+                    do {
-                        Task { @MainActor in
+                        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

FuelBoard/ProximityMonitor.swift

@@ -79,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?
@@ -218,6 +222,46 @@ 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)
@@ -452,6 +496,31 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
         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
@@ -725,9 +794,11 @@ final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLoca
         }
     }
 
-    /// Tapping a notification opens Apple Maps directions to the station from
+    /// Tapping a notification honours Settings → Tap station: Open map opens
-    /// the user's current location. If Apple Maps can't be opened (e.g. inside
+    /// Apple Maps directions to the station from the user's current location;
-    /// LiveContainer), an in-app map sheet with directions is shown instead.
+    /// 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
@@ -752,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.
@@ -762,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,8 +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
@@ -53,9 +58,6 @@ struct SettingsView: View {
     /// 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).
@@ -103,6 +105,7 @@ 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
@@ -113,6 +116,7 @@ struct SettingsView: View {
                     .onChange(of: priceDisplayStyle) { _, newValue in
                         FuelStore.savePriceDisplayStyle(newValue)
                         WidgetCenter.shared.reloadAllTimelines()
+                        WatchSyncManager.shared.pushSnapshot()
                     }
                 } header: {
                     Text("Units")
@@ -120,6 +124,46 @@ struct SettingsView: View {
                     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()
@@ -359,13 +403,6 @@ struct SettingsView: View {
                     Text("About")
                 }
 
-                if let message = tipStore.message {
-                    Section {
-                        Text(message)
-                            .font(.footnote)
-                            .foregroundStyle(.secondary)
-                    }
-                }
             }
             .navigationTitle("Settings")
             .onAppear {
@@ -408,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)
@@ -567,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: "")
                         }
                     }
                 }
@@ -606,9 +647,19 @@ final class TipStore: ObservableObject {
                 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?
+
+    /// 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
@@ -626,6 +677,7 @@ final class TipStore: ObservableObject {
 
     deinit {
         updatesTask?.cancel()
+        dismissTask?.cancel()
     }
 
     private func handle(_ update: VerificationResult<StoreKit.Transaction>) async {
@@ -634,7 +686,30 @@ final class TipStore: ObservableObject {
         // Only acknowledge our own consumables (future products get their own).
         guard Self.tiers.contains(where: { $0.id == transaction.productID }) else { return }
         await transaction.finish()
-        message = NSLocalizedString("Thank you! Your tip has been received. ⛽", comment: "")
+        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 {
@@ -663,7 +738,11 @@ final class TipStore: ObservableObject {
         // Connect yet), still allow the attempt so the user sees a clear
         // outcome rather than a dead button.
         guard let product = products[tier.id] else {
-            message = NSLocalizedString("The tip isn't available in this build yet — check back after an App Store release.", comment: "")
+            showOutcome(
+                NSLocalizedString("The tip isn't available in this build yet — check back after an App Store release.", comment: ""),
+                icon: "info.circle.fill",
+                tint: Color(.secondaryLabel)
+            )
             return
         }
 
@@ -676,19 +755,35 @@ final class TipStore: ObservableObject {
                     // Consume the consumable — otherwise StoreKit re-delivers
                     // it through Transaction.updates on every launch.
                     await transaction.finish()
-                    message = NSLocalizedString("Thank you! Your tip has been received. ⛽", comment: "")
+                    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 {
@@ -137,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")
@@ -297,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")
@@ -416,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
@@ -501,19 +489,14 @@ struct FuelMessageSnippetIntent: SnippetIntent {
 
 struct FuelBoardShortcuts: AppShortcutsProvider {
     static var appShortcuts: [AppShortcut] {
-        // Generic parameterized shortcut — matches whatever fuel word Siri
+        // NOTE (2026-08-20): the generic parameterized shortcut ("cheapest
-        // resolves. Parameter resolution is flaky on-device ("cheapest diesel"
+        // ${fuel}") was REMOVED. It competed with the fixed-fuel literal-word
-        // matched, "cheapest unleaded" didn't), which is why the fixed-fuel
+        // shortcuts for the same intent (parameter resolution was already flaky
-        // entries below carry the fuel word as LITERAL phrase text.
+        // on-device), which degraded Siri's NLU ranking and caused the
-        AppShortcut(
+        // hit-and-miss "can't do that, searching in app" fallback. Now Siri
-            intent: CheapestFuelIntent(),
+        // routes on literal fuel words only, and the freed slot keeps us under
-            phrases: [
+        // the 10-shortcut cap. Every phrase carries .applicationName (iOS 26
-                "Ask \(.applicationName) what's the cheapest \(\.$fuel) near me",
+        // metadata-processor requirement) and mirrors how people actually ask.
-            ],
-            shortTitle: "Cheapest Fuel",
-            systemImageName: "fuelpump"
-        )
-
         AppShortcut(
             intent: CheapestFuelIntent(fuel: .e10),
             phrases: [
@@ -521,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

@@ -15,6 +15,7 @@ struct StationsView: View {
     let topStationID: String?
     let location: Coordinate?
     let favouriteIDs: Set<String>
+    let stationTapAction: StationTapAction
     var onToggleFavourite: (FuelStation, FuelType) -> Void = { _, _ in }
     var onRefresh: () async -> Void = {}
 
@@ -29,6 +30,9 @@ struct StationsView: View {
     /// 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
@@ -38,19 +42,22 @@ struct StationsView: View {
         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 let location {
+        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 · tap a station for directions."
+            return "\(mode) \(fuel) within \(miles) \(unit) — \(ratio) stations updated · \(tapHint)"
         }
-        return "\(mode) \(fuel) — \(ratio) stations updated · tap a station for directions."
+        return "\(mode) \(fuel) — \(ratio) stations updated · \(tapHint)"
     }
 
     var body: some View {
@@ -126,7 +133,9 @@ struct StationsView: View {
                                 baselinePrice: baselinePrice,
                                 isTopResult: station.id == topStationID,
                                 isFavourite: favouriteIDs.contains(station.id),
-                                onToggleFavourite: { onToggleFavourite(station, selectedFuel) }
+                                tapAction: stationTapAction,
+                                onToggleFavourite: { onToggleFavourite(station, selectedFuel) },
+                                onShowDetails: { detailStation = $0 }
                             )
                         }
 
@@ -174,11 +183,13 @@ struct StationsView: View {
             .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) {
@@ -258,6 +269,13 @@ struct StationsView: View {
                 .presentationDetents([.fraction(0.6)])
                 .presentationBackground(Color(UIColor.systemGroupedBackground))
             }
+            .sheet(item: $detailStation) { station in
+                StationDetailView(
+                    station: station,
+                    location: location,
+                    distanceUnit: distanceUnit
+                )
+            }
         }
     }
 
@@ -315,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
@@ -340,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)
@@ -362,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))
+}

FuelBoard/TrendsView.swift

@@ -13,6 +13,8 @@ struct TrendsView: View {
     /// All favourites (fuel-scoped entries) — the sheet derives the active
     /// fuel's stations and which fuels have favourites.
     let favourites: [FavouriteEntry]
+    /// The fuel the Favourites tab is showing when the Trends button is
+    /// tapped — the sheet must open on the same fuel, not always .e10.
     let selectedFuel: FuelType
     let priceDisplayStyle: PriceDisplayStyle
 
@@ -23,6 +25,7 @@ struct TrendsView: View {
     var onHistoryRecovered: (() -> Void)? = nil
 
     @Environment(\.dismiss) private var dismiss
+    @Environment(\.accessibilityReduceMotion) private var reduceMotion
 
     @State private var fuel: FuelType = .e10
     @State private var rangeDays: Int = 30
@@ -32,6 +35,28 @@ struct TrendsView: View {
     @State private var loadFailed = false
     @State private var firstSnapshot: String?
 
+    /// Per-series draw-in waterline: maps stationID → how many leading points
+    /// are revealed, so each line traces left→right on first appearance.
+    /// Series reveal in a short staggered cascade so the draw is clearly
+    /// visible even with only 2 points per line. Stays full after the first
+    /// reveal so range/mode switches morph instead of re-tracing.
+    @State private var revealed: [String: Int] = [:]
+
+    /// Seeded from `selectedFuel` (the fuel the tab was on) so the sheet
+    /// opens where the user was — same pattern as FavouritesView.
+    init(favourites: [FavouriteEntry],
+         selectedFuel: FuelType,
+         priceDisplayStyle: PriceDisplayStyle,
+         onHistoryUnavailable: (() -> Void)? = nil,
+         onHistoryRecovered: (() -> Void)? = nil) {
+        self.favourites = favourites
+        self.selectedFuel = selectedFuel
+        self.priceDisplayStyle = priceDisplayStyle
+        self.onHistoryUnavailable = onHistoryUnavailable
+        self.onHistoryRecovered = onHistoryRecovered
+        _fuel = State(initialValue: selectedFuel)
+    }
+
     enum TrendsMode: String, CaseIterable, Identifiable {
         case price
         case vsCheapest
@@ -85,7 +110,34 @@ struct TrendsView: View {
         }
     }
 
+    /// Y-domain hugging the displayed data (RevenueCat-style tight scale).
+    /// Without it Swift Charts pads a sparse series (e.g. 3 days of ~150.7p)
+    /// out to a 0→200 axis, wasting the plot area. Pad by ~4% of the range
+    /// (min 0.5p) so the line doesn't kiss the top edge.
+    private var yDomain: ClosedRange<Double> {
+        let values = displaySeries.flatMap { $0.points.map(\.pence) }
+        guard let lo = values.min(), let hi = values.max() else {
+            return 0...1
+        }
+        let pad = max((hi - lo) * 0.04, 0.5)
+        return (lo - pad)...(hi + pad)
+    }
+
+    /// Depth of each series' gradient fill band, in pence. Band instead of
+    /// fill-to-axis: with 2+ favourites, full-height unstacked fills overlap
+    /// and wash out the lower lines (observed on device 2026-08-17). A band
+    /// of ~18% of the y-range under each line keeps every area visible and
+    /// gives the RevenueCat "fade under the line" look.
+    private var fillBand: Double {
+        let values = displaySeries.flatMap { $0.points.map(\.pence) }
+        guard let lo = values.min(), let hi = values.max(), hi > lo else {
+            return 1.0
+        }
+        return max((hi - lo) * 0.18, 0.8)
+    }
+
     private func load() async {
+#if DEBUG
         // QA hook: force the unreachable state for screenshots (same pattern
         // as -showTrends / -forceConnectionProblem). Runs before the fetch so
         // the retry state renders immediately with no spinner flash.
@@ -95,6 +147,7 @@ struct TrendsView: View {
             onHistoryUnavailable?()
             return
         }
+#endif
         isLoading = true
         loadFailed = false
         defer { isLoading = false }
@@ -112,7 +165,13 @@ struct TrendsView: View {
             // pointer probe already done above.
             loadFailed = firstSnapshot == nil
         }
+        // Always redraw the lines on a selection change. `.task(id:)` fires on
+        // the initial appear and on every fuel/range switch (there's no
+        // periodic refetch in this sheet), so a staggered per-series draw-in
+        // replays exactly when the user picks 7/30/90 (or switches fuel) while
+        // a width-stable morph keeps the x-axis/y-range from jumping abruptly.
         series = fetched
+        revealSeries(fetched)
         // A failure with no data IS a connection problem — raise the global
         // banner so the user isn't stuck with a silent retry state. Success
         // clears it (only if the banner is the connection banner).
@@ -123,6 +182,32 @@ struct TrendsView: View {
         }
     }
 
+    /// Replays the staggered per-series draw-in for the given histories:
+    /// resets the waterline, then cascades each station's line left→right,
+    /// 0.18s apart, on every range/fuel selection. Reduce Motion jump-cuts
+    /// straight to the full state.
+    private func revealSeries(_ histories: [StationHistory]) {
+        let hasPoints = histories.contains { !$0.points.isEmpty }
+        guard hasPoints else { return }
+        if reduceMotion {
+            revealed = histories.reduce(into: [:]) { $0[$1.stationID] = $1.points.count }
+            return
+        }
+        revealed = [:]
+        let cascadeNS = UInt64(0.18 * 1_000_000_000)
+        for (i, h) in histories.enumerated() {
+            let sid = h.stationID
+            let total = h.points.count
+            Task {
+                try? await Task.sleep(nanoseconds: UInt64(i) * cascadeNS)
+                guard !Task.isCancelled else { return }
+                withAnimation(.easeOut(duration: 0.5)) {
+                    revealed[sid] = total
+                }
+            }
+        }
+    }
+
     private func yLabel(_ pence: Double) -> String {
         switch mode {
         case .price:
@@ -132,6 +217,38 @@ struct TrendsView: View {
         }
     }
 
+    // MARK: - RevenueCat-style headline metric
+
+    /// Overall average across displayed series (mean of per-station means) —
+    /// the big figure in the card header, Price and vs-cheapest mode both.
+    private var headlineAverage: Double? {
+        let avgs = displaySeries.compactMap { FuelHistoryStore.averagePence($0.points) }
+        guard !avgs.isEmpty else { return nil }
+        return avgs.reduce(0, +) / Double(avgs.count)
+    }
+
+    /// Change over the window: mean of each series' (last − first) point.
+    /// Positive = prices/gaps rose; negative = fell. Hidden while loading or
+    /// when any displayed series lacks two points.
+    private var headlineDelta: Double? {
+        let deltas = displaySeries.compactMap { history -> Double? in
+            guard let first = history.points.first?.pence,
+                  let last = history.points.last?.pence else { return nil }
+            return last - first
+        }
+        guard deltas.count == displaySeries.count else { return nil }
+        return deltas.reduce(0, +) / Double(deltas.count)
+    }
+
+    /// Good = prices fell (saving money) or the gap to cheapest narrowed.
+    private var deltaIsGood: Bool {
+        (headlineDelta ?? 0) <= 0
+    }
+
+    private var periodLabel: String {
+        "Last \(rangeDays) days"
+    }
+
     var body: some View {
         NavigationStack {
             VStack(spacing: 14) {
@@ -195,11 +312,7 @@ struct TrendsView: View {
             } else if !hasEnoughData {
                 emptyState // single point — nothing to draw yet
             } else {
-                VStack(spacing: 12) {
+                revenueCatCard
-                    chart
-                    legend
-                    legendFooter
-                }
             }
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
@@ -228,21 +341,106 @@ struct TrendsView: View {
         .padding(.vertical, 24)
     }
 
+    /// RevenueCat-style card: rounded surface with a headline metric (period
+    /// average + change), the multi-series area chart, then the key. Mirrors
+    /// the mockup approved after the dashboard reference screenshot.
+    private var revenueCatCard: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            metricHeader
+            metricFooter
+            chart
+            legend
+            legendFooter
+        }
+        .padding(16)
+        .background(
+            RoundedRectangle(cornerRadius: 16, style: .continuous)
+                .fill(Color(.secondarySystemGroupedBackground))
+        )
+    }
+
+    /// Headline row: big average figure, signed change, right-aligned period.
+    /// Colours stay on the app palette — green when the move is good
+    /// (prices fell / gap narrowed), the accent tint when it rose.
+    @ViewBuilder
+    private var metricHeader: some View {
+        HStack(alignment: .firstTextBaseline, spacing: 8) {
+            if let headAvg = headlineAverage {
+                Text(yLabel(headAvg))
+                    .font(.system(size: 30, weight: .bold, design: .default))
+                    .monospacedDigit()
+                    .foregroundStyle(.primary)
+                    // Roll the digits to the new figure on range/mode change
+                    // (fires inside the animated transaction above).
+                    .contentTransition(.numericText(value: headAvg))
+                if let delta = headlineDelta, delta != 0 {
+                    Label(
+                        "\(deltaIsGood ? "−" : "+")\(abs(delta), specifier: "%.1f")p",
+                        systemImage: deltaIsGood ? "arrow.down.right" : "arrow.up.right"
+                    )
+                    .font(.system(size: 13, weight: .semibold))
+                    .labelStyle(.titleAndIcon)
+                    .foregroundStyle(deltaIsGood ? Color(red: 48/255.0, green: 209/255.0, blue: 88/255.0) : Color.accentColor)
+                }
+            }
+            Spacer()
+            Text(periodLabel)
+                .font(.footnote)
+                .foregroundStyle(.secondary)
+        }
+    }
+
+    /// One-line descriptor under the headline so the big figure (period
+    /// average across favourites) and the arrowed delta (change over the
+    /// window) are self-explanatory.
+    private var metricFooter: some View {
+        Text(chartFooterText)
+            .font(.caption2)
+            .foregroundStyle(.secondary)
+    }
+
+    private var chartFooterText: String {
+        switch mode {
+        case .price:
+            return "Average across favourites · change since the first day"
+        case .vsCheapest:
+            return "Average gap above the day's cheapest · change since the first day"
+        }
+    }
+
     private var chart: some View {
         // NOTE: each LineMark MUST carry an explicit `series:` — without it
         // Swift Charts merges every station's points into ONE polyline
         // (points connect across stations, so only the first station's line
         // is recognisable). The outer ForEach keeps one chart with N series;
         // per-mark foregroundStyle then colours each series from the palette.
+        // The AreaMark under each LineMark adds the gradient fill.
+        //
+        // stacking: .unstacked is essential — the standard stacking mode
+        // piles each series' area ON TOP of the previous series' area, so
+        // with 2+ favourites the fills land in the wrong place (seen on
+        // device 2026-08-17: fills shifted/overlapping vs the lines).
+        // .unstacked draws each area from its own line down to the axis,
+        // the RevenueCat look.
+        // Two passes: ALL AreaMarks first, then ALL LineMarks. Same-series
+        // marks composite in insertion order — if fills and lines interleave,
+        // a later series' fill paints OVER an earlier series' line (the
+        // bottom favourite's line vanished under the next fill; seen on
+        // device 2026-08-17). Drawing every fill before every line keeps all
+        // lines on top of all fills, RevenueCat style. (Mark builders are
+        // extracted into small helpers — the inline expression grew past the
+        // type-checker's budget.)
         Chart {
             ForEach(displaySeries) { history in
-                ForEach(history.points) { point in
+                ForEach(history.points.prefix(revealed[history.stationID] ?? 0)) { point in
-                    LineMark(
+                    areaMark(point, series: history.name,
-                        x: .value("Date", point.date),
+                             color: seriesColor(index(of: history.stationID)))
-                        y: .value("Price", point.pence),
+                }
-                        series: .value("Station", history.name)
+            }
-                    )
+            ForEach(displaySeries) { history in
-                    .foregroundStyle(seriesColor(index(of: history.stationID)))
+                ForEach(history.points.prefix(revealed[history.stationID] ?? 0)) { point in
+                    lineMark(point, series: history.name,
+                             color: seriesColor(index(of: history.stationID)))
                 }
             }
         }
@@ -251,31 +449,86 @@ struct TrendsView: View {
                 AxisGridLine()
                 AxisTick()
                 AxisValueLabel(format: .dateTime.month().day())
+                    .font(.caption2)
+                    .foregroundStyle(.secondary)
             }
         }
+        .chartYScale(domain: yDomain)
         .chartYAxis {
             AxisMarks { value in
                 AxisGridLine()
                 AxisValueLabel {
                     if let pence = value.as(Double.self) {
                         Text(yLabel(pence))
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
                     }
                 }
             }
         }
-        .frame(height: 260)
+        .frame(height: 190)
+        // Price ↔ vs-cheapest is a pure view toggle (no network): animate the
+        // lines + axis gliding to the rebased series.
+        .animation(.easeInOut(duration: 0.35), value: mode)
+    }
+
+    /// One gradient-filled area band under a single point of a series.
+    /// yStart/yEnd bound the fill to `fillBand` pence under the line
+    /// instead of to the axis: full-height fills overlap and bury lower
+    /// lines when several favourites overlap (observed on device
+    /// 2026-08-17).
+    private func areaMark(_ point: PricePoint, series: String,
+                          color: Color) -> some ChartContent {
+        AreaMark(
+            x: .value("Date", point.date),
+            yStart: .value("Price start", point.pence),
+            yEnd: .value("Price end", point.pence - fillBand),
+            series: .value("Station", series)
+        )
+        .foregroundStyle(
+            LinearGradient(
+                colors: [color.opacity(0.30), color.opacity(0.02)],
+                startPoint: .top,
+                endPoint: .bottom
+            )
+        )
+        .interpolationMethod(.monotone)
+    }
+
+    /// One line segment point for a series, drawn above every fill.
+    private func lineMark(_ point: PricePoint, series: String,
+                          color: Color) -> some ChartContent {
+        LineMark(
+            x: .value("Date", point.date),
+            y: .value("Price", point.pence),
+            series: .value("Station", series)
+        )
+        .foregroundStyle(color)
+        .lineStyle(StrokeStyle(lineWidth: 2.5, lineCap: .round, lineJoin: .round))
+        .interpolationMethod(.monotone)
     }
 
     private func index(of stationID: String) -> Int {
         orderedStations.firstIndex(where: { $0.id == stationID }) ?? 0
     }
 
+    /// Key rows in the same vertical order as the chart: most expensive at the
+    /// top working down to cheapest at the bottom (the chart's y-axis puts
+    /// the cheapest line lowest). Sorts by average price — the bracketed
+    /// figure — descending, so the first key row matches the top line.
+    private var legendSeries: [StationHistory] {
+        displaySeries.sorted {
+            (FuelHistoryStore.averagePence($0.points) ?? 0)
+                > (FuelHistoryStore.averagePence($1.points) ?? 0)
+        }
+    }
+
     private var legend: some View {
         VStack(alignment: .leading, spacing: 4) {
-            ForEach(Array(displaySeries.enumerated()), id: \.element.stationID) { index, history in
+            ForEach(legendSeries, id: \.stationID) { history in
                 HStack(spacing: 8) {
                     Circle()
-                        .fill(seriesColor(index))
+                        .fill(seriesColor(index(of: history.stationID)))
                         .frame(width: 8, height: 8)
                     Text(history.name)
                         .font(.caption)

FuelBoard/WatchSyncManager.swift

@@ -0,0 +1,118 @@
+import Foundation
+import WatchConnectivity
+
+extension Notification.Name {
+    static let fuelBoardWatchRefreshRequested = Notification.Name("FuelBoardWatchRefreshRequested")
+    static let fuelBoardShowStationDetail = Notification.Name("FuelBoardShowStationDetail")
+}
+
+@MainActor
+final class WatchSyncManager: NSObject, WCSessionDelegate {
+    static let shared = WatchSyncManager()
+
+    private var pendingSnapshotPush = false
+
+    private override init() {
+        super.init()
+    }
+
+    func activate() {
+        guard WCSession.isSupported() else { return }
+        pendingSnapshotPush = true
+        let session = WCSession.default
+        if session.delegate !== self {
+            session.delegate = self
+        }
+        session.activate()
+    }
+
+    func pushSnapshot() {
+        guard WCSession.isSupported() else { return }
+        let session = WCSession.default
+        guard session.activationState == .activated else {
+            pendingSnapshotPush = true
+            return
+        }
+        do {
+            try session.updateApplicationContext(snapshotContext())
+            pendingSnapshotPush = false
+        } catch {
+            print("WATCH-SYNC push failed: \(error.localizedDescription)")
+        }
+    }
+
+    private func snapshotContext() -> [String: Any] {
+        var context: [String: Any] = [:]
+
+        if let favourites = try? JSONEncoder().encode(FuelStore.loadFavourites()) {
+            context[FuelStore.favouritesKey] = favourites
+        }
+        // Do NOT send the full station dump to watchOS via WatchConnectivity.
+        // The UK dataset is megabytes large and exceeds application-context
+        // payload limits, which prevents any snapshot from arriving. The
+        // favourites payload already carries station snapshots + prices, so the
+        // watch can render favourites without the full list.
+
+        context[FuelStore.fuelKey] = FuelStore.loadSelectedFuel().rawValue
+        context[FuelStore.distanceUnitKey] = FuelStore.loadDistanceUnit().rawValue
+        context[FuelStore.priceDisplayStyleKey] = FuelStore.loadPriceDisplayStyle().rawValue
+
+        if let lastRefresh = FuelStore.loadLastRefresh() {
+            context[FuelStore.lastRefreshKey] = String(lastRefresh.timeIntervalSince1970)
+        }
+
+        if let handled = FuelStore.loadWatchRefreshHandled() {
+            context[FuelStore.watchRefreshHandledKey] = String(handled.timeIntervalSince1970)
+        }
+
+        if let location = FuelStore.loadLocationWithDate() {
+            context[FuelStore.locationKey] = "\(location.coordinate.lat),\(location.coordinate.lng),\(location.date.timeIntervalSince1970)"
+        }
+
+        return context
+    }
+
+    nonisolated func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: (any Error)?) {
+        if let error {
+            print("WATCH-SYNC activation failed: \(error.localizedDescription)")
+            return
+        }
+        Task { @MainActor in
+            if activationState == .activated, self.pendingSnapshotPush {
+                self.pushSnapshot()
+            }
+        }
+    }
+
+    nonisolated func sessionDidBecomeInactive(_ session: WCSession) {}
+
+    nonisolated func sessionDidDeactivate(_ session: WCSession) {
+        Task { @MainActor in
+            WCSession.default.activate()
+        }
+    }
+
+    nonisolated func session(_ session: WCSession, didReceiveUserInfo userInfo: [String : Any] = [:]) {
+        handleIncomingMessage(userInfo)
+    }
+
+    nonisolated func session(_ session: WCSession, didReceiveMessage message: [String : Any]) {
+        handleIncomingMessage(message)
+    }
+
+    private nonisolated func handleIncomingMessage(_ payload: [String: Any]) {
+        if payload["fuelboard.snapshotRequest"] as? String != nil {
+            Task { @MainActor in
+                self.pushSnapshot()
+            }
+        }
+
+        guard let raw = payload[FuelStore.watchRefreshRequestKey] as? String,
+              let timestamp = TimeInterval(raw) else { return }
+        let date = Date(timeIntervalSince1970: timestamp)
+        Task { @MainActor in
+            FuelStore.requestWatchRefresh(date)
+            NotificationCenter.default.post(name: .fuelBoardWatchRefreshRequested, object: nil)
+        }
+    }
+}

FuelBoard/en.lproj/Localizable.strings

@@ -56,6 +56,14 @@
 "Units" = "Units";
 "Price display" = "Price display";
 "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)." = "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).";
+"Tap station" = "Tap station";
+"Tap action" = "Tap action";
+"Tapping a station either opens directions straight away or shows its details first." = "Tapping a station either opens directions straight away or shows its details first.";
+"Open map" = "Open map";
+"More info" = "More info";
+"Name" = "Name";
+"Address" = "Address";
+"Distance" = "Distance";
 "Show introduction" = "Replay onboarding";
 "Replay the welcome screen, including the location and notification permission prompts." = "Replay the welcome screen, including the location and notification permission prompts.";
 "Test alert notification (real data)" = "Test alert notification (real data)";
@@ -139,6 +147,12 @@
 "You" = "You";
 "Done" = "Done";
 "Directions" = "Directions";
+"Report issue" = "Report issue";
+"Membership required" = "Membership required";
+"Report an error?" = "Report an error?";
+"Cancel" = "Cancel";
+"Report" = "Report";
+"Are you sure you want to report an error in fuel prices or forecourt details? This will open in your chosen browser." = "Are you sure you want to report an error in fuel prices or forecourt details? This will open in your chosen browser.";
 
 /* Station row */
 "best" = "best";

FuelBoardTests/Sources/FuelBoardShared/DataRefreshMode.swift

@@ -0,0 +1 @@
+../../../Shared/DataRefreshMode.swift

FuelBoardTests/Tests/FuelBoardSharedTests/FuelBoardTests.swift

@@ -233,11 +233,25 @@ final class BrandTests: XCTestCase {
         XCTAssertEqual(station(brand: "JET").brandImageName, "brand_jet")
         XCTAssertEqual(station(brand: "TEXACO").brandImageName, "brand_texaco")
         XCTAssertEqual(station(brand: "APPLEGREEN").brandImageName, "brand_applegreen")
+        XCTAssertEqual(station(brand: "VALERO").brandImageName, "brand_valero")
+        XCTAssertEqual(station(brand: "WELCOME BREAK").brandImageName, "brand_welcome_break")
+        XCTAssertEqual(station(brand: "THE CO-OPERATIVE").brandImageName, "brand_the_co_operative")
+        XCTAssertEqual(station(brand: "CO-OP").brandImageName, "brand_the_co_operative")
+        XCTAssertEqual(station(brand: "MURCO").brandImageName, "brand_murco")
+        XCTAssertEqual(station(brand: "GLEANER").brandImageName, "brand_gleaner")
+        XCTAssertEqual(station(brand: "HIGHLAND FUELS").brandImageName, "brand_highland_fuels")
+        XCTAssertEqual(station(brand: "CIRCLE K").brandImageName, "brand_circle_k")
+        XCTAssertEqual(station(brand: "MAXOL").brandImageName, "brand_maxol")
+        XCTAssertEqual(station(brand: "SPAR").brandImageName, "brand_spar")
+        XCTAssertEqual(station(brand: "ESSAR").brandImageName, "brand_essar")
+        XCTAssertEqual(station(brand: "EG ON THE MOVE").brandImageName, "brand_esso")
+        XCTAssertEqual(station(brand: "GO FORECOURT").brandImageName, "brand_gulf")
     }
 
-    func testUnknownBrand() {
+    func testUnknownBrandUsesGenericFuelPumpFallbackInUI() {
-        XCTAssertNil(station(brand: "WELCOME BREAK").brandImageName)
+        XCTAssertNil(station(brand: "TOTAL HARVEST ENERGY").brandImageName)
-        XCTAssertNil(station(brand: "VALERO").brandImageName)
+        XCTAssertNil(station(brand: "SOLO").brandImageName)
+        XCTAssertNil(station(brand: "PACE").brandImageName)
         XCTAssertNil(station(brand: "").brandImageName)
     }
 }
@@ -606,3 +620,82 @@ final class OfflineDataLabelTests: XCTestCase {
         XCTAssertNil(FuelStore.offlineDataLabel(from: "not-a-date"))
     }
 }
+
+// MARK: - Road distance cache
+
+final class RoadDistanceCacheTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+        // Keychain persists across invocations, so a cache left by an earlier
+        // test or run would pollute these. Overwrite with an empty, far-away
+        // cache (source at (0,0)) so every test starts from a clean slate.
+        FuelStore.saveRoadDistances(sourceLat: 0, sourceLng: 0, entries: [:])
+    }
+
+    private func station(_ id: String, _ lat: Double, _ lng: Double) -> FuelStation {
+        FuelStation(id: id, name: id, brand: "X", address: "", postcode: "",
+                    lat: lat, lng: lng, prices: [:], priceUpdated: nil)
+    }
+
+    func testDisplayDistanceFallsBackToStraightLineWhenNoCache() {
+        // London user, station ~ London -> no cache -> straight-line haversine.
+        let s = station("a", 51.5074, -0.1278)
+        let km = FuelStore.displayDistanceKM(station: s, userLat: 51.6, userLng: -0.1)
+        XCTAssertEqual(km, s.distanceKM(to: 51.6, lng2: -0.1), accuracy: 0.0001)
+    }
+
+    func testRoadDistanceUsedWhenCachedNear() {
+        let s = station("a", 51.5074, -0.1278)
+        // Cache a road distance of 3.2 km for this station from the user's fix.
+        FuelStore.saveRoadDistances(sourceLat: 51.6, sourceLng: -0.1,
+                                    entries: ["a": .init(meters: 3200, lat: 51.5074, lng: -0.1278)])
+        let km = FuelStore.displayDistanceKM(station: s, userLat: 51.6, userLng: -0.1)
+        XCTAssertEqual(km, 3.2, accuracy: 0.0001)
+    }
+
+    func testRoadDistanceNilWhenOriginFar() {
+        let s = station("a", 51.5074, -0.1278)
+        // Cache built in London, but the user is now ~200 km away -> stale.
+        FuelStore.saveRoadDistances(sourceLat: 51.5074, sourceLng: -0.1278,
+                                    entries: ["a": .init(meters: 3200, lat: 51.5074, lng: -0.1278)])
+        let meters = FuelStore.roadDistanceMeters(for: s, userLat: 53.4808, userLng: -2.2426)
+        XCTAssertNil(meters)
+        // And display falls back to straight-line.
+        let km = FuelStore.displayDistanceKM(station: s, userLat: 53.4808, userLng: -2.2426)
+        XCTAssertEqual(km, s.distanceKM(to: 53.4808, lng2: -2.2426), accuracy: 0.0001)
+    }
+
+    func testRoadDistanceUsedForOtherStationNotFound() {
+        FuelStore.saveRoadDistances(sourceLat: 51.6, sourceLng: -0.1,
+                                    entries: ["a": .init(meters: 3200, lat: 51.5074, lng: -0.1278)])
+        // A station that isn't in the cache falls back to straight-line.
+        let s = station("z", 51.51, -0.13)
+        let km = FuelStore.displayDistanceKM(station: s, userLat: 51.6, userLng: -0.1)
+        XCTAssertEqual(km, s.distanceKM(to: 51.6, lng2: -0.1), accuracy: 0.0001)
+    }
+
+    func testRoadDistanceNotServedWhenStationPinDiffers() {
+        // Route a road distance to station "a" at pin P1.
+        FuelStore.saveRoadDistances(sourceLat: 51.6, sourceLng: -0.1,
+                                    entries: ["a": .init(meters: 3200, lat: 51.5074, lng: -0.1278)])
+        // The SAME station id appears with a moved pin (corrected coordinate /
+        // different embedded vs live source): the cached route to P1 must NOT
+        // be served — it belongs to a different location.
+        let moved = station("a", 51.5400, -0.1600)
+        let km = FuelStore.displayDistanceKM(station: moved, userLat: 51.6, userLng: -0.1)
+        XCTAssertEqual(km, moved.distanceKM(to: 51.6, lng2: -0.1), accuracy: 0.0001,
+                       "road value routed to the old pin leaked onto a different coordinate")
+    }
+}
+
+// MARK: - Install identity
+
+final class InstallIdentityTests: XCTestCase {
+    func testFreshInstallIsStableAfterFirstCall() {
+        // The first call seeds the common install id (local == keychain), so
+        // any subsequent call in the same process must report NOT-fresh. This
+        // holds regardless of persisted keychain/defaults state from prior runs.
+        _ = FuelStore.isFreshInstall()
+        XCTAssertFalse(FuelStore.isFreshInstall())
+    }
+}

FuelBoardWatch Watch App/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

FuelBoardWatch Watch App/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,156 @@
+{
+  "images": [
+    {
+      "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"
+    },
+    {
+      "filename": "Watch-LongLook-88.png",
+      "idiom": "watch",
+      "role": "longLook",
+      "scale": "2x",
+      "size": "44x44",
+      "subtype": "42mm"
+    },
+    {
+      "filename": "Watch-LongLook-100.png",
+      "idiom": "watch",
+      "role": "longLook",
+      "scale": "2x",
+      "size": "50x50",
+      "subtype": "44mm"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}