From e960ef85c6a3f1694820abf5054f72f1bd4a8ee8 Mon Sep 17 00:00:00 2001
From: FuelBoard Contributor <fuelboard@apt.local>
Date: Fri, 16 Oct 2026 09:48:01 +0100
Subject: [PATCH] Make station price age informational only

The relay's price_updated is the maximum price_last_updated across the grades it maps, so it cannot vouch for the selected grade: stop using it to score, gate or warn about Best Value.

- FuelPriceFreshness is now station-level and display-only: one age per station, fresh/outdated/unknown/invalid, "May be outdated" past 30 days, with future-tolerance and non-finite guards.
- Best Value restores the closest-station-selling-the-selected-fuel baseline and its savings ranking; eligibility gating, eligible-first sorting and the unavailable banner are gone.
- Price age appears in the More info sheet only - no listing-row warnings, no extra banners.
- Copy reverted from "closest eligible station" to "closest station"; stale price-confidence strings removed, "May be outdated" added.
- Dormant per-grade timestamp plumbing removed, and regression tests added for every fuel type, missing/invalid/future stamps and the bundled offline dump.
---
 FuelBoard/ContentView.swift                   |  42 +--
 FuelBoard/FavouritesView.swift                |  14 +-
 FuelBoard/FuelSavingsViews.swift              |  25 +-
 FuelBoard/HowBestValueSheet.swift             |   4 +-
 FuelBoard/StationDetailView.swift             |  11 +-
 FuelBoard/StationPriceAgeView.swift           |  31 ++
 FuelBoard/StationsView.swift                  |  11 -
 FuelBoard/en.lproj/Localizable.strings        |  19 +-
 .../FuelPriceFreshnessTests.swift             | 310 +++++++-----------
 .../FuelSavingsCalculationAuditTests.swift    |   2 +-
 .../FuelSavingsEstimateTests.swift            | 193 ++---------
 .../FuelSavingsTests.swift                    |  16 +-
 .../StationPriceAgePolicyTests.swift          | 219 +++++++++++++
 FuelBoardWidgets/FuelPriceWidget.swift        |  16 +-
 Shared/FuelPriceFreshness.swift               | 183 +++--------
 Shared/FuelPriceProvider.swift                |  29 +-
 Shared/FuelPriceWidgetViews.swift             |  22 +-
 Shared/FuelSavings.swift                      |  88 ++---
 Shared/FuelStore.swift                        |  27 +-
 19 files changed, 530 insertions(+), 732 deletions(-)
 create mode 100644 FuelBoard/StationPriceAgeView.swift
 create mode 100644 FuelBoardTests/Tests/FuelBoardSharedTests/StationPriceAgePolicyTests.swift

diff --git a/FuelBoard/ContentView.swift b/FuelBoard/ContentView.swift
index 413e863..027701d 100644
--- a/FuelBoard/ContentView.swift
+++ b/FuelBoard/ContentView.swift
@@ -401,9 +401,9 @@ struct ContentView: View {
     /// (computing a journey for each) and `savingsLookup` immediately scanned them
     /// all AGAIN to fill the per-station map. Both now share one result.
     ///
-    /// The baseline is chosen with the same journey and selected-fuel freshness
-    /// guards as `FuelSavingsEstimator.bestValueBaselineStation` when configured;
-    /// with the feature off, the ordinary Closest station still names that row.
+    /// The baseline is chosen with the same journey guards as
+    /// `FuelSavingsEstimator.baselineStation` when configured; with the feature
+    /// off, the ordinary Closest station still names that row.
     private func savingsScaffold() -> (baseline: FuelStation?, journeys: [String: FuelSavingsJourney]) {
         guard let location else { return (nil, [:]) }
         guard fuelSavingsSettings.isConfigured else {
@@ -418,7 +418,7 @@ struct ContentView: View {
                 journeys[station.id] = journey
             }
         }
-        let baseline = FuelSavingsEstimator.bestValueBaselineStation(stations, fuel: selectedFuel) {
+        let baseline = FuelSavingsEstimator.baselineStation(stations, fuel: selectedFuel) {
             journeys[$0.id]
         }
         return (baseline, journeys)
@@ -454,15 +454,15 @@ struct ContentView: View {
         }
     }
 
-    /// The Closest station with an eligible selected-fuel price — the Best Value
-    /// comparison baseline. Ordinary Closest sorting still includes stale stations.
-    /// It uses the same journey values as the savings calculation, so a cached
-    /// road route can change the baseline and keep the "extra return travel"
-    /// labels synchronized with the cost calculation. Without a cached route,
-    /// the journey falls back to straight-line and the result is an estimate.
+    /// The nearest station that sells the selected fuel — the Best Value
+    /// comparison baseline. It is chosen with the SAME journey values used by
+    /// the savings calculation, so a cached road route can change the baseline
+    /// and keep the "extra return travel" labels synchronized with the
+    /// cost calculation. When no road route is cached, the journey falls back to
+    /// straight-line out-and-back, and the result is marked as an estimate.
     private var nearestSavingsBaseline: FuelStation? {
         guard let location else { return nil }
-        return FuelSavingsEstimator.bestValueBaselineStation(
+        return FuelSavingsEstimator.baselineStation(
             stations,
             fuel: selectedFuel,
             journeyMiles: { [self] station in savingsJourneyMiles(for: station, location: location) }
@@ -802,10 +802,6 @@ struct ContentView: View {
                         fuelSavings: savingsLookup(baseline: scaffold.baseline,
                                                    journeys: scaffold.journeys)(station),
                         fuelSavingsAmount: sessionFuelSavingsAmount,
-                        savingsPriceConfidence: FuelPriceFreshness.ComparisonConfidence.assess(
-                            station: station, fuel: selectedFuel, baseline: scaffold.baseline),
-                        savingsPriceWarning: FuelPriceFreshness.comparisonWarning(
-                            station: station, fuel: selectedFuel, baseline: scaffold.baseline),
                         savingsBaselineStationName: scaffold.baseline?.name,
                         journeyDiagnostics: journeyDiagnostics(for: station, baseline: scaffold.baseline),
                         isFavourite: favouriteIDs.contains(station.id),
@@ -1532,12 +1528,6 @@ struct ContentView: View {
             fuelSavingsAmount: $sessionFuelSavingsAmount,
             savingsForStation: savingsLookup(baseline: baselineStation, journeys: scaffold.journeys),
             journeyDiagnosticsForStation: { station in journeyDiagnostics(for: station, baseline: baselineStation) },
-            savingsPriceConfidenceForStation: { station in
-                FuelPriceFreshness.ComparisonConfidence.assess(station: station, fuel: selectedFuel, baseline: baselineStation)
-            },
-            savingsPriceWarningForStation: { station in
-                FuelPriceFreshness.comparisonWarning(station: station, fuel: selectedFuel, baseline: baselineStation)
-            },
             onToggleFavourite: toggleFavourite,
             onRefresh: { await refresh(force: true) }
         )
@@ -1559,12 +1549,6 @@ struct ContentView: View {
             fuelSavingsAmount: $sessionFuelSavingsAmount,
             savingsForStation: savingsLookup(baseline: baselineStation, journeys: scaffold.journeys),
             journeyDiagnosticsForStation: { station in journeyDiagnostics(for: station, baseline: baselineStation) },
-            savingsPriceConfidenceForStation: { station in
-                FuelPriceFreshness.ComparisonConfidence.assess(station: station, fuel: selectedFuel, baseline: baselineStation)
-            },
-            savingsPriceWarningForStation: { station in
-                FuelPriceFreshness.comparisonWarning(station: station, fuel: selectedFuel, baseline: baselineStation)
-            },
             onToggleFavourite: toggleFavourite,
             onReorder: reorderFavourites,
             onHistoryUnavailable: { if dataStatus == .live { dataStatus = .connectionProblem } },
@@ -1802,8 +1786,6 @@ struct StationRow: View {
     /// compact banner does not print it today, but a row that carried a hard
     /// zero would print "for £0" the moment it did — pass the real figure.
     var fuelSavingsAmount: FuelSavingsFillAmount = FuelSavingsSettings.defaultPreferredAmount
-    var savingsPriceConfidence: FuelPriceFreshness.ComparisonConfidence = .ineligible
-    var savingsPriceWarning: String? = nil
     var onToggleFavourite: () -> Void = {}
     var onShowDetails: (FuelStation) -> Void = { _ in }
 
@@ -1964,8 +1946,6 @@ struct StationRow: View {
                 FuelSavingsSummaryView(
                     availability: fuelSavings,
                     amount: fuelSavingsAmount,
-                    priceConfidence: savingsPriceConfidence,
-                    priceWarning: savingsPriceWarning,
                     compact: true,
                     distanceUnit: distanceUnit
                 )
diff --git a/FuelBoard/FavouritesView.swift b/FuelBoard/FavouritesView.swift
index 524b2a2..a9f79b0 100644
--- a/FuelBoard/FavouritesView.swift
+++ b/FuelBoard/FavouritesView.swift
@@ -21,12 +21,10 @@ struct FavouritesView: View {
     /// still never touches the Settings default.
     let fuelSavingsSettings: FuelSavingsSettings
     @Binding var fuelSavingsAmount: FuelSavingsFillAmount
-    /// Estimated saving for a favourite, against the closest eligible station by
+    /// Estimated saving for a favourite, against the closest station by
     /// journey distance — the same baseline and definition the Stations list uses.
     var savingsForStation: (FuelStation) -> FuelSavingsAvailability? = { _ in nil }
     var journeyDiagnosticsForStation: (FuelStation) -> FuelSavingsJourneyDiagnostics? = { _ in nil }
-    var savingsPriceConfidenceForStation: (FuelStation) -> FuelPriceFreshness.ComparisonConfidence
-    var savingsPriceWarningForStation: (FuelStation) -> String? = { _ in nil }
     var onToggleFavourite: (FuelStation, FuelType) -> Void = { _, _ in }
     /// Persists a reordered favourites array (after drag-and-drop).
     var onReorder: ([FavouriteEntry]) -> Void = { _ in }
@@ -86,8 +84,6 @@ struct FavouritesView: View {
          fuelSavingsAmount: Binding<FuelSavingsFillAmount>,
          savingsForStation: @escaping (FuelStation) -> FuelSavingsAvailability? = { _ in nil },
          journeyDiagnosticsForStation: @escaping (FuelStation) -> FuelSavingsJourneyDiagnostics? = { _ in nil },
-         savingsPriceConfidenceForStation: @escaping (FuelStation) -> FuelPriceFreshness.ComparisonConfidence = { _ in .ineligible },
-         savingsPriceWarningForStation: @escaping (FuelStation) -> String? = { _ in nil },
          onToggleFavourite: @escaping (FuelStation, FuelType) -> Void = { _, _ in },
          onReorder: @escaping ([FavouriteEntry]) -> Void = { _ in },
          onHistoryUnavailable: (() -> Void)? = nil,
@@ -102,8 +98,6 @@ struct FavouritesView: View {
         _fuelSavingsAmount = fuelSavingsAmount
         self.savingsForStation = savingsForStation
         self.journeyDiagnosticsForStation = journeyDiagnosticsForStation
-        self.savingsPriceConfidenceForStation = savingsPriceConfidenceForStation
-        self.savingsPriceWarningForStation = savingsPriceWarningForStation
         self.onToggleFavourite = onToggleFavourite
         self.onReorder = onReorder
         self.onHistoryUnavailable = onHistoryUnavailable
@@ -152,7 +146,7 @@ struct FavouritesView: View {
                         Section {
                             FuelSavingsAdjustmentView(amount: $fuelSavingsAmount)
                         } footer: {
-                            Text(String(localized: "Savings below are estimated against the closest eligible station by journey distance — the same baseline as the Stations list.", comment: "Favourites fuel-savings explanation"))
+                            Text(String(localized: "Savings below are estimated against the closest station by journey distance — the same baseline as the Stations list.", comment: "Favourites fuel-savings explanation"))
                         }
                     }
 
@@ -171,8 +165,6 @@ struct FavouritesView: View {
                                 tapAction: stationTapAction,
                                 fuelSavings: savingsForStation(station),
                                 fuelSavingsAmount: fuelSavingsAmount,
-                                savingsPriceConfidence: savingsPriceConfidenceForStation(station),
-                                savingsPriceWarning: savingsPriceWarningForStation(station),
                                 onToggleFavourite: { onToggleFavourite(station, activeFuel) },
                                 onShowDetails: { detailStation = $0 }
                             )
@@ -224,8 +216,6 @@ struct FavouritesView: View {
                     selectedFuel: activeFuel,
                     fuelSavings: savingsForStation(station),
                     fuelSavingsAmount: fuelSavingsAmount,
-                    savingsPriceConfidence: savingsPriceConfidenceForStation(station),
-                    savingsPriceWarning: savingsPriceWarningForStation(station),
                     journeyDiagnostics: journeyDiagnosticsForStation(station),
                     // Every station listed here IS a favourite for the tab's
                     // fuel, so the star starts filled; tapping it unstars.
diff --git a/FuelBoard/FuelSavingsViews.swift b/FuelBoard/FuelSavingsViews.swift
index f8f9fcc..ba25e5d 100644
--- a/FuelBoard/FuelSavingsViews.swift
+++ b/FuelBoard/FuelSavingsViews.swift
@@ -80,9 +80,6 @@ struct FuelSavingsAdjustmentView: View {
 struct FuelSavingsSummaryView: View {
     let availability: FuelSavingsAvailability?
     let amount: FuelSavingsFillAmount
-    /// Candidate/baseline price confidence for every Best Value result.
-    var priceConfidence: FuelPriceFreshness.ComparisonConfidence = .ineligible
-    var priceWarning: String? = nil
     var baselineStationName: String? = nil
     var compact: Bool = false
     /// Sizes the "extra return travel" caption in the user's own unit (the
@@ -120,12 +117,6 @@ struct FuelSavingsSummaryView: View {
                         .lineLimit(1)
                         .minimumScaleFactor(0.85)
                         .accessibilityLabel("Comparison: \(comparisonLabel(for: result))")
-                    if let warning = priceWarning ?? priceConfidence.warningText {
-                        Text(warning)
-                            .font(.caption2)
-                            .foregroundStyle(.orange)
-                            .accessibilityLabel(warning)
-                    }
                     if let extraTravel = FuelSavingsFormat.extraTravelLabel(
                         extraDistanceMiles: result.extraDistanceMiles,
                         unit: distanceUnit,
@@ -166,16 +157,10 @@ struct FuelSavingsSummaryView: View {
                     LabeledContent("Fuel you'll receive", value: String(format: "%.2f litres", result.fillLitres))
                         .monospacedDigit()
                     if amount.unit == .pounds {
-                        Text("You pay the selected budget here. The saving compares the same litres at your closest eligible station; litres differ between stations, and this is not a refund.")
+                        Text("You pay the selected budget here. The saving compares the same litres at your closest station; litres differ between stations, and this is not a refund.")
                             .font(.caption2)
                             .foregroundStyle(.secondary)
                     }
-                    if let warning = priceWarning ?? priceConfidence.warningText {
-                        Text(warning)
-                            .font(.caption2)
-                            .foregroundStyle(.orange)
-                            .accessibilityLabel(warning)
-                    }
                     if let extraTravel = FuelSavingsFormat.extraTravelLabel(
                         extraDistanceMiles: result.extraDistanceMiles,
                         unit: distanceUnit,
@@ -187,11 +172,11 @@ struct FuelSavingsSummaryView: View {
                             .accessibilityLabel(spokenExtraTravel(for: result, fallback: extraTravel))
                     }
                     if result.status == .baseline {
-                        Text("Your closest eligible station by journey distance is the baseline — every other saving is measured against it.")
+                        Text("Your closest station by journey distance is the baseline — every other saving is measured against it.")
                             .font(.caption)
                             .foregroundStyle(.secondary)
                     } else {
-                        Text(baselineStationName.map { "Compared with \($0)." } ?? "Compared with your closest eligible station.")
+                        Text(baselineStationName.map { "Compared with \($0)." } ?? "Compared with your closest station.")
                             .font(.caption)
                             .foregroundStyle(.secondary)
                         LabeledContent(
@@ -266,8 +251,8 @@ struct FuelSavingsSummaryView: View {
     }
 
     /// VoiceOver form of the verdict. `spokenHeadline()` spells "Approx." out for
-    /// and leaves the plain words ("Break even", "Closest eligible
-    /// station") alone — one source, so visible and spoken copy cannot drift.
+    /// and leaves the plain words ("Break even", "Closest station") alone —
+    /// one source, so visible and spoken copy cannot drift.
     private func accessibilityHeadline(for result: FuelSavingsResult) -> String {
         result.spokenHeadline()
     }
diff --git a/FuelBoard/HowBestValueSheet.swift b/FuelBoard/HowBestValueSheet.swift
index 948bab3..4766a6b 100644
--- a/FuelBoard/HowBestValueSheet.swift
+++ b/FuelBoard/HowBestValueSheet.swift
@@ -14,9 +14,9 @@ struct HowBestValueSheet: View {
             List {
                 Section {
                     VStack(alignment: .leading, spacing: 10) {
-                        Text("Best Value compares each station with the closest eligible station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey.")
+                        Text("Best Value compares each station with the closest station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey.")
                         Text("Your fill-up amount and MPG are used to show whether you could save overall.")
-                        Text("With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest eligible station, then deduct extra journey fuel. You do not receive cash back.")
+                        Text("With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest station, then deduct extra journey fuel. You do not receive cash back.")
                         Text("With Litres, every station is compared for the fixed quantity you selected.")
                         Text("Results are marked “Approx.” until road distances are available.")
                             .foregroundStyle(.secondary)
diff --git a/FuelBoard/StationDetailView.swift b/FuelBoard/StationDetailView.swift
index 0a5fa2b..901f4b6 100644
--- a/FuelBoard/StationDetailView.swift
+++ b/FuelBoard/StationDetailView.swift
@@ -21,8 +21,6 @@ struct StationDetailView: View {
     var selectedFuel: FuelType = FuelStore.loadSelectedFuel()
     var fuelSavings: FuelSavingsAvailability? = nil
     var fuelSavingsAmount: FuelSavingsFillAmount = FuelSavingsSettings.defaultPreferredAmount
-    var savingsPriceConfidence: FuelPriceFreshness.ComparisonConfidence = .ineligible
-    var savingsPriceWarning: String? = nil
     var savingsBaselineStationName: String? = nil
     var journeyDiagnostics: FuelSavingsJourneyDiagnostics? = nil
     /// Whether this station is starred for the fuel currently being viewed, and
@@ -62,11 +60,11 @@ struct StationDetailView: View {
     }
 
     private var priceFreshness: FuelPriceFreshness.Assessment {
-        FuelPriceFreshness.assessment(for: station, fuel: selectedFuel)
+        FuelPriceFreshness.assessment(for: station)
     }
 
     /// The selected grade's current price, when present. Kept separate from
-    /// the freshness label so a stale price remains visible rather than being
+    /// the price-age row so an old price remains visible rather than being
     /// silently hidden.
     private var selectedFuelPriceText: String {
         guard let price = station.prices[selectedFuel] else { return "—" }
@@ -215,8 +213,7 @@ struct StationDetailView: View {
                     }
                     LabeledContent("\(selectedFuel.displayName) price", value: selectedFuelPriceText)
                         .monospacedDigit()
-                    LabeledContent("Price updated", value: priceFreshness.updateAgeLabel)
-                        .monospacedDigit()
+                    StationPriceAgeView(assessment: priceFreshness)
                     ForEach(StationNotice.notices(for: station)) { notice in
                         Label(notice.title, systemImage: notice.symbolName)
                             .font(.subheadline.weight(.semibold))
@@ -257,8 +254,6 @@ struct StationDetailView: View {
                         FuelSavingsSummaryView(
                             availability: fuelSavings,
                             amount: fuelSavingsAmount,
-                            priceConfidence: savingsPriceConfidence,
-                            priceWarning: savingsPriceWarning,
                             baselineStationName: savingsBaselineStationName,
                             distanceUnit: distanceUnit,
                             showInfoAction: { showBestValueInfo = true }
diff --git a/FuelBoard/StationPriceAgeView.swift b/FuelBoard/StationPriceAgeView.swift
new file mode 100644
index 0000000..af28646
--- /dev/null
+++ b/FuelBoard/StationPriceAgeView.swift
@@ -0,0 +1,31 @@
+import SwiftUI
+
+/// The More info sheet's price-age row.
+///
+/// Station-level by design: the relay publishes a single `price_updated` per
+/// station (the newest grade it maps), so the copy says "Price updated" and
+/// never claims the selected grade itself was updated.
+///
+/// Past `FuelPriceFreshness.outdatedAge` a discreet note flags the information
+/// as possibly out of date. It is informational only — it gates nothing, and
+/// the station's own price row above it is unaffected.
+///
+/// Its own view rather than inlined into `StationDetailView`: that body sits at
+/// the compiler's type-checking limit, so one extra statement there fails the
+/// build. One statement here, one there.
+struct StationPriceAgeView: View {
+    let assessment: FuelPriceFreshness.Assessment
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 2) {
+            LabeledContent("Price updated", value: assessment.updateAgeLabel)
+                .monospacedDigit()
+            if let notice = assessment.outdatedNotice {
+                Text(notice)
+                    .font(.caption2)
+                    .foregroundStyle(.secondary)
+                    .accessibilityLabel(notice)
+            }
+        }
+    }
+}
diff --git a/FuelBoard/StationsView.swift b/FuelBoard/StationsView.swift
index 6991eb9..4db56e5 100644
--- a/FuelBoard/StationsView.swift
+++ b/FuelBoard/StationsView.swift
@@ -20,8 +20,6 @@ struct StationsView: View {
     @Binding var fuelSavingsAmount: FuelSavingsFillAmount
     var savingsForStation: (FuelStation) -> FuelSavingsAvailability? = { _ in nil }
     var journeyDiagnosticsForStation: (FuelStation) -> FuelSavingsJourneyDiagnostics? = { _ in nil }
-    var savingsPriceConfidenceForStation: (FuelStation) -> FuelPriceFreshness.ComparisonConfidence
-    var savingsPriceWarningForStation: (FuelStation) -> String?
     var onToggleFavourite: (FuelStation, FuelType) -> Void = { _, _ in }
     var onRefresh: () async -> Void = {}
 
@@ -123,11 +121,6 @@ struct StationsView: View {
                     // for a switched-off feature.
                     if sortMode == .worthTheDrive && fuelSavingsSettings.isConfigured {
                         FuelSavingsAdjustmentView(amount: $fuelSavingsAmount)
-                        if !stations.isEmpty && stations.allSatisfy({ savingsPriceConfidenceForStation($0) == .ineligible }) {
-                            Text("Best Value unavailable: no eligible price comparison. Stations and prices remain visible below.")
-                                .font(.caption)
-                                .foregroundStyle(.orange)
-                        }
                     }
 
                     if isLoading && stations.isEmpty {
@@ -264,8 +257,6 @@ struct StationsView: View {
             selectedFuel: selectedFuel,
             fuelSavings: savingsForStation(station),
             fuelSavingsAmount: fuelSavingsAmount,
-            savingsPriceConfidence: savingsPriceConfidenceForStation(station),
-            savingsPriceWarning: savingsPriceWarningForStation(station),
             journeyDiagnostics: journeyDiagnosticsForStation(station),
             isFavourite: favouriteIDs.contains(station.id),
             onToggleFavourite: { onToggleFavourite(station, selectedFuel) }
@@ -369,8 +360,6 @@ struct StationsView: View {
             tapAction: stationTapAction,
             fuelSavings: savingsForStation(station),
             fuelSavingsAmount: fuelSavingsAmount,
-            savingsPriceConfidence: savingsPriceConfidenceForStation(station),
-            savingsPriceWarning: savingsPriceWarningForStation(station),
             onToggleFavourite: { onToggleFavourite(station, selectedFuel) },
             onShowDetails: { detailStation = $0 }
         )
diff --git a/FuelBoard/en.lproj/Localizable.strings b/FuelBoard/en.lproj/Localizable.strings
index a1a9341..4a65a3e 100644
--- a/FuelBoard/en.lproj/Localizable.strings
+++ b/FuelBoard/en.lproj/Localizable.strings
@@ -36,10 +36,10 @@
 "Remove from favourites" = "Remove from favourites";
 "Price differences are shown in pence per litre (p/litre). Colours match each station's rating on the list." = "Price differences are shown in pence per litre (p/litre). Colours match each station's rating on the list.";
 "How Best Value works" = "How Best Value works";
-"Best Value compares each station with the closest eligible station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey." = "Best Value compares each station with the closest eligible station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey.";
-"With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest eligible station, then deduct extra journey fuel. You do not receive cash back." = "With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest eligible station, then deduct extra journey fuel. You do not receive cash back.";
-"Your closest eligible station by journey distance is the baseline — every other saving is measured against it." = "Your closest eligible station by journey distance is the baseline — every other saving is measured against it.";
-"Savings below are estimated against the closest eligible station by journey distance — the same baseline as the Stations list." = "Savings below are estimated against the closest eligible station by journey distance — the same baseline as the Stations list.";
+"Best Value compares each station with the closest station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey." = "Best Value compares each station with the closest station by journey distance. It works out what you could save at the pump, then takes off the fuel used for the extra return journey.";
+"With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest station, then deduct extra journey fuel. You do not receive cash back." = "With a £ budget you spend that amount at each station; the litres differ by station. Savings compare those litres with the same quantity at your closest station, then deduct extra journey fuel. You do not receive cash back.";
+"Your closest station by journey distance is the baseline — every other saving is measured against it." = "Your closest station by journey distance is the baseline — every other saving is measured against it.";
+"Savings below are estimated against the closest station by journey distance — the same baseline as the Stations list." = "Savings below are estimated against the closest station by journey distance — the same baseline as the Stations list.";
 "Your fill-up amount and MPG are used to show whether you could save overall." = "Your fill-up amount and MPG are used to show whether you could save overall.";
 "Results are marked “Approx.” until road distances are available." = "Results are marked “Approx.” until road distances are available.";
 
@@ -220,17 +220,14 @@
 "Long-distance journeys. Maximum reach: a ping when a cheap station is coming up from far out. In town this essentially never fires." = "Long-distance journeys. Maximum reach: a ping when a cheap station is coming up from far out. In town this essentially never fires.";
 "%@ — %@" = "%@ — %@";
 
-/* Best Value calculation and price confidence */
+/* Best Value calculation and station price age */
 "£ compares the litres your budget buys at each station; Litres compares one fixed quantity." = "£ compares the litres your budget buys at each station; Litres compares one fixed quantity.";
-"You pay the selected budget here. The saving compares the same litres at your closest eligible station; litres differ between stations, and this is not a refund." = "You pay the selected budget here. The saving compares the same litres at your closest eligible station; litres differ between stations, and this is not a refund.";
-"Best Value unavailable · price confidence insufficient" = "Best Value unavailable · price confidence insufficient";
+"You pay the selected budget here. The saving compares the same litres at your closest station; litres differ between stations, and this is not a refund." = "You pay the selected budget here. The saving compares the same litres at your closest station; litres differ between stations, and this is not a refund.";
 "Best Value unavailable · location needed" = "Best Value unavailable · location needed";
-"price order · Best Value unavailable" = "price order · Best Value unavailable";
 "your order" = "your order";
 "Price updated" = "Price updated";
-"Price age unavailable or too old — not a Best Value recommendation." = "Price age unavailable or too old — not a Best Value recommendation.";
 "%@ ago" = "%@ ago";
 "Not provided" = "Not provided";
+"May be outdated" = "May be outdated";
 "Fuel you'll receive" = "Fuel you'll receive";
-"Best Value unavailable: no eligible price comparison. Stations and prices remain visible below." = "Best Value unavailable: no eligible price comparison. Stations and prices remain visible below.";
-"Compared with your closest eligible station." = "Compared with your closest eligible station.";
+"Compared with your closest station." = "Compared with your closest station.";
diff --git a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelPriceFreshnessTests.swift b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelPriceFreshnessTests.swift
index ba32419..4f29d49 100644
--- a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelPriceFreshnessTests.swift
+++ b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelPriceFreshnessTests.swift
@@ -3,28 +3,41 @@ import XCTest
 @testable import FuelBoardShared
 #endif
 
+/// Station-level price age — one timestamp per station, reported in More info
+/// and nowhere else.
+///
+/// The relay's `price_updated` is the newest `price_last_updated` across every
+/// grade a station maps, so it is not evidence about the selected grade. These
+/// tests pin what the app *reports*; `StationPriceAgePolicyTests` pins what the
+/// app does about it (nothing).
 final class FuelPriceFreshnessTests: XCTestCase {
-    private let now = Date(timeIntervalSince1970: 1_792_022_400)
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
 
-    private func station(
-        priceUpdated: TimeInterval? = nil,
-        priceUpdatedByFuel: [FuelType: TimeInterval]? = nil
-    ) -> FuelStation {
-        FuelStation(
-            id: "freshness-station",
-            name: "Freshness Station",
-            brand: "Test",
-            address: "1 High Street",
-            postcode: "BD1 1AA",
-            lat: 53.79,
-            lng: -1.75,
-            prices: [.diesel: 129.9, .e10: 169.9],
-            priceUpdated: priceUpdated,
-            priceUpdatedByFuel: priceUpdatedByFuel
-        )
+    private func at(_ offset: TimeInterval) -> TimeInterval {
+        now.addingTimeInterval(offset).timeIntervalSince1970
     }
 
-    func testPerGradeTimestampIsDecodedAndEligibleWhenFresh() throws {
+    private func station(priceUpdated: TimeInterval?) -> FuelStation {
+        FuelStation(id: "freshness-station", name: "Freshness Station", brand: "Test",
+                    address: "1 High Street", postcode: "BD1 1AA", lat: 53.79, lng: -1.75,
+                    prices: [.e10: 169.9], priceUpdated: priceUpdated)
+    }
+
+    // MARK: - One figure per station, whatever fuel is on screen
+
+    func testOneAgeIsReportedForEveryFuelAStationSells() {
+        let sold = FuelStation(id: "multi", name: "Multi", brand: "", address: "", postcode: "",
+                               lat: 53, lng: -1, prices: [.e5: 165.9, .e10: 169.9, .diesel: 129.9],
+                               priceUpdated: at(-28 * 60 * 60))
+
+        for fuel in FuelType.allCases {
+            XCTAssertEqual(FuelPriceFreshness.assessment(for: sold, now: now).updateAgeLabel,
+                           "28h ago",
+                           "\(fuel.rawValue): every grade reads the same station timestamp")
+        }
+    }
+
+    func testStationTimestampIsDecodedAndNoPerGradeTimestampIsInvented() throws {
         let json = """
         {
           "stations": [{
@@ -36,207 +49,122 @@ final class FuelPriceFreshnessTests: XCTestCase {
             "lat": 53.78,
             "lng": -1.75,
             "prices": {"E10": 169.9, "DIESEL": 129.9},
-            "price_updated": "2026-09-25T07:45:52Z",
+            "price_updated": "2026-10-14T07:45:52Z",
             "price_updated_by_grade": {
-              "E10": "2026-10-14T07:45:52Z",
-              "DIESEL": "2026-10-14T07:45:52Z"
+              "E10": "2026-01-01T00:00:00Z",
+              "DIESEL": "2026-01-01T00:00:00Z"
             }
           }]
         }
         """
-        let stations = try FuelPriceProvider.decodeStations(from: Data(json.utf8))
-        let decoded = try XCTUnwrap(stations.first)
+        let decoded = try XCTUnwrap(try FuelPriceProvider.decodeStations(from: Data(json.utf8)).first)
 
-        XCTAssertEqual(decoded.priceUpdatedByFuel?[.diesel],
-                       ISO8601DateFormatter.fuelBoardDate("2026-10-14T07:45:52Z")?.timeIntervalSince1970)
-        let assessment = FuelPriceFreshness.assessment(for: decoded, fuel: .diesel, now: now)
-        XCTAssertEqual(assessment.source, .gradeSpecific)
+        XCTAssertEqual(decoded.priceUpdated,
+                       ISO8601DateFormatter.fuelBoardDate("2026-10-14T07:45:52Z")?.timeIntervalSince1970,
+                       "the station-level field is what the app records")
+        // A per-grade map in the payload is ignored: the app has one age, and it
+        // is the station's.
+        let assessment = FuelPriceFreshness.assessment(for: decoded, now: now)
+        XCTAssertEqual(assessment.status, .outdated,
+                       "the station field is used, not the 2026-01-01 grade entries")
+    }
+
+    // MARK: - Reading the age
+
+    func testFreshAgeReadsInMinutesThenHours() {
+        XCTAssertEqual(FuelPriceFreshness.assessment(priceUpdated: at(-59 * 60), now: now).updateAgeLabel,
+                       "59m ago")
+        XCTAssertEqual(FuelPriceFreshness.assessment(priceUpdated: at(-60 * 60), now: now).updateAgeLabel,
+                       "1h ago")
+        XCTAssertEqual(FuelPriceFreshness.assessment(priceUpdated: at(-47 * 60 * 60), now: now).updateAgeLabel,
+                       "47h ago")
+        XCTAssertEqual(FuelPriceFreshness.assessment(priceUpdated: at(-48 * 60 * 60), now: now).updateAgeLabel,
+                       "2d ago")
+    }
+
+    func testFreshInformationIsNeverFlagged() {
+        let assessment = FuelPriceFreshness.assessment(for: station(priceUpdated: at(-28 * 60 * 60)), now: now)
         XCTAssertEqual(assessment.status, .fresh)
-        XCTAssertTrue(assessment.isEligibleForBestValue)
+        XCTAssertFalse(assessment.isOutdated)
+        XCTAssertNil(assessment.outdatedNotice)
+        XCTAssertEqual(assessment.age, 28 * 60 * 60)
     }
 
-    func testStationWideTimestampIsNotPresentedAsGradeSpecificOrEligible() {
-        let updated = now.addingTimeInterval(-FuelPriceFreshness.warningAge / 2).timeIntervalSince1970
-        let assessment = FuelPriceFreshness.assessment(
-            for: station(priceUpdated: updated), fuel: .diesel, now: now
-        )
+    // MARK: - The thirty-day display threshold
 
-        XCTAssertEqual(assessment.source, .stationWide)
+    func testInformationExactlyThirtyDaysOldIsNotYetFlagged() {
+        let assessment = FuelPriceFreshness.assessment(priceUpdated: at(-FuelPriceFreshness.outdatedAge), now: now)
         XCTAssertEqual(assessment.status, .fresh)
-        XCTAssertEqual(assessment.confidence, .provisional)
-        XCTAssertTrue(assessment.recommendationEligibility == .eligible)
-        XCTAssertTrue(assessment.isEligibleForBestValue)
-        XCTAssertTrue(assessment.warning)
-        XCTAssertTrue(assessment.displayLabel.contains("station-wide"))
+        XCTAssertNil(assessment.outdatedNotice)
     }
 
-    func testMoreInfoReportsOneStationPriceAge() {
-        let updated = now.addingTimeInterval(-28 * 60 * 60).timeIntervalSince1970
-        let assessment = FuelPriceFreshness.assessment(for: station(priceUpdated: updated), fuel: .e10, now: now)
-        XCTAssertEqual(assessment.updateAgeLabel, "28h ago")
-        XCTAssertEqual(assessment.source, .stationWide)
-        XCTAssertEqual(assessment.status, .fresh)
+    func testInformationJustPastThirtyDaysIsFlaggedButStillReportsItsAge() {
+        let assessment = FuelPriceFreshness.assessment(priceUpdated: at(-FuelPriceFreshness.outdatedAge - 1), now: now)
+        XCTAssertEqual(assessment.status, .outdated)
+        XCTAssertTrue(assessment.isOutdated)
+        XCTAssertEqual(assessment.outdatedNotice, "May be outdated")
+        XCTAssertEqual(assessment.updateAgeLabel, "30d ago")
     }
 
-    func testOlderFuelSpecificTimestampStillReportsItsOwnAgeOnce() {
-        let updated = now.addingTimeInterval(-10 * 86_400).timeIntervalSince1970
-        let priced = station(priceUpdatedByFuel: [.diesel: updated])
-        let assessment = FuelPriceFreshness.assessment(for: priced, fuel: .diesel, now: now)
-        XCTAssertEqual(assessment.updateAgeLabel, "10d ago")
-        XCTAssertEqual(assessment.source, .gradeSpecific)
+    func testLongOldInformationIsFlaggedWithItsDayCount() {
+        // The oldest figure the mirror carries for a real station is ~250 days.
+        let assessment = FuelPriceFreshness.assessment(priceUpdated: at(-250 * 86_400), now: now)
+        XCTAssertEqual(assessment.status, .outdated)
+        XCTAssertEqual(assessment.updateAgeLabel, "250d ago")
+        XCTAssertEqual(assessment.outdatedNotice, "May be outdated")
     }
 
-    func testMissingUpdateTimeReadsNotProvided() {
-        let assessment = FuelPriceFreshness.assessment(for: station(), fuel: .e10, now: now)
+    // MARK: - Missing, malformed, future and absurd timestamps
+
+    func testMissingTimestampReadsNotProvidedAndIsNeverFlagged() {
+        let assessment = FuelPriceFreshness.assessment(for: station(priceUpdated: nil), now: now)
+        XCTAssertEqual(assessment.status, .unknown)
+        XCTAssertNil(assessment.age)
         XCTAssertEqual(assessment.updateAgeLabel, "Not provided")
+        XCTAssertFalse(assessment.isOutdated)
+        XCTAssertNil(assessment.outdatedNotice)
     }
 
-    func testProvisionalSavingAddsNoSecondWarningLine() {
-        let recent = now.addingTimeInterval(-28 * 60 * 60).timeIntervalSince1970
-        let stationWide = station(priceUpdated: recent)
-        let gradeSpecific = station(priceUpdatedByFuel: [.e10: recent])
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(
-            station: gradeSpecific, fuel: .e10, baseline: stationWide, now: now), .provisional)
-        XCTAssertNil(FuelPriceFreshness.comparisonWarning(
-            station: stationWide, fuel: .e10, baseline: stationWide, now: now))
-        XCTAssertNil(FuelPriceFreshness.comparisonWarning(
-            station: gradeSpecific, fuel: .e10, baseline: stationWide, now: now))
+    func testUnparseableSourceTextIsDroppedRatherThanGuessed() throws {
+        XCTAssertNil(FuelPriceTimestamp.parse("not-a-date"))
+        XCTAssertNil(FuelPriceTimestamp.parse(""))
+        XCTAssertNil(FuelPriceTimestamp.parse("   "))
+
+        let json = """
+        {"stations": [{"id": "bad", "name": "Bad", "brand": "", "address": "", "postcode": "",
+          "lat": 53, "lng": -1, "prices": {"E10": 169.9}, "price_updated": "2026-99-99T99:99:99Z"}]}
+        """
+        let decoded = try XCTUnwrap(try FuelPriceProvider.decodeStations(from: Data(json.utf8)).first)
+        XCTAssertNil(decoded.priceUpdated)
+        XCTAssertEqual(FuelPriceFreshness.assessment(for: decoded, now: now).updateAgeLabel, "Not provided")
     }
 
-    func testIneligibleComparisonStillExplainsItself() {
-        let old = now.addingTimeInterval(-FuelPriceFreshness.staleAge - 1).timeIntervalSince1970
-        let stale = station(priceUpdatedByFuel: [.diesel: old])
-        XCTAssertEqual(FuelPriceFreshness.comparisonWarning(
-            station: stale, fuel: .diesel, baseline: stale, now: now),
-            "Price age unavailable or too old — not a Best Value recommendation.")
+    func testSmallClockSkewReadsAsJustNowNotAsAFutureDate() {
+        let assessment = FuelPriceFreshness.assessment(priceUpdated: at(60), now: now)
+        XCTAssertEqual(assessment.status, .fresh)
+        XCTAssertEqual(assessment.age, 0)
+        XCTAssertEqual(assessment.updateAgeLabel, "0m ago")
     }
 
-    func testStationWideTimestampAtWarningBoundaryChangesRecommendationEligibility() {
-        let updated = now.addingTimeInterval(-FuelPriceFreshness.warningAge).timeIntervalSince1970
-        let onBoundary = FuelPriceFreshness.assessment(for: station(priceUpdated: updated), fuel: .diesel, now: now)
-        XCTAssertEqual(onBoundary.status, .fresh)
-        XCTAssertTrue(onBoundary.isEligibleForBestValue)
-        let pastBoundary = FuelPriceFreshness.assessment(
-            for: station(priceUpdated: updated - 1), fuel: .diesel, now: now)
-        XCTAssertEqual(pastBoundary.status, .warning)
-        XCTAssertFalse(pastBoundary.isEligibleForBestValue)
+    func testTimestampBeyondTheSkewToleranceIsUnusableNotOptimistic() {
+        let assessment = FuelPriceFreshness.assessment(priceUpdated: at(86_400), now: now)
+        XCTAssertEqual(assessment.status, .invalid)
+        XCTAssertNil(assessment.age)
+        XCTAssertEqual(assessment.updateAgeLabel, "Not provided")
+        XCTAssertNil(assessment.outdatedNotice)
     }
 
-    func testStationWideTimestampOlderThanWarningThresholdCannotRecommendSuspiciousDiesel() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let shell = station(priceUpdated: now.addingTimeInterval(-20 * 86_400).timeIntervalSince1970)
-        let age = FuelPriceFreshness.assessment(for: shell, fuel: .diesel, now: now)
-        XCTAssertEqual(age.status, .warning)
-        XCTAssertFalse(age.isEligibleForBestValue)
-        XCTAssertEqual(shell.prices[.diesel], 129.9)
-    }
-
-    func testComparisonConfidenceRejectsMissingSelectedFuelPriceEvenWithFreshTimestamp() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let updated = now.addingTimeInterval(-86_400).timeIntervalSince1970
-        let dieselOnly = FuelStation(id: "diesel", name: "Diesel", brand: "", address: "", postcode: "",
-                                     lat: 53, lng: -1, prices: [.diesel: 129.9], priceUpdated: nil,
-                                     priceUpdatedByFuel: [.e10: updated])
-        let e10 = FuelStation(id: "petrol", name: "Petrol", brand: "", address: "", postcode: "",
-                               lat: 53, lng: -1, prices: [.e10: 169.9], priceUpdated: nil,
-                               priceUpdatedByFuel: [.e10: updated])
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: dieselOnly, fuel: .e10,
-                                                                 baseline: e10, now: now), .ineligible)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: e10, fuel: .e10,
-                                                                 baseline: dieselOnly, now: now), .ineligible)
-    }
-
-    func testComparisonConfidenceRequiresBothSelectedGradeTimestamps() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let recent = now.addingTimeInterval(-86_400).timeIntervalSince1970
-        let old = now.addingTimeInterval(-20 * 86_400).timeIntervalSince1970
-        let verified = station(priceUpdatedByFuel: [.diesel: recent])
-        let provisional = station(priceUpdated: recent)
-        let oldStationWide = station(priceUpdated: old)
-        let oldGrade = station(priceUpdatedByFuel: [.diesel: old])
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: verified, fuel: .diesel,
-                                                                 baseline: verified, now: now), .verified)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: verified, fuel: .diesel,
-                                                                 baseline: provisional, now: now), .provisional)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: oldGrade, fuel: .diesel,
-                                                                 baseline: verified, now: now), .provisional)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: verified, fuel: .diesel,
-                                                                 baseline: oldStationWide, now: now), .ineligible)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: provisional, fuel: .diesel,
-                                                                 baseline: verified, now: now), .provisional)
-        XCTAssertEqual(FuelPriceFreshness.comparisonConfidence(station: verified, fuel: .e10,
-                                                                 baseline: verified, now: now), .ineligible)
-    }
-
-    func testNonFiniteAndExtremeEpochsCannotBecomeTrusted() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        for value in [Double.nan, .infinity, -.infinity, Double.greatestFiniteMagnitude, -Double.greatestFiniteMagnitude] {
-            let assessment = FuelPriceFreshness.assessment(
-                priceUpdated: value, priceUpdatedByFuel: nil, fuel: .diesel, now: now)
-            XCTAssertFalse(assessment.isEligibleForBestValue)
-            XCTAssertTrue(assessment.warning)
+    func testNonFiniteAndAbsurdEpochsAreUnusableAndCannotTrap() {
+        let values: [TimeInterval] = [.nan, .infinity, -.infinity,
+                                      .greatestFiniteMagnitude, -.greatestFiniteMagnitude]
+        for value in values {
+            let assessment = FuelPriceFreshness.assessment(priceUpdated: value, now: now)
+            XCTAssertEqual(assessment.status, .invalid, "\(value)")
+            XCTAssertNil(assessment.age, "\(value)")
+            XCTAssertEqual(assessment.updateAgeLabel, "Not provided", "\(value)")
+            XCTAssertFalse(assessment.isOutdated, "\(value)")
         }
     }
-
-    func testMissingAndMalformedTimestampsAreUnknownAndIneligible() {
-        let missing = FuelPriceFreshness.assessment(for: station(), fuel: .diesel, now: now)
-        XCTAssertEqual(missing.status, .unknown)
-        XCTAssertEqual(missing.source, .unknown)
-        XCTAssertFalse(missing.isEligibleForBestValue)
-
-        let malformed = FuelPriceFreshness.assessment(
-            priceUpdated: "not-a-date", priceUpdatedByGrade: nil, fuel: .diesel, now: now
-        )
-        XCTAssertEqual(malformed.status, .invalid)
-        XCTAssertFalse(malformed.isEligibleForBestValue)
-    }
-
-    func testStaleDisplayLabelDoesNotCallIneligiblePriceProvisional() {
-        let stale = station(priceUpdatedByFuel: [
-            .diesel: now.addingTimeInterval(-FuelPriceFreshness.staleAge - 1).timeIntervalSince1970
-        ])
-        let assessment = FuelPriceFreshness.assessment(for: stale, fuel: .diesel, now: now)
-        XCTAssertFalse(assessment.isEligibleForBestValue)
-        XCTAssertFalse(assessment.displayLabel.contains("provisional"))
-        XCTAssertTrue(assessment.displayLabel.contains("outdated"))
-    }
-
-    func testStaleAndFutureGradeTimestampsAreRejected() {
-        let stale = station(priceUpdatedByFuel: [
-            .diesel: now.addingTimeInterval(-FuelPriceFreshness.staleAge - 1).timeIntervalSince1970
-        ])
-        let staleAssessment = FuelPriceFreshness.assessment(for: stale, fuel: .diesel, now: now)
-        XCTAssertEqual(staleAssessment.status, .stale)
-        XCTAssertFalse(staleAssessment.isEligibleForBestValue)
-        XCTAssertTrue(staleAssessment.warning)
-
-        let future = station(priceUpdatedByFuel: [
-            .diesel: now.addingTimeInterval(FuelPriceFreshness.futureTolerance + 1).timeIntervalSince1970
-        ])
-        let futureAssessment = FuelPriceFreshness.assessment(for: future, fuel: .diesel, now: now)
-        XCTAssertEqual(futureAssessment.status, .invalid)
-        XCTAssertFalse(futureAssessment.isEligibleForBestValue)
-    }
-
-    func testMalformedAndFutureSourceValuesDoNotCrashOrProduceNegativeAge() {
-        let malformed = FuelPriceFreshness.assessment(
-            priceUpdated: "2026-99-99T99:99:99Z",
-            priceUpdatedByGrade: ["DIESEL": "2026-99-99T99:99:99Z"],
-            fuel: .diesel,
-            now: now
-        )
-        XCTAssertNil(malformed.age)
-        XCTAssertFalse(malformed.isEligibleForBestValue)
-
-        let future = FuelPriceFreshness.assessment(
-            priceUpdated: now.addingTimeInterval(86_400).timeIntervalSince1970,
-            priceUpdatedByFuel: nil,
-            fuel: .diesel,
-            now: now
-        )
-        XCTAssertNil(future.age)
-        XCTAssertFalse(future.isEligibleForBestValue)
-    }
 }
 
 private extension ISO8601DateFormatter {
diff --git a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsCalculationAuditTests.swift b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsCalculationAuditTests.swift
index cdce9a8..c23babe 100644
--- a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsCalculationAuditTests.swift
+++ b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsCalculationAuditTests.swift
@@ -533,6 +533,6 @@ final class FuelSavingsCalculationAuditTests: XCTestCase {
         )?.result
         XCTAssertEqual(result?.status, .baseline)
         XCTAssertEqual(result?.netSavingGBP, 0)
-        XCTAssertEqual(result?.headline(), "Closest eligible station")
+        XCTAssertEqual(result?.headline(), "Closest station")
     }
 }
diff --git a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsEstimateTests.swift b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsEstimateTests.swift
index 9a51293..c380e8c 100644
--- a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsEstimateTests.swift
+++ b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsEstimateTests.swift
@@ -41,6 +41,8 @@ final class FuelSavingsEstimateTests: XCTestCase {
         FuelSavingsJourney(miles: miles, basis: .straightLine)
     }
 
+    /// Fuel types are never mixed: a station that does not sell the selected
+    /// fuel cannot be its baseline, and cannot be compared with it.
     func testDifferentFuelNeverUsesAnotherGradeAsItsBaseline() {
         let petrolOnly = FuelStation(id: "petrol", name: "Petrol", brand: "", address: "", postcode: "", lat: 53, lng: -1,
             prices: [.e10: 199.9], priceUpdated: nil)
@@ -55,6 +57,26 @@ final class FuelSavingsEstimateTests: XCTestCase {
         XCTAssertEqual(unavailable, .unavailable("No comparison station"))
     }
 
+    /// Ranking must still work when the list being ordered is filtered tighter
+    /// than the pool the baseline was chosen from.
+    func testBaselineOutsideFilteredPoolStillRanksByNetSaving() {
+        let baseline = station("nearest-outside-radius", price: 199.9)
+        let cheap = station("z-cheap", price: 129.9)
+        let expensive = station("a-expensive", price: 198.9)
+        let ranked = FuelSavingsEstimator.ranked(
+            [expensive, cheap], fuel: .e10, baseline: baseline,
+            settings: settings, amount: amount,
+            journeyMiles: { s in self.straightLine(s.id == baseline.id ? 0.8 : 4.0) }
+        )
+        XCTAssertEqual(ranked.map(\.id), ["z-cheap", "a-expensive"])
+        let expected = FuelSavingsEstimator.availability(
+            station: cheap, fuel: .e10, baseline: baseline,
+            settings: settings, amount: amount,
+            journey: straightLine(4.0), baselineJourney: straightLine(0.8)
+        )?.result
+        XCTAssertGreaterThan(expected?.netSavingGBP ?? -1, 0)
+    }
+
     func testCheaperStationThreePointFiveMilesAwayIsRankedFirstWithASaving() {
         // Nearest station: 1 mile away at 145.9p. The station the user can see
         // in the Cheapest tab: 3.5 miles away at 138.9p.
@@ -99,24 +121,6 @@ final class FuelSavingsEstimateTests: XCTestCase {
                        "unmeasured routes are reported as straight-line estimates")
     }
 
-    func testBaselineOutsideFilteredPoolStillRanksByNetSaving() {
-        let baseline = station("nearest-outside-radius", price: 199.9)
-        let cheap = station("z-cheap", price: 129.9)
-        let expensive = station("a-expensive", price: 198.9)
-        let ranked = FuelSavingsEstimator.ranked(
-            [expensive, cheap], fuel: .e10, baseline: baseline,
-            settings: settings, amount: amount,
-            journeyMiles: { s in self.straightLine(s.id == baseline.id ? 0.8 : 4.0) }
-        )
-        XCTAssertEqual(ranked.map(\.id), ["z-cheap", "a-expensive"])
-        let expected = FuelSavingsEstimator.availability(
-            station: cheap, fuel: .e10, baseline: baseline,
-            settings: settings, amount: amount,
-            journey: straightLine(4.0), baselineJourney: straightLine(0.8)
-        )?.result
-        XCTAssertGreaterThan(expected?.netSavingGBP ?? -1, 0)
-    }
-
     func testEveryPricedStationInThePoolIsEstimatedNotJustAShortlist() {
         // 40 stations, but only the first one has a measured road route — the
         // old implementation capped the whole ranking to 12 shortlisted
@@ -191,56 +195,6 @@ final class FuelSavingsEstimateTests: XCTestCase {
         XCTAssertEqual(result?.distanceBasis, .straightLine)
     }
 
-    func testBestValueBaselineSkipsClosestStalePriceButKeepsThatStationVisible() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        func priced(_ id: String, _ price: Double, _ daysOld: Double) -> FuelStation {
-            FuelStation(id: id, name: id, brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                        prices: [.e10: price], priceUpdated: now.addingTimeInterval(-daysOld * 86_400).timeIntervalSince1970)
-        }
-        let staleClosest = priced("stale-closest", 199.9, 27)
-        let eligibleClosest = priced("eligible-closest", 170.9, 1)
-        let eligibleFurther = priced("eligible-further", 150.9, 1)
-        let pool = [staleClosest, eligibleClosest, eligibleFurther]
-        let journeys: (FuelStation) -> FuelSavingsJourney? = { station in
-            self.straightLine(station.id == "stale-closest" ? 0.8 : station.id == "eligible-closest" ? 1.6 : 3.0)
-        }
-        let baseline = FuelSavingsEstimator.bestValueBaselineStation(pool, fuel: .e10,
-                                                                       journeyMiles: journeys, now: now)
-        XCTAssertEqual(baseline?.id, "eligible-closest")
-        XCTAssertEqual(FuelSavingsEstimator.baselineStation(pool, fuel: .e10, journeyMiles: journeys)?.id,
-                       "stale-closest", "non-Best-Value closest behaviour must stay unchanged")
-        let ranked = FuelSavingsEstimator.ranked(pool, fuel: .e10, baseline: baseline,
-            settings: briefSettings, amount: briefAmount, journeyMiles: journeys, now: now)
-        XCTAssertEqual(ranked.first?.id, "eligible-further")
-        XCTAssertTrue(ranked.contains(where: { $0.id == "stale-closest" }))
-        XCTAssertFalse(FuelSavingsEstimator.recommendationEligible(station: staleClosest, fuel: .e10,
-                                                                  baseline: baseline, now: now))
-    }
-
-    func testBestValueBaselineRequiresEligibleSelectedFuelAndUsableJourney() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let recent = now.addingTimeInterval(-86_400).timeIntervalSince1970
-        let stale = now.addingTimeInterval(-40 * 86_400).timeIntervalSince1970
-        let stations = [
-            FuelStation(id: "wrong-fuel", name: "Wrong", brand: "", address: "", postcode: "", lat: 0, lng: 0,
-                        prices: [.diesel: 140], priceUpdated: recent),
-            FuelStation(id: "stale", name: "Stale", brand: "", address: "", postcode: "", lat: 0, lng: 0,
-                        prices: [.e10: 140], priceUpdated: stale),
-            FuelStation(id: "bad-journey", name: "Bad journey", brand: "", address: "", postcode: "", lat: 0, lng: 0,
-                        prices: [.e10: 141], priceUpdated: recent),
-            FuelStation(id: "eligible", name: "Eligible", brand: "", address: "", postcode: "", lat: 0, lng: 0,
-                        prices: [.e10: 145], priceUpdated: recent)
-        ]
-        let journeys: (FuelStation) -> FuelSavingsJourney? = { station in
-            self.straightLine(station.id == "wrong-fuel" ? 0.1 : station.id == "stale" ? 0.2 :
-                              station.id == "bad-journey" ? .infinity : 2)
-        }
-        XCTAssertEqual(FuelSavingsEstimator.bestValueBaselineStation(stations, fuel: .e10,
-                                                                       journeyMiles: journeys, now: now)?.id, "eligible")
-        XCTAssertNil(FuelSavingsEstimator.bestValueBaselineStation(Array(stations.prefix(2)), fuel: .e10,
-                                                                    journeyMiles: journeys, now: now))
-    }
-
     func testBaselineStationUsesTheSameJourneyValuesAsSavings() {
         let geographicallyNearest = station("geographically-nearest", price: 145.9)
         let roadNearest = station("road-nearest", price: 146.9)
@@ -432,8 +386,8 @@ final class FuelSavingsEstimateTests: XCTestCase {
         )
 
         XCTAssertEqual(availability?.result?.status, .baseline)
-        XCTAssertEqual(availability?.result?.headline(compact: true), "Closest eligible station")
-        XCTAssertEqual(FuelSavingsStatus.baseline.displayName, "Closest eligible station")
+        XCTAssertEqual(availability?.result?.headline(compact: true), "Closest station")
+        XCTAssertEqual(FuelSavingsStatus.baseline.displayName, "Closest station")
         XCTAssertEqual(availability?.result?.netSavingGBP, 0)
         XCTAssertEqual(availability?.result?.extraDistanceMiles, 0)
     }
@@ -485,7 +439,7 @@ final class FuelSavingsEstimateTests: XCTestCase {
 
     /// The exact strings the brief asks for.
     func testHeadlineWordingMatchesTheBrief() {
-        XCTAssertEqual(FuelSavingsResult.baselineHeadline, "Closest eligible station")
+        XCTAssertEqual(FuelSavingsResult.baselineHeadline, "Closest station")
         XCTAssertEqual(FuelSavingsResult.breakEvenHeadline, "Break even")
 
         let saving = FuelSavingsResult(fillLitres: 34.9,
@@ -509,87 +463,10 @@ final class FuelSavingsEstimateTests: XCTestCase {
 
     /// The sort must order by NET saving, not pump price: a pricier station can
     /// win when the cheaper one is far enough away.
-    func testBestValueAlertUsesClosestEligiblePriceAsBaseline() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        func priced(_ id: String, _ price: Double, _ daysOld: Double) -> FuelStation {
-            FuelStation(id: id, name: id, brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                        prices: [.e10: price], priceUpdated: now.addingTimeInterval(-daysOld * 86_400).timeIntervalSince1970)
-        }
-        let stations = [priced("stale-closest", 199.9, 27), priced("eligible-closest", 170.9, 1),
-                        priced("eligible-cheaper", 150.9, 1)]
-        let settings = FuelSavingsSettings(enabled: true, mpg: 30,
-            preferredAmount: .init(value: 60, unit: .pounds))
-        let alert = FuelSavingsCalculator.bestValueAlertCandidate(
-            stations: stations, fuel: .e10, settings: settings, amount: settings.preferredAmount,
-            minimumNetSavingGBP: 1,
-            journeyMiles: { self.straightLine($0.id == "stale-closest" ? 0.8 : $0.id == "eligible-closest" ? 1.6 : 3) },
-            now: now)
-        XCTAssertEqual(alert?.station.id, "eligible-cheaper")
-    }
-
-    func testBestValueAlertDoesNotRecommendStaleCandidateOrStaleBaseline() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        func priced(_ id: String, _ price: Double, _ daysOld: Double) -> FuelStation {
-            FuelStation(id: id, name: id, brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                        prices: [.e10: price], priceUpdated: now.addingTimeInterval(-daysOld * 86_400).timeIntervalSince1970)
-        }
-        let base = priced("base", 199.9, 1)
-        let stale = priced("stale", 129.9, 40)
-        let fresh = priced("fresh", 159.9, 1)
-        let settings = FuelSavingsSettings(enabled: true, mpg: 30, preferredAmount: .init(value: 60, unit: .pounds))
-        let choice = FuelSavingsCalculator.bestValueAlertCandidate(
-            stations: [base, stale, fresh], fuel: .e10, settings: settings,
-            amount: .init(value: 60, unit: .pounds), minimumNetSavingGBP: 1,
-            journeyMiles: { station in self.straightLine(station.id == "base" ? 0.8 : 2) }, now: now)
-        XCTAssertEqual(choice?.station.id, "fresh")
-        let noTrustedBaseline = FuelSavingsCalculator.bestValueAlertCandidate(
-            stations: [priced("base", 199.9, 40), fresh], fuel: .e10, settings: settings,
-            amount: .init(value: 60, unit: .pounds), minimumNetSavingGBP: 1,
-            journeyMiles: { station in self.straightLine(station.id == "base" ? 0.8 : 2) }, now: now)
-        XCTAssertNil(noTrustedBaseline)
-    }
-
-    func testStalePriceCannotLeadBestValueButRemainsVisible() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let baseline = FuelStation(id: "base", name: "Baseline", brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                                   prices: [.e10: 199.9], priceUpdated: now.addingTimeInterval(-86_400).timeIntervalSince1970)
-        let stale = FuelStation(id: "stale-cheap", name: "Stale", brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                                prices: [.e10: 129.9], priceUpdated: now.addingTimeInterval(-40 * 86_400).timeIntervalSince1970)
-        let recent = FuelStation(id: "recent", name: "Recent", brand: "", address: "", postcode: "", lat: 53, lng: -1,
-                                 prices: [.e10: 170.9], priceUpdated: now.addingTimeInterval(-86_400).timeIntervalSince1970)
-        let ranked = FuelSavingsEstimator.ranked([stale, recent], fuel: .e10, baseline: baseline,
-                                                  settings: briefSettings, amount: briefAmount,
-                                                  journeyMiles: { _ in self.straightLine(0.8) }, now: now)
-        XCTAssertEqual(ranked.map(\.id), ["recent", "stale-cheap"])
-    }
-
-    func testNoFreshPriceComparisonUsesExplicitCheapestPriceFallback() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        let staleTime = now.addingTimeInterval(-40 * 86_400).timeIntervalSince1970
-        let baseline = FuelStation(id: "baseline", name: "Baseline", brand: "", address: "", postcode: "",
-                                   lat: 53, lng: -1, prices: [.diesel: 199.9], priceUpdated: staleTime)
-        let cheapest = FuelStation(id: "cheapest", name: "Cheapest", brand: "", address: "", postcode: "",
-                                   lat: 53, lng: -1, prices: [.diesel: 129.9], priceUpdated: staleTime)
-        let near = FuelStation(id: "near", name: "Near", brand: "", address: "", postcode: "",
-                               lat: 53, lng: -1, prices: [.diesel: 170.9], priceUpdated: staleTime)
-        let ordered = FuelSavingsEstimator.ranked([near, baseline, cheapest], fuel: .diesel,
-            baseline: baseline, settings: briefSettings, amount: briefAmount,
-            journeyMiles: { station in self.straightLine(station.id == "cheapest" ? 250 : 1) }, now: now)
-        XCTAssertEqual(ordered.map(\.id), ["cheapest", "near", "baseline"])
-        XCTAssertFalse(FuelSavingsEstimator.recommendationEligible(station: ordered[0], fuel: .diesel,
-                                                                  baseline: baseline, now: now))
-    }
-
     func testSortingRanksByNetSavingNotPumpPrice() {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
-        func pricedStation(_ id: String, price: Double) -> FuelStation {
-            FuelStation(id: id, name: id, brand: "X", address: "", postcode: "",
-                        lat: 51.5, lng: -0.1, prices: [.e10: price],
-                        priceUpdated: nil, priceUpdatedByFuel: [.e10: now.timeIntervalSince1970])
-        }
-        let baseline = pricedStation("baseline", price: 171.9)
-        let cheapButFar = pricedStation("cheap-but-far", price: 167.9)
-        let pricierButNear = pricedStation("pricier-but-near", price: 169.9)
+        let baseline = station("baseline", price: 171.9)
+        let cheapButFar = station("cheap-but-far", price: 167.9)
+        let pricierButNear = station("pricier-but-near", price: 169.9)
 
         let ranked = FuelSavingsEstimator.ranked(
             [baseline, cheapButFar, pricierButNear],
@@ -603,7 +480,7 @@ final class FuelSavingsEstimateTests: XCTestCase {
                 case "cheap-but-far": return self.straightLine(7.6)
                 default: return self.straightLine(1.2)
                 }
-            }, now: now
+            }
         )
 
         XCTAssertEqual(ranked.first?.id, "pricier-but-near",
@@ -613,18 +490,18 @@ final class FuelSavingsEstimateTests: XCTestCase {
 
     // MARK: Row copy
 
-    func testCompactComparisonLabelUsesClosestEligibleStationWording() {
+    func testCompactComparisonLabelUsesGenericNearestStationWording() {
         XCTAssertEqual(
             FuelSavingsFormat.comparisonLabel(status: .worthTheDrive),
-            "vs closest eligible station"
+            "vs closest station"
         )
         XCTAssertEqual(
             FuelSavingsFormat.comparisonLabel(status: .notWorthTheDrive),
-            "vs closest eligible station"
+            "vs closest station"
         )
         XCTAssertEqual(
             FuelSavingsFormat.comparisonLabel(status: .breakEven),
-            "vs closest eligible station"
+            "vs closest station"
         )
         XCTAssertEqual(
             FuelSavingsFormat.comparisonLabel(status: .baseline),
@@ -653,7 +530,7 @@ final class FuelSavingsEstimateTests: XCTestCase {
     }
 
     /// The baseline capsule has to say what it IS: it previously repeated the
-    /// status word above it ("Closest eligible station" twice) and never explained that
+    /// status word above it ("Closest station" twice) and never explained that
     /// the savings are measured against it.
     func testCapsuleHeadlineMarksTheBaselineAndKeepsTheEstimateMarker() {
         let baseline = FuelSavingsResult(
@@ -664,7 +541,7 @@ final class FuelSavingsEstimateTests: XCTestCase {
             netSavingGBP: 0,
             status: .baseline
         )
-        XCTAssertEqual(baseline.capsuleHeadline(), "Closest eligible station")
+        XCTAssertEqual(baseline.capsuleHeadline(), "Closest station")
 
         let saving = FuelSavingsResult(
             fillLitres: 30,
diff --git a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsTests.swift b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsTests.swift
index a65411e..7ccac71 100644
--- a/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsTests.swift
+++ b/FuelBoardTests/Tests/FuelBoardSharedTests/FuelSavingsTests.swift
@@ -110,11 +110,10 @@ final class FuelSavingsCalculatorTests: XCTestCase {
     }
 
     func testBestValueAlertCandidatePicksHighestNetSavingAboveThreshold() throws {
-        let now = Date(timeIntervalSince1970: 1_800_000_000)
         let stations = [
-            station("baseline", lat: 0, lng: 0, price: 160, priceUpdated: now.timeIntervalSince1970),
-            station("small", lat: 0, lng: 0, price: 154, priceUpdated: now.timeIntervalSince1970),
-            station("best", lat: 0, lng: 0, price: 148, priceUpdated: now.timeIntervalSince1970),
+            station("baseline", lat: 0, lng: 0, price: 160),
+            station("small", lat: 0, lng: 0, price: 154),
+            station("best", lat: 0, lng: 0, price: 148),
         ]
         let journeys = ["baseline": 2.0, "small": 4.0, "best": 6.0]
         let settings = FuelSavingsSettings(enabled: true, mpg: 45, preferredAmount: .init(value: 40, unit: .pounds))
@@ -124,8 +123,7 @@ final class FuelSavingsCalculatorTests: XCTestCase {
             settings: settings,
             amount: settings.preferredAmount,
             minimumNetSavingGBP: 1.0,
-            journeyMiles: { journeys[$0.id].map { FuelSavingsJourney(miles: $0, basis: .roadRoute) } },
-            now: now
+            journeyMiles: { journeys[$0.id].map { FuelSavingsJourney(miles: $0, basis: .roadRoute) } }
         )
         XCTAssertEqual(candidate?.station.id, "best")
         XCTAssertEqual(candidate?.result.status, .worthTheDrive)
@@ -139,10 +137,8 @@ final class FuelSavingsCalculatorTests: XCTestCase {
         XCTAssertEqual(FuelSavingsCalculator.sortedForWorthTheDrive([farther, nearer]).first?.stationID, "nearer")
     }
 
-    private func station(_ id: String, lat: Double, lng: Double, price: Double,
-                         priceUpdated: TimeInterval? = nil) -> FuelStation {
-        FuelStation(id: id, name: id, brand: id, address: "", postcode: "", lat: lat, lng: lng,
-                    prices: [.e10: price], priceUpdated: priceUpdated)
+    private func station(_ id: String, lat: Double, lng: Double, price: Double) -> FuelStation {
+        FuelStation(id: id, name: id, brand: id, address: "", postcode: "", lat: lat, lng: lng, prices: [.e10: price], priceUpdated: nil)
     }
 }
 
diff --git a/FuelBoardTests/Tests/FuelBoardSharedTests/StationPriceAgePolicyTests.swift b/FuelBoardTests/Tests/FuelBoardSharedTests/StationPriceAgePolicyTests.swift
new file mode 100644
index 0000000..18757c6
--- /dev/null
+++ b/FuelBoardTests/Tests/FuelBoardSharedTests/StationPriceAgePolicyTests.swift
@@ -0,0 +1,219 @@
+import XCTest
+#if SWIFT_PACKAGE
+@testable import FuelBoardShared
+#endif
+
+/// Regression: a station's price age never removes it from Best Value.
+///
+/// The relay publishes one `price_updated` per station — the newest
+/// `price_last_updated` across the grades it maps — which cannot vouch for the
+/// selected grade. It is therefore display-only: Best Value, Cheapest and
+/// Closest rank stations on their prices and distances exactly as before,
+/// whether the timestamp is minutes, months or absent.
+final class StationPriceAgePolicyTests: XCTestCase {
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+    private let settings = FuelSavingsSettings(
+        enabled: true,
+        mpg: 30,
+        preferredAmount: FuelSavingsFillAmount(value: 60, unit: .pounds)
+    )
+
+    private func station(_ id: String,
+                         price: Double,
+                         fuel: FuelType = .e10,
+                         ageDays: Double?,
+                         lat: Double = 53,
+                         lng: Double = -1) -> FuelStation {
+        FuelStation(
+            id: id, name: id, brand: "X", address: "", postcode: "", lat: lat, lng: lng,
+            prices: [fuel: price],
+            priceUpdated: ageDays.map { now.addingTimeInterval(-$0 * 86_400).timeIntervalSince1970 }
+        )
+    }
+
+    private func straightLine(_ miles: Double) -> FuelSavingsJourney {
+        FuelSavingsJourney(miles: miles, basis: .straightLine)
+    }
+
+    private func distanceProvider(_ miles: [String: Double]) -> (FuelStation) -> FuelSavingsJourney? {
+        { station in miles[station.id].map { self.straightLine($0) } }
+    }
+
+    // MARK: - The baseline is the closest seller, whatever its age
+
+    func testClosestSellerIsTheBaselineEvenWhenItsTimestampIsAncient() {
+        let ancientClosest = station("ancient-closest", price: 199.9, ageDays: 250)
+        let freshFurther = station("fresh-further", price: 170.9, ageDays: 1)
+        let journeys = distanceProvider(["ancient-closest": 0.8, "fresh-further": 3.0])
+
+        XCTAssertEqual(
+            FuelSavingsEstimator.baselineStation([ancientClosest, freshFurther], fuel: .e10,
+                                                 journeyMiles: journeys)?.id,
+            "ancient-closest",
+            "the baseline is the closest station selling the selected fuel — age is not a criterion"
+        )
+    }
+
+    func testBaselineStillRequiresTheSelectedFuelAndAUsableJourney() {
+        let wrongFuel = station("wrong-fuel", price: 140, fuel: .diesel, ageDays: 1)
+        let unusableJourney = station("bad-journey", price: 141, ageDays: 1)
+        let sellsFuel = station("sells-fuel", price: 145, ageDays: 1)
+        let journeys = distanceProvider(["wrong-fuel": 0.1, "sells-fuel": 2.0])  // bad-journey has none
+
+        XCTAssertEqual(
+            FuelSavingsEstimator.baselineStation([wrongFuel, unusableJourney, sellsFuel], fuel: .e10,
+                                                 journeyMiles: journeys)?.id,
+            "sells-fuel"
+        )
+    }
+
+    // MARK: - Old, missing and invalid timestamps still rank
+
+    func testOldPriceTimestampsRankByNetSavingForEveryFuel() {
+        for fuel in FuelType.allCases {
+            let base = station("base", price: 199.9, fuel: fuel, ageDays: 250)
+            let cheap = station("cheap", price: 129.9, fuel: fuel, ageDays: 250)
+            let dear = station("dear", price: 198.9, fuel: fuel, ageDays: 250)
+            let journeys = distanceProvider(["base": 0.8, "cheap": 1.2, "dear": 1.0])
+
+            let ranked = FuelSavingsEstimator.ranked([dear, cheap, base], fuel: fuel, baseline: base,
+                                                     settings: settings, amount: settings.preferredAmount,
+                                                     journeyMiles: journeys)
+
+            XCTAssertEqual(ranked.map(\.id), ["cheap", "dear", "base"], fuel.rawValue)
+            let saving = FuelSavingsEstimator.availability(
+                station: cheap, fuel: fuel, baseline: base, settings: settings,
+                amount: settings.preferredAmount, journey: straightLine(1.2), baselineJourney: straightLine(0.8)
+            )?.result
+            XCTAssertGreaterThan(saving?.netSavingGBP ?? -1, 0,
+                                 "\(fuel.rawValue): a 250-day-old price still produces a saving")
+        }
+    }
+
+    func testNetSavingStillOutranksPumpPriceWhenTimestampsAreOld() {
+        // Net saving decides the order: the cheapest station is 30 miles away,
+        // so a pricier one a mile from home wins. Nothing here consults the age.
+        let base = station("base", price: 171.9, ageDays: 120)
+        let cheapFar = station("cheap-far", price: 169.9, ageDays: 250)
+        let pricierNear = station("pricier-near", price: 170.9, ageDays: 200)
+        let journeys = distanceProvider(["base": 0.8, "cheap-far": 30, "pricier-near": 1.2])
+
+        let ranked = FuelSavingsEstimator.ranked([cheapFar, pricierNear, base], fuel: .e10, baseline: base,
+                                                 settings: settings, amount: settings.preferredAmount,
+                                                 journeyMiles: journeys)
+
+        XCTAssertEqual(ranked.map(\.id), ["pricier-near", "base", "cheap-far"])
+        XCTAssertEqual(ranked.first?.prices[.e10], 170.9, "the winner is chosen on net saving, not pump price")
+    }
+
+    func testMissingFutureAndAbsurdTimestampsDoNotRemoveStations() {
+        let invalid = FuelStation(id: "absurd", name: "Absurd", brand: "", address: "", postcode: "",
+                                  lat: 53, lng: -1, prices: [.e10: 150.9],
+                                  priceUpdated: -Double.greatestFiniteMagnitude)
+        let pool = [station("base", price: 199.9, ageDays: 250),
+                    station("cheap", price: 129.9, ageDays: 100),
+                    FuelStation(id: "future", name: "Future", brand: "", address: "", postcode: "",
+                                lat: 53, lng: -1, prices: [.e10: 160.9],
+                                priceUpdated: now.addingTimeInterval(86_400).timeIntervalSince1970),
+                    station("undated", price: 170.9, ageDays: nil),
+                    invalid]
+        let journeys = distanceProvider(["base": 0.8, "cheap": 1.2, "future": 1.6,
+                                         "undated": 2.0, "absurd": 2.8])
+
+        let ranked = FuelSavingsEstimator.ranked(pool, fuel: .e10, baseline: pool[0],
+                                                 settings: settings, amount: settings.preferredAmount,
+                                                 journeyMiles: journeys)
+
+        XCTAssertEqual(Set(ranked.map(\.id)), Set(pool.map(\.id)),
+                       "every station stays in the pool: no timestamp can filter a row out")
+        XCTAssertEqual(ranked.first?.id, "cheap", "the cheapest station still wins")
+    }
+
+    func testEveryPricedStationKeepsAResultWhateverItsTimestamp() {
+        let pool = [
+            station("base", price: 199.9, ageDays: 1),
+            station("fresh", price: 180.9, ageDays: 1),
+            station("old", price: 175.9, ageDays: 40),
+            station("ancient", price: 170.9, ageDays: 250),
+            station("undated", price: 165.9, ageDays: nil)
+        ]
+        let journeys = distanceProvider(["base": 0.8, "fresh": 1.0, "old": 1.4, "ancient": 1.8, "undated": 2.2])
+
+        let ranked = FuelSavingsEstimator.ranked(pool, fuel: .e10, baseline: pool[0],
+                                                 settings: settings, amount: settings.preferredAmount,
+                                                 journeyMiles: journeys)
+
+        XCTAssertEqual(ranked.map(\.id).sorted(), ["ancient", "base", "fresh", "old", "undated"])
+        for station in pool {
+            let result = FuelSavingsEstimator.availability(
+                station: station, fuel: .e10, baseline: pool[0], settings: settings,
+                amount: settings.preferredAmount,
+                journey: journeys(station), baselineJourney: straightLine(0.8)
+            )?.result
+            XCTAssertNotNil(result, "\(station.id) still shows a Best Value row")
+        }
+    }
+
+    func testCheapestAndClosestOrdersAreUnaffectedByTimestampAge() {
+        // Cheapest sorts on pump price, Closest on distance — the only inputs are
+        // prices and distances, so no age combination changes either order.
+        let specs: [(String, Double, Double)] = [("a", 199.9, 0.8), ("b", 129.9, 30), ("c", 170.9, 1.2)]
+        for ages in [[1.0, 1.0, 1.0], [250.0, 250.0, 250.0]] {
+            let pool = zip(specs, ages).map { spec, age in
+                station(spec.0, price: spec.1, ageDays: age)
+            }
+            let journeys = distanceProvider(Dictionary(uniqueKeysWithValues:
+                zip(specs.map(\.0), specs.map(\.2))))
+
+            let cheapestFirst = pool.sorted { lhs, rhs in
+                let left = lhs.prices[.e10] ?? .infinity
+                let right = rhs.prices[.e10] ?? .infinity
+                if left != right { return left < right }
+                return (journeys(lhs)?.miles ?? .infinity) < (journeys(rhs)?.miles ?? .infinity)
+            }
+            XCTAssertEqual(cheapestFirst.map(\.id), ["b", "c", "a"])
+
+            let closestFirst = pool.sorted { lhs, rhs in
+                let left = journeys(lhs)?.miles ?? .infinity
+                let right = journeys(rhs)?.miles ?? .infinity
+                if left != right { return left < right }
+                return (lhs.prices[.e10] ?? .infinity) < (rhs.prices[.e10] ?? .infinity)
+            }
+            XCTAssertEqual(closestFirst.map(\.id), ["a", "c", "b"])
+        }
+    }
+
+    // MARK: - The bundled / offline dataset
+
+    func testBundledDatasetWithMonthOldTimestampsStillRecommendsBestValue() {
+        // The bundled dump ships one pull of the whole UK feed, so every station
+        // arrives with the same months-old timestamp. Best Value must still
+        // recommend — it used to read "unavailable" for the entire offline list.
+        var specs: [(String, Double, Double, Double?)] = [("base", 171.9, 0.8, 90),
+                                                          ("pricier-near", 170.9, 1.2, 200),
+                                                          ("cheap-far", 149.9, 40, 250),
+                                                          ("dear-near", 179.9, 1.6, nil),
+                                                          ("old-undated", 160.9, 5.0, 240)]
+        let pool = specs.map { station($0.0, price: $0.1, ageDays: $0.3) }
+        let journeys = distanceProvider(Dictionary(uniqueKeysWithValues:
+            specs.map { ($0.0, $0.2) }))
+
+        let ranked = FuelSavingsEstimator.ranked(pool, fuel: .e10, baseline: pool[0],
+                                                 settings: settings, amount: settings.preferredAmount,
+                                                 journeyMiles: journeys)
+
+        let savings = pool.map { station in
+            (station.id, FuelSavingsEstimator.availability(
+                station: station, fuel: .e10, baseline: pool[0], settings: settings,
+                amount: settings.preferredAmount, journey: journeys(station), baselineJourney: straightLine(0.8)
+            )?.result?.netSavingGBP ?? -Double.infinity)
+        }
+        let expectedWinner = savings.max { $0.1 < $1.1 }?.0
+
+        XCTAssertEqual(ranked.first?.id, expectedWinner,
+                       "the offline list is still ordered by net saving")
+        XCTAssertNotNil(ranked.first?.prices[.e10], "the top station has a price to show")
+        XCTAssertGreaterThan(savings.first { $0.0 == expectedWinner }?.1 ?? -1, 0,
+                             "and that recommendation carries a real saving")
+    }
+}
diff --git a/FuelBoardWidgets/FuelPriceWidget.swift b/FuelBoardWidgets/FuelPriceWidget.swift
index 7220e0c..b0ef840 100644
--- a/FuelBoardWidgets/FuelPriceWidget.swift
+++ b/FuelBoardWidgets/FuelPriceWidget.swift
@@ -203,8 +203,6 @@ struct FuelPriceTimelineProvider<Configuration: WidgetConfigurationIntent & Widg
         // 3) Load + order stations per widget mode.
         let ordered: [FuelStation]
         var bestValueResult: FuelSavingsResult?
-        var bestValuePriceConfidence: FuelPriceFreshness.ComparisonConfidence = .ineligible
-        var bestValuePriceWarning: String?
         if isFavourites {
             let favourites = FuelStore.loadFavourites()
                 .filter { $0.station.prices[$0.fuel] != nil }
@@ -308,8 +306,7 @@ struct FuelPriceTimelineProvider<Configuration: WidgetConfigurationIntent & Widg
                     break
                 }
                 let amount = settings.preferredAmount
-                let baseline = FuelSavingsEstimator.bestValueBaselineStation(filtered, fuel: fuel,
-                                                                             journeyMiles: journey)
+                let baseline = FuelSavingsEstimator.baselineStation(filtered, fuel: fuel, journeyMiles: journey)
                 let ranked = FuelSavingsEstimator.ranked(
                     filtered,
                     fuel: fuel,
@@ -320,13 +317,6 @@ struct FuelPriceTimelineProvider<Configuration: WidgetConfigurationIntent & Widg
                 )
                 ordered = ranked
                 if let first = ranked.first, let baseline {
-                    bestValuePriceConfidence = FuelPriceFreshness.comparisonConfidence(
-                        station: first, fuel: fuel, baseline: baseline)
-                    bestValuePriceWarning = FuelPriceFreshness.comparisonWarning(
-                        station: first, fuel: fuel, baseline: baseline)
-                }
-                if let first = ranked.first, let baseline,
-                   bestValuePriceConfidence != .ineligible {
                     let baselineJourney = journey(baseline)
                     let result = FuelSavingsEstimator.availability(
                         station: first,
@@ -358,9 +348,7 @@ struct FuelPriceTimelineProvider<Configuration: WidgetConfigurationIntent & Widg
                 date: Date(), stations: Array(ordered.prefix(8)),
                 fuel: fuel, sort: sort, isFavourites: isFavourites,
                 location: origin, locationSource: source,
-                unit: unit, bestValueResult: bestValueResult,
-                bestValuePriceConfidence: bestValuePriceConfidence,
-                bestValuePriceWarning: bestValuePriceWarning
+                unit: unit, bestValueResult: bestValueResult
             )
         ), originSource)
     }
diff --git a/Shared/FuelPriceFreshness.swift b/Shared/FuelPriceFreshness.swift
index 4a0cbeb..c6047c5 100644
--- a/Shared/FuelPriceFreshness.swift
+++ b/Shared/FuelPriceFreshness.swift
@@ -12,31 +12,48 @@ enum FuelPriceTimestamp {
     }
 }
 
+/// Station-level price freshness — informational only.
+///
+/// The relay publishes ONE `price_updated` per station, derived from the
+/// GOV.UK Fuel Finder field `price_last_updated` as the MAXIMUM across the
+/// fuel grades it maps. It is therefore a station-level figure and never a
+/// verified timestamp for the grade the user has selected, so every label
+/// describes the station's price information rather than one fuel.
+///
+/// Age excludes nothing: a station with a valid price is ranked on that price
+/// however old its timestamp is. `outdatedAge` only decides whether More info
+/// adds a discreet "May be outdated" note.
 enum FuelPriceFreshness {
-    static let warningAge: TimeInterval = 7 * 24 * 60 * 60
-    static let staleAge: TimeInterval = 30 * 24 * 60 * 60
+    /// Price information older than this is flagged as possibly out of date.
+    /// A display threshold only — it gates nothing.
+    static let outdatedAge: TimeInterval = 30 * 24 * 60 * 60
+    /// Tolerated clock skew. A timestamp further into the future than this is
+    /// unusable (a feed error), never silently treated as "just now".
     static let futureTolerance: TimeInterval = 5 * 60
+    /// Ages beyond this are unusable rather than displayed. It also keeps the
+    /// day count inside `Int`, so an absurd epoch cannot trap.
+    static let maximumAge: TimeInterval = 365 * 24 * 60 * 60 * 10
 
-    enum Source: Equatable { case gradeSpecific, stationWide, unknown }
-    enum Status: Equatable { case fresh, warning, stale, unknown, invalid }
-    enum Confidence: Equatable { case verified, provisional, unavailable }
-    enum RecommendationEligibility: Equatable { case eligible, ineligible }
+    enum Status: Equatable {
+        /// Readable timestamp within `outdatedAge`.
+        case fresh
+        /// Readable timestamp older than `outdatedAge`.
+        case outdated
+        /// The record carries no timestamp.
+        case unknown
+        /// A timestamp is present but unreadable, or implausibly in the future.
+        case invalid
+    }
 
     struct Assessment: Equatable {
-        let source: Source
         let status: Status
+        /// Age in seconds. nil exactly when the timestamp is unusable, so no
+        /// caller can print an age that was never measured.
         let age: TimeInterval?
-        let confidence: Confidence
-        let recommendationEligibility: RecommendationEligibility
-        let warning: Bool
 
-        var isEligibleForBestValue: Bool {
-            recommendationEligibility == .eligible
-        }
+        var isOutdated: Bool { status == .outdated }
 
-        /// The one age More info reports. Production data carries a single
-        /// station-wide timestamp per station, so there is no separate
-        /// grade-level age to show; an absent or unreadable timestamp reads
+        /// The one age More info reports. Missing or unreadable timestamps read
         /// "Not provided" rather than implying freshness.
         var updateAgeLabel: String {
             guard let age else {
@@ -46,19 +63,16 @@ enum FuelPriceFreshness {
                           Self.ageText(age))
         }
 
-        var displayLabel: String {
-            switch (source, status, age) {
-            case (_, .unknown, _): return "Price age unknown"
-            case (_, .invalid, _): return "Price timestamp invalid"
-            case (_, .stale, let age?): return "Price updated \(Self.ageText(age)) ago · may be outdated"
-            case (.stationWide, _, let age?): return "Price updated \(Self.ageText(age)) ago · station-wide · provisional"
-            case (_, .warning, let age?): return "Price updated \(Self.ageText(age)) ago"
-            case (.gradeSpecific, .fresh, let age?): return "Price updated \(Self.ageText(age)) ago"
-            default: return "Price age unknown"
-            }
+        /// Discreet flag for price information past `outdatedAge`. nil while the
+        /// information is fresh, and nil when there is nothing to measure.
+        var outdatedNotice: String? {
+            guard status == .outdated else { return nil }
+            return String(localized: "May be outdated",
+                          comment: "Station price information older than 30 days")
         }
 
-        private static func ageText(_ age: TimeInterval) -> String {
+        /// Compact age: minutes under an hour, hours under two days, then days.
+        static func ageText(_ age: TimeInterval) -> String {
             let minutes = max(0, Int(age / 60))
             if minutes < 60 { return "\(minutes)m" }
             let hours = minutes / 60
@@ -67,112 +81,21 @@ enum FuelPriceFreshness {
         }
     }
 
-    static func assessment(for station: FuelStation, fuel: FuelType, now: Date = Date()) -> Assessment {
-        if station.priceUpdatedByFuelRaw?[fuel] != nil && station.priceUpdatedByFuel?[fuel] == nil {
-            return invalid(source: .gradeSpecific)
-        }
-        if let timestamp = station.priceUpdatedByFuel?[fuel] {
-            return assess(timestamp: timestamp, source: .gradeSpecific, now: now)
-        }
-        guard let timestamp = station.priceUpdated else { return unknown() }
-        return assess(timestamp: timestamp, source: .stationWide, now: now)
+    /// The station's own timestamp. Deliberately takes no fuel: there is one
+    /// figure per station and every grade reads the same one, so the policy
+    /// cannot differ between fuels.
+    static func assessment(for station: FuelStation, now: Date = Date()) -> Assessment {
+        assessment(priceUpdated: station.priceUpdated, now: now)
     }
 
-    /// Recommendation gate for Best Value. A station-wide timestamp under
-    /// seven days can support a provisional estimate. Older station-wide
-    /// reports cannot establish grade recency; grade-specific timestamps may
-    /// remain eligible up to thirty days, but carry an age warning.
-    static func isEligibleForBestValue(station: FuelStation, fuel: FuelType,
-                                       now: Date = Date()) -> Bool {
-        assessment(for: station, fuel: fuel, now: now).isEligibleForBestValue
-    }
-
-    static func assessment(priceUpdated: String?, priceUpdatedByGrade: [String: String]?,
-                           fuel: FuelType, now: Date = Date()) -> Assessment {
-        if let raw = priceUpdatedByGrade?[fuel.rawValue] {
-            guard let date = FuelPriceTimestamp.parse(raw) else { return invalid(source: .gradeSpecific) }
-            return assess(timestamp: date.timeIntervalSince1970, source: .gradeSpecific, now: now)
-        }
-        guard let raw = priceUpdated else { return unknown() }
-        guard let date = FuelPriceTimestamp.parse(raw) else { return invalid() }
-        return assess(timestamp: date.timeIntervalSince1970, source: .stationWide, now: now)
-    }
-
-    static func assessment(priceUpdated: TimeInterval?, priceUpdatedByFuel: [FuelType: TimeInterval]?,
-                           fuel: FuelType, now: Date = Date()) -> Assessment {
-        if let timestamp = priceUpdatedByFuel?[fuel] {
-            return assess(timestamp: timestamp, source: .gradeSpecific, now: now)
-        }
-        guard let timestamp = priceUpdated else { return unknown() }
-        return assess(timestamp: timestamp, source: .stationWide, now: now)
-    }
-
-    /// Confidence for a monetary comparison requires both selected-grade prices.
-    /// Keep the eligibility and label decision together for app and widgets.
-    enum ComparisonConfidence: Equatable {
-        case verified, provisional, ineligible
-
-        static func assess(station: FuelStation, fuel: FuelType, baseline: FuelStation?, now: Date = Date()) -> Self {
-            FuelPriceFreshness.comparisonConfidence(station: station, fuel: fuel, baseline: baseline, now: now)
-        }
-
-        /// Only an ineligible comparison needs a line of its own. The capsule
-        /// already presents a provisional saving as an estimate, so a second
-        /// line saying so crowded the rows and the detail sheet without
-        /// changing anything the user could do.
-        var warningText: String? {
-            switch self {
-            case .verified, .provisional: return nil
-            case .ineligible: return String(localized: "Price age unavailable or too old — not a Best Value recommendation.")
-            }
-        }
-    }
-
-    /// A short line for a comparison that cannot be recommended at all; rows
-    /// stay quiet otherwise. Naming the fuel, and which side of the comparison
-    /// was weak, was noise once the saving is already labelled an estimate.
-    static func comparisonWarning(station: FuelStation, fuel: FuelType,
-                                  baseline: FuelStation?, now: Date = Date()) -> String? {
-        comparisonConfidence(station: station, fuel: fuel, baseline: baseline, now: now).warningText
-    }
-
-    static func comparisonConfidence(station: FuelStation, fuel: FuelType,
-                                     baseline: FuelStation?, now: Date = Date()) -> ComparisonConfidence {
-        guard let baseline,
-              let candidatePrice = station.prices[fuel], candidatePrice.isFinite, candidatePrice > 0,
-              let baselinePrice = baseline.prices[fuel], baselinePrice.isFinite, baselinePrice > 0
-        else { return .ineligible }
-        let candidate = assessment(for: station, fuel: fuel, now: now)
-        let reference = assessment(for: baseline, fuel: fuel, now: now)
-        guard candidate.isEligibleForBestValue, reference.isEligibleForBestValue else { return .ineligible }
-        if candidate.confidence == .verified, reference.confidence == .verified,
-           candidate.status == .fresh, reference.status == .fresh { return .verified }
-        return .provisional
-    }
-
-    private static func unknown() -> Assessment {
-        Assessment(source: .unknown, status: .unknown, age: nil,
-                   confidence: .unavailable, recommendationEligibility: .ineligible, warning: true)
-    }
-
-    private static func invalid(source: Source = .unknown) -> Assessment {
-        Assessment(source: source, status: .invalid, age: nil,
-                   confidence: .unavailable, recommendationEligibility: .ineligible, warning: true)
-    }
-
-    private static func assess(timestamp: TimeInterval, source: Source, now: Date) -> Assessment {
-        let age = now.timeIntervalSince1970 - timestamp
-        guard age >= -futureTolerance else {
-            return Assessment(source: source, status: .invalid, age: nil,
-                              confidence: .unavailable, recommendationEligibility: .ineligible, warning: true)
+    static func assessment(priceUpdated: TimeInterval?, now: Date = Date()) -> Assessment {
+        guard let priceUpdated else { return Assessment(status: .unknown, age: nil) }
+        guard priceUpdated.isFinite else { return Assessment(status: .invalid, age: nil) }
+        let age = now.timeIntervalSince1970 - priceUpdated
+        guard age.isFinite, age >= -futureTolerance, age <= maximumAge else {
+            return Assessment(status: .invalid, age: nil)
         }
         let boundedAge = max(0, age)
-        let status: Status = boundedAge > staleAge ? .stale : boundedAge > warningAge ? .warning : .fresh
-        let confidence: Confidence = source == .gradeSpecific ? .verified : .provisional
-        let eligible = status == .fresh || (source == .gradeSpecific && status == .warning)
-        return Assessment(source: source, status: status, age: boundedAge,
-                          confidence: confidence,
-                          recommendationEligibility: eligible ? .eligible : .ineligible,
-                          warning: source != .gradeSpecific || status != .fresh)
+        return Assessment(status: boundedAge > outdatedAge ? .outdated : .fresh, age: boundedAge)
     }
 }
diff --git a/Shared/FuelPriceProvider.swift b/Shared/FuelPriceProvider.swift
index 8c554c2..f70a5cc 100644
--- a/Shared/FuelPriceProvider.swift
+++ b/Shared/FuelPriceProvider.swift
@@ -38,9 +38,7 @@ enum FuelPriceProvider {
                 lat: relay.lat ?? 0,
                 lng: relay.lng ?? 0,
                 prices: relay.allPrices,
-                    priceUpdated: relay.priceUpdatedDate?.timeIntervalSince1970,
-                    priceUpdatedByFuel: relay.priceUpdatedByFuel,
-                    priceUpdatedByFuelRaw: relay.priceUpdatedByFuelRaw
+                priceUpdated: relay.priceUpdatedDate?.timeIntervalSince1970
             )
         }
     }
@@ -118,41 +116,16 @@ private struct MirrorResponse: Codable {
         let price: Double?
         let prices: [String: Double]?
         let priceUpdated: String?
-        let priceUpdatedByGrade: [String: String]?
-        let priceUpdatedByFuelRawValues: [String: String]?
 
         enum CodingKeys: String, CodingKey {
             case id, name, brand, address, postcode, lat, lng, price, prices
             case priceUpdated = "price_updated"
-            case priceUpdatedByGrade = "price_updated_by_grade"
-            case priceUpdatedByFuelRawValues = "price_updated_by_fuel"
         }
 
         var priceUpdatedDate: Date? {
             FuelPriceTimestamp.parse(priceUpdated)
         }
 
-        var priceUpdatedByFuelRaw: [FuelType: String]? {
-            let raw = priceUpdatedByGrade ?? priceUpdatedByFuelRawValues
-            guard let raw else { return nil }
-            let parsed = raw.reduce(into: [FuelType: String]()) { result, item in
-                guard let fuel = FuelPriceProvider.fuelType(for: item.key) else { return }
-                result[fuel] = item.value
-            }
-            return parsed.isEmpty ? nil : parsed
-        }
-
-        var priceUpdatedByFuel: [FuelType: TimeInterval]? {
-            let raw = priceUpdatedByGrade ?? priceUpdatedByFuelRawValues
-            guard let raw else { return nil }
-            let parsed = raw.reduce(into: [FuelType: TimeInterval]()) { result, item in
-                guard let fuel = FuelPriceProvider.fuelType(for: item.key),
-                      let date = FuelPriceTimestamp.parse(item.value) else { return }
-                result[fuel] = date.timeIntervalSince1970
-            }
-            return parsed.isEmpty ? nil : parsed
-        }
-
         /// Map mirror grade keys (E5/E10/DIESEL) to FuelType for ALL fuels the
         /// station sells — one fetch populates every fuel tab. Defensive guard:
         /// any grade outside the 50–500 pence/litre band is dropped, so a mirror
diff --git a/Shared/FuelPriceWidgetViews.swift b/Shared/FuelPriceWidgetViews.swift
index e31bb58..a25241c 100644
--- a/Shared/FuelPriceWidgetViews.swift
+++ b/Shared/FuelPriceWidgetViews.swift
@@ -35,11 +35,6 @@ struct FuelPriceWidgetEntryData {
     let locationSource: String    // "live" | "cached" | "none"
     let unit: DistanceUnit        // user's display unit for distances
     let bestValueResult: FuelSavingsResult? // only populated for the small Best Value face
-    /// Both selected-fuel prices are assessed by the shared freshness policy.
-    var bestValuePriceConfidence: FuelPriceFreshness.ComparisonConfidence = .ineligible
-    /// Candidate-aware warning copy (names the fuel, and the baseline when the
-    /// baseline is the weak link). Falls back to the confidence's own text.
-    var bestValuePriceWarning: String? = nil
 }
 
 /// The widget face, parameterised by family so the app can preview it.
@@ -97,16 +92,10 @@ struct FuelPriceWidgetContent: View {
                 Text(result.headline(compact: true))
                     .font(.title3.weight(.bold))
                     .lineLimit(1)
-                Text(result.status == .baseline ? "your baseline" : "vs closest eligible station")
+                Text(result.status == .baseline ? "your baseline" : "vs closest station")
                     .font(.caption2)
                     .foregroundStyle(.secondary)
                     .lineLimit(1)
-                if let warning = entry.bestValuePriceWarning ?? entry.bestValuePriceConfidence.warningText {
-                    Text(warning)
-                        .font(.caption2)
-                        .foregroundStyle(.orange)
-                        .lineLimit(2)
-                }
             } else if entry.sort == .worthTheDrive {
                 if let price = station.prices[entry.fuel] {
                     FuelStore.priceTextAttributed(price, size: 26, weight: .bold, color: .green)
@@ -116,11 +105,6 @@ struct FuelPriceWidgetContent: View {
                         .font(.caption2)
                         .foregroundStyle(.orange)
                         .lineLimit(2)
-                } else {
-                    Text("Best Value unavailable · price confidence insufficient")
-                        .font(.caption2)
-                        .foregroundStyle(.orange)
-                        .lineLimit(2)
                 }
             } else if let price = station.prices[entry.fuel] {
                 FuelStore.priceTextAttributed(price, size: 26, weight: .bold, color: .green)
@@ -163,9 +147,7 @@ struct FuelPriceWidgetContent: View {
                     .font(.caption2)
                     .foregroundStyle(.secondary)
                 Spacer()
-                Text(entry.sort == .worthTheDrive && entry.bestValuePriceConfidence == .ineligible
-                     ? "price order · Best Value unavailable"
-                     : entry.isFavourites ? "your order"
+                Text(entry.isFavourites ? "your order"
                      : (entry.locationSource == "none" ? "by price" : "near you"))
                     .font(.caption2)
                     .foregroundStyle(.secondary)
diff --git a/Shared/FuelSavings.swift b/Shared/FuelSavings.swift
index 1987d5c..27d5dc2 100644
--- a/Shared/FuelSavings.swift
+++ b/Shared/FuelSavings.swift
@@ -45,7 +45,7 @@ enum FuelSavingsStatus: String, Codable, Equatable {
     case breakEven
     case notWorthTheDrive
     /// The comparison baseline itself — the station every other saving is
-    /// measured against. Shown as "Closest eligible station", never "Break even".
+    /// measured against. Shown as "Closest station", never "Break even".
     case baseline
 
     var displayName: String {
@@ -147,7 +147,7 @@ enum FuelSavingsFormat {
     /// "Closest" refers to the existing shortest-journey baseline selection;
     /// it does not claim a straight-line comparison.
     static func comparisonLabel(status: FuelSavingsStatus) -> String {
-        status == .baseline ? "your baseline" : "vs closest eligible station"
+        status == .baseline ? "your baseline" : "vs closest station"
     }
 
     /// VoiceOver form of `extraTravelLabel`. The abbreviation and the unit suffix
@@ -174,7 +174,7 @@ enum FuelSavingsFormat {
 
 extension FuelSavingsResult {
     /// Baseline row label — required wording.
-    static let baselineHeadline = "Closest eligible station"
+    static let baselineHeadline = "Closest station"
     /// Neutral result label — required wording.
     static let breakEvenHeadline = "Break even"
 
@@ -195,7 +195,7 @@ extension FuelSavingsResult {
     }
 
     /// Row headline, e.g. "£1.22 better off after travel", "£0.31 worse off after
-    /// travel", "Break even", "Closest eligible station".
+    /// travel", "Break even", "Closest station".
     ///
     /// Estimated comparisons are prefixed "Approx. " for positive/negative money
     /// results — the WORD, never a "~": a tilde reads as decoration (and assistive
@@ -452,24 +452,21 @@ enum FuelSavingsCalculator {
         settings: FuelSavingsSettings,
         amount: FuelSavingsFillAmount,
         minimumNetSavingGBP: Double,
-        journeyMiles: (FuelStation) -> FuelSavingsJourney?,
-        now: Date = Date()
+        journeyMiles: (FuelStation) -> FuelSavingsJourney?
     ) -> BestValueAlertCandidate? {
         guard settings.isConfigured, minimumNetSavingGBP.isFinite else { return nil }
         let sellers = stations.filter { $0.prices[fuel] != nil }
         guard !sellers.isEmpty else { return nil }
-        let baseline = FuelSavingsEstimator.bestValueBaselineStation(sellers, fuel: fuel,
-                                                                     journeyMiles: journeyMiles, now: now)
-        guard let baseline else { return nil }
+        let baseline = FuelSavingsEstimator.baselineStation(sellers, fuel: fuel, journeyMiles: journeyMiles)
         var best: BestValueAlertCandidate?
         var bestDistance = Double.greatestFiniteMagnitude
         var bestPrice = Double.infinity
         var baselineJourneyCache: FuelSavingsJourney?
         var baselineJourneyLoaded = false
         for station in sellers {
-            guard FuelPriceFreshness.isEligibleForBestValue(station: station, fuel: fuel, now: now) else { continue }
             let journey = journeyMiles(station)
             let baselineJourney: FuelSavingsJourney? = {
+                guard let baseline else { return nil }
                 if baseline.id == station.id { return journey }
                 if !baselineJourneyLoaded {
                     baselineJourneyCache = journeyMiles(baseline)
@@ -513,8 +510,12 @@ enum FuelSavingsCalculator {
 /// Pure and injectable (no MapKit, CoreLocation or SwiftUI) so the ranking
 /// rules are unit tested directly.
 enum FuelSavingsEstimator {
-    /// Closest priced station, irrespective of evidence age. Used for ordinary
-    /// Closest sorting, which must continue to include older prices.
+    /// Baseline station for Best Value: the station with the shortest journey
+    /// among stations that sell the selected fuel, using the SAME journey source
+    /// the savings calculation will use. This keeps the row labelled "Closest
+    /// station" and every "extra return travel" value tied to one
+    /// reference, instead of mixing a separate straight-line baseline with
+    /// road-route savings.
     static func baselineStation(_ stations: [FuelStation],
                                 fuel: FuelType,
                                 journeyMiles: (FuelStation) -> FuelSavingsJourney?) -> FuelStation? {
@@ -532,17 +533,6 @@ enum FuelSavingsEstimator {
         return bestStation
     }
 
-    /// Closest selected-fuel seller with price evidence eligible for a Best Value
-    /// comparison. The ordinary Closest sort still includes every priced station.
-    static func bestValueBaselineStation(_ stations: [FuelStation],
-                                         fuel: FuelType,
-                                         journeyMiles: (FuelStation) -> FuelSavingsJourney?,
-                                         now: Date = Date()) -> FuelStation? {
-        baselineStation(stations.filter {
-            FuelPriceFreshness.comparisonConfidence(station: $0, fuel: fuel, baseline: $0, now: now) != .ineligible
-        }, fuel: fuel, journeyMiles: journeyMiles)
-    }
-
     /// Savings for a single station against `baseline`, or nil when there is
     /// nothing to show at all (feature off).
     static func availability(station: FuelStation,
@@ -584,26 +574,20 @@ enum FuelSavingsEstimator {
         }
     }
 
-    /// Recommendation gate shared by Best Value order, widgets and alerts.
-    /// The baseline and candidate must both pass the selected-fuel freshness
-    /// policy. A recent station-wide timestamp remains provisional; missing,
-    /// invalid and over-threshold timestamps cannot lead a recommendation.
-    static func recommendationEligible(station: FuelStation, fuel: FuelType,
-                                       baseline: FuelStation?, now: Date = Date()) -> Bool {
-        FuelPriceFreshness.comparisonConfidence(station: station, fuel: fuel, baseline: baseline, now: now) != .ineligible
-    }
-
-    /// Ranks the whole station pool by valid full-precision savings. Stations
-    /// with an ineligible price stay visible behind eligible candidates; if
-    /// none qualify, the fallback order is selected-fuel pump price (then id),
-    /// not an untrustworthy savings order. The caller labels the fallback.
+    /// Ranks a whole pool for the Best Value sort.
+    ///
+    /// EVERY priced station in the pool gets an estimate, not just the handful
+    /// whose road routes happen to have been measured: journeys that have no
+    /// measured route fall back to a straight-line out-and-back estimate (see
+    /// `FuelSavingsDistanceBasis`). Capping this to a shortlist dropped cheaper
+    /// stations that were a few miles further away — the exact stations the
+    /// sort exists to surface — and left later pages with no savings at all.
     static func ranked(_ stations: [FuelStation],
                        fuel: FuelType,
                        baseline: FuelStation?,
                        settings: FuelSavingsSettings,
                        amount: FuelSavingsFillAmount,
-                       journeyMiles: (FuelStation) -> FuelSavingsJourney?,
-                       now: Date = Date()) -> [FuelStation] {
+                       journeyMiles: (FuelStation) -> FuelSavingsJourney?) -> [FuelStation] {
         var journeys: [String: FuelSavingsJourney] = [:]
         journeys.reserveCapacity(stations.count)
         for station in stations {
@@ -611,21 +595,11 @@ enum FuelSavingsEstimator {
                 journeys[station.id] = journey
             }
         }
+        // The baseline is normally in the pool, so this is the same lookup it has
+        // always been; asking for its journey directly covers the case where the
+        // list being ranked is filtered tighter than the baseline was chosen from,
+        // which would otherwise mark every row unavailable.
         let baselineJourney = baseline.flatMap { journeys[$0.id] ?? journeyMiles($0) }
-        let hasEligibleComparison = stations.contains {
-            recommendationEligible(station: $0, fuel: fuel, baseline: baseline, now: now)
-        }
-        if !hasEligibleComparison {
-            // A net-savings order cannot be offered without trustworthy price
-            // evidence. Keep every station visible in an explicit price order;
-            // the caller labels the fallback as unavailable.
-            return stations.sorted { lhs, rhs in
-                let left = lhs.prices[fuel] ?? .infinity
-                let right = rhs.prices[fuel] ?? .infinity
-                if left != right { return left < right }
-                return lhs.id < rhs.id
-            }
-        }
         let ranked = stations.map { station -> FuelSavingsRankedStation in
             let journey = journeys[station.id]
             let availability = availability(station: station,
@@ -648,17 +622,7 @@ enum FuelSavingsEstimator {
                 order[rankedStation.stationID] = offset
             }
         }
-        // Compute freshness once per station, never in the O(n log n)
-        // comparator over the full UK pool.
-        var eligibility: [String: Bool] = [:]
-        eligibility.reserveCapacity(stations.count)
-        for station in stations {
-            eligibility[station.id] = recommendationEligible(station: station, fuel: fuel, baseline: baseline, now: now)
-        }
         return stations.sorted { lhs, rhs in
-            let leftEligible = eligibility[lhs.id] ?? false
-            let rightEligible = eligibility[rhs.id] ?? false
-            if leftEligible != rightEligible { return leftEligible }
             let left = order[lhs.id] ?? Int.max
             let right = order[rhs.id] ?? Int.max
             if left != right { return left < right }
diff --git a/Shared/FuelStore.swift b/Shared/FuelStore.swift
index e6b4873..2edb484 100644
--- a/Shared/FuelStore.swift
+++ b/Shared/FuelStore.swift
@@ -273,20 +273,13 @@ struct FuelStation: Identifiable, Codable, Equatable {
     let lng: Double
     /// Price per fuel type in pence per litre. Missing type = station doesn't sell it.
     let prices: [FuelType: Double]
-    /// Updated timestamp (seconds since 1970) — nil for sample data.
+    /// Station-level price timestamp (seconds since 1970): the relay's
+    /// `price_updated`, i.e. the newest price submission across the grades it
+    /// maps — never a per-grade time. nil when the source omits it (sample data).
     let priceUpdated: TimeInterval?
-    /// Per-grade timestamps when the source provides them. A station-wide
-    /// `price_updated` must not be copied into this map: it does not prove that
-    /// every grade changed at that time.
-    let priceUpdatedByFuel: [FuelType: TimeInterval]?
-    /// Original per-grade timestamp text, retained so malformed source values
-    /// cannot silently fall back to a station-wide timestamp.
-    let priceUpdatedByFuelRaw: [FuelType: String]?
-
     init(id: String, name: String, brand: String, address: String, postcode: String,
          lat: Double, lng: Double, prices: [FuelType: Double],
-         priceUpdated: TimeInterval?, priceUpdatedByFuel: [FuelType: TimeInterval]? = nil,
-         priceUpdatedByFuelRaw: [FuelType: String]? = nil) {
+         priceUpdated: TimeInterval?) {
         self.id = id
         self.name = name
         self.brand = brand
@@ -296,18 +289,12 @@ struct FuelStation: Identifiable, Codable, Equatable {
         self.lng = lng
         self.prices = prices
         self.priceUpdated = priceUpdated
-        self.priceUpdatedByFuel = priceUpdatedByFuel
-        self.priceUpdatedByFuelRaw = priceUpdatedByFuelRaw
     }
 
     private enum CodingKeys: String, CodingKey {
         case id, name, brand, address, postcode, lat, lng, prices
         case priceUpdated = "priceUpdated"
         case priceUpdatedSnake = "price_updated"
-        case priceUpdatedByFuel = "priceUpdatedByFuel"
-        case priceUpdatedByFuelSnake = "price_updated_by_fuel"
-        case priceUpdatedByFuelRaw = "priceUpdatedByFuelRaw"
-        case priceUpdatedByFuelRawSnake = "price_updated_by_fuel_raw"
     }
 
     init(from decoder: Decoder) throws {
@@ -322,10 +309,6 @@ struct FuelStation: Identifiable, Codable, Equatable {
         prices = try values.decode([FuelType: Double].self, forKey: .prices)
         priceUpdated = try values.decodeIfPresent(TimeInterval.self, forKey: .priceUpdated)
             ?? values.decodeIfPresent(TimeInterval.self, forKey: .priceUpdatedSnake)
-        priceUpdatedByFuel = try values.decodeIfPresent([FuelType: TimeInterval].self, forKey: .priceUpdatedByFuel)
-            ?? values.decodeIfPresent([FuelType: TimeInterval].self, forKey: .priceUpdatedByFuelSnake)
-        priceUpdatedByFuelRaw = try values.decodeIfPresent([FuelType: String].self, forKey: .priceUpdatedByFuelRaw)
-            ?? values.decodeIfPresent([FuelType: String].self, forKey: .priceUpdatedByFuelRawSnake)
     }
 
     func encode(to encoder: Encoder) throws {
@@ -339,8 +322,6 @@ struct FuelStation: Identifiable, Codable, Equatable {
         try values.encode(lng, forKey: .lng)
         try values.encode(prices, forKey: .prices)
         try values.encodeIfPresent(priceUpdated, forKey: .priceUpdated)
-        try values.encodeIfPresent(priceUpdatedByFuel, forKey: .priceUpdatedByFuel)
-        try values.encodeIfPresent(priceUpdatedByFuelRaw, forKey: .priceUpdatedByFuelRaw)
     }
 
     /// Cheap haversine distance to a location, in km.