fix(metrics): min/max/avg pills work for every metric, not just the legacy 6

The dashboard pills resolved stats from a hardcoded when(key) covering only
battery/temp/voltage/current/load/speed, and the dashboard MetricHistory dropped
the generic extras buffer - so Max Power, Max GPS Speed, AVG etc. showed "--"
even when the data existed. Now the pills fall back to the extras buffer and
format it with the same unit conversion as the detail screen, and the sampler
allocates a buffer for every supportsStats catalog key. Location/phone-derived
metrics (GPS_SPEED, GPS_ALTITUDE, GPS_ACCURACY, PHONE_BATTERY, EXTERNAL_GPS_
BATTERY) are sampled each tick from their sources (Lazy<TripRepository> avoids
the DI cycle). Drift-guard test asserts every supportsStats key has a buffer.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GADLyChheAoMX9dQbRgRnH

Author: eried

app/src/main/java/com/eried/eucplanet/data/repository/WheelRepository.kt

@@ -135,6 +135,41 @@ internal val EXTRA_HISTORY_METRICS: List<Pair<String, (com.eried.eucplanet.data.
     "TIRE_PRESSURE" to { it.tirePressureKpa }
 )
 
+/**
+ * The six metrics with their own typed buffer on [FullMetricHistory]. Every
+ * OTHER supportsStats catalog metric rides in the keyed extras map instead.
+ */
+internal val LEGACY_STAT_METRIC_KEYS: List<String> =
+    listOf("BATTERY", "TEMPERATURE", "VOLTAGE", "CURRENT", "LOAD", "SPEED")
+
+/**
+ * Stat metrics that are NOT on WheelData: they come from the phone location,
+ * the phone battery, or the paired external GPS box. Sampled from those
+ * injected sources on the same 1 Hz history tick as the wheel metrics.
+ * Stored raw so [computeDashboardStatValue] and the tile formatter agree:
+ * GPS_SPEED in km/h, altitude / accuracy in metres, batteries in percent.
+ */
+internal val SOURCE_HISTORY_METRIC_KEYS: List<String> =
+    listOf("GPS_SPEED", "GPS_ALTITUDE", "GPS_ACCURACY", "PHONE_BATTERY", "EXTERNAL_GPS_BATTERY")
+
+/**
+ * Every catalog key with supportsStats = true that isn't a legacy typed
+ * buffer gets an extras buffer, so min / max / avg / last resolve for it on
+ * the dashboard. Wheel-sourced keys fill from [EXTRA_HISTORY_METRICS], the
+ * phone / GPS keys from [SOURCE_HISTORY_METRIC_KEYS]. Any remaining stat
+ * metric with no live source yet still gets an (empty) buffer, so its pill
+ * shows a stable placeholder instead of silently having no stat path. Driven
+ * off the catalog so a new supportsStats metric can't regress unnoticed.
+ */
+internal val STAT_BUFFER_EXTRA_KEYS: List<String> =
+    (EXTRA_HISTORY_METRICS.map { it.first } +
+        SOURCE_HISTORY_METRIC_KEYS +
+        com.eried.eucplanet.data.model.MetricCatalog.all
+            .filter { it.supportsStats }
+            .map { it.key })
+        .distinct()
+        .filter { it !in LEGACY_STAT_METRIC_KEYS }
+
 @Singleton
 class WheelRepository @Inject constructor(
     @ApplicationContext private val context: Context,
@@ -148,6 +183,11 @@ class WheelRepository @Inject constructor(
     private val cheatState: com.eried.eucplanet.cheats.CheatState,
     private val phoneSensorRepository: PhoneSensorRepository,
     private val externalGpsRepository: ExternalGpsRepository,
+    // Lazy breaks the Hilt dependency cycle: TripRepository injects this
+    // repository, so a direct TripRepository here would be circular. Only
+    // read on the history tick to sample GPS_SPEED / GPS_ALTITUDE /
+    // GPS_ACCURACY from the current location fix.
+    private val tripRepositoryLazy: dagger.Lazy<TripRepository>,
     private val appNotifier: com.eried.eucplanet.util.AppNotifier
 ) {
     companion object {
@@ -342,11 +382,12 @@ class WheelRepository @Inject constructor(
     private val ampsHist = mutableListOf<MetricSample>()
     private val loadHist = mutableListOf<MetricSample>()
     private val speedHist = mutableListOf<MetricSample>()
-    // One buffer per entry in EXTRA_HISTORY_METRICS. Keys mirror the
-    // catalog so the metric-detail screen can fish the right list out
-    // by name without a hard-coded switch per metric.
+    // One buffer per non-legacy stat metric (wheel-sourced, phone / GPS
+    // sourced, plus any not-yet-sourced supportsStats key). Keys mirror the
+    // catalog so the metric-detail screen and the dashboard corner stats can
+    // fish the right list out by name without a hard-coded switch per metric.
     private val extrasHist: MutableMap<String, MutableList<MetricSample>> =
-        EXTRA_HISTORY_METRICS.associate { (key, _) -> key to mutableListOf<MetricSample>() }
+        STAT_BUFFER_EXTRA_KEYS.associateWith { mutableListOf<MetricSample>() }
             .toMutableMap()
     private var lastHistorySampleMs = 0L
 
@@ -384,6 +425,35 @@ class WheelRepository @Inject constructor(
         _fullHistory.value = FullMetricHistory()
     }
 
+    /**
+     * Appends one sample to each phone- / GPS-derived stat buffer
+     * ([SOURCE_HISTORY_METRIC_KEYS]) from its injected source. Called on the
+     * wheel history tick so these metrics share the legacy buffers' timeline
+     * and retention. A source with no fresh value this tick simply skips its
+     * append (the buffer holds its last window of good samples). Wrapped so a
+     * transient source read can never break the telemetry path.
+     */
+    private fun sampleSourceHistory(now: Long) {
+        runCatching {
+            val loc = tripRepositoryLazy.get().currentLocation.value
+            if (loc != null) {
+                if (loc.hasSpeed()) extrasHist["GPS_SPEED"]?.add(MetricSample(now, loc.speed * 3.6f))
+                if (loc.hasAltitude()) extrasHist["GPS_ALTITUDE"]?.add(MetricSample(now, loc.altitude.toFloat()))
+                if (loc.hasAccuracy()) extrasHist["GPS_ACCURACY"]?.add(MetricSample(now, loc.accuracy))
+            }
+            // Phone battery: cheap in-memory system read, fine at 1 Hz.
+            val phonePct = (context.getSystemService(Context.BATTERY_SERVICE) as? android.os.BatteryManager)
+                ?.getIntProperty(android.os.BatteryManager.BATTERY_PROPERTY_CAPACITY) ?: -1
+            if (phonePct in 0..100) extrasHist["PHONE_BATTERY"]?.add(MetricSample(now, phonePct.toFloat()))
+            // External GPS box battery, freshness-gated to 5 s like the dashboard tile.
+            val ext = externalGpsRepository.currentSample.value
+            val extPct = ext?.batteryPercent
+            if (extPct != null && now - ext.timestamp < 5_000L) {
+                extrasHist["EXTERNAL_GPS_BATTERY"]?.add(MetricSample(now, extPct.toFloat()))
+            }
+        }
+    }
+
     // Auth state for lock/unlock (V14 requires password verification)
     private var authKey: ByteArray? = null
     private var pendingAuthKeyDeferred: CompletableDeferred<ByteArray>? = null
@@ -1647,6 +1717,12 @@ class WheelRepository @Inject constructor(
                     for ((key, extractor) in EXTRA_HISTORY_METRICS) {
                         extrasHist[key]?.add(MetricSample(now, extractor(d)))
                     }
+                    // Phone- and GPS-derived stat metrics aren't on WheelData,
+                    // so sample them from their injected sources on this same
+                    // tick. Store raw values (km/h, metres, percent) so the
+                    // stat math and the tile formatter agree, exactly like the
+                    // wheel extras above.
+                    sampleSourceHistory(now)
                     // Drop anything older than the 5-min window from every
                     // buffer in one pass. List.removeAll touches each list
                     // once so this stays linear in buffer size.

app/src/main/java/com/eried/eucplanet/ui/dashboard/DashboardScreen.kt

@@ -179,6 +179,52 @@ private fun openMediaGallery(context: Context, video: Boolean, onNoGalleryApp: (
     runCatching { context.startActivity(intent) }.onFailure { onNoGalleryApp() }
 }
 
+/**
+ * Formats a RAW buffered stat value (WheelData canonical units) into the
+ * compact string a dashboard corner chip or composite cell shows, applying
+ * the rider's unit conversion so a MAX / AVG chip reads in the same units as
+ * the live tile. Mirrors displayValueFor's per-key formatting and the
+ * MetricDetailScreen conversions. Any key without a dedicated unit falls back
+ * to one decimal. Shared by the standalone-tile corner stats and the
+ * composite cell renderer so both agree.
+ */
+private fun formatMetricStatValue(
+    key: String,
+    raw: Float,
+    speedUnit: String,
+    speedUnitLabel: String,
+    tempUnit: String,
+    tempUnitLabel: String,
+    distanceUnit: String
+): String = when (key) {
+    "BATTERY", "LOAD" -> "${raw.toInt()}%"
+    "BATTERY_1", "BATTERY_2", "PHONE_BATTERY", "EXTERNAL_GPS_BATTERY" -> "%.0f%%".format(raw)
+    // Temp buffers store raw °C; convert to the rider's unit like the tile.
+    "TEMPERATURE" -> "${com.eried.eucplanet.util.Units.temperature(raw, tempUnit).toInt()}°"
+    "MOTOR_TEMP", "CONTROLLER_TEMP", "BATTERY_TEMP" ->
+        "%.0f%s".format(com.eried.eucplanet.util.Units.temperature(raw, tempUnit), tempUnitLabel)
+    "VOLTAGE" -> "%.1fV".format(raw)
+    "CURRENT", "DYN_CURRENT_LIMIT" -> "%.1fA".format(raw)
+    // Speed buffers store raw km/h; convert to the rider's speed unit.
+    "SPEED", "DYN_SPEED_LIMIT", "GPS_SPEED" ->
+        "%.0f %s".format(com.eried.eucplanet.util.Units.speed(raw, speedUnit), speedUnitLabel)
+    "MOTOR_POWER", "BATTERY_POWER", "POWER" -> "%.0fW".format(raw)
+    "PITCH", "ROLL" -> "%.1f°".format(raw)
+    "G_FORCE", "LATERAL_G", "FORWARD_G" -> "%.2fg".format(raw)
+    "TORQUE" -> "%.1fNm".format(raw)
+    // Tire pressure stored raw in kPa; psi for imperial-distance, bar otherwise.
+    "TIRE_PRESSURE" -> if (distanceUnit == "mi")
+        "%.1f psi".format(com.eried.eucplanet.util.Units.pressure(raw, "psi"))
+    else
+        "%.2f bar".format(com.eried.eucplanet.util.Units.pressure(raw, "bar"))
+    // Altitude / accuracy stored raw in metres; feet for imperial riders.
+    "GPS_ALTITUDE", "GPS_ACCURACY" -> if (distanceUnit == "mi")
+        "%.0fft".format(raw * 3.28084f)
+    else
+        "%.0fm".format(raw)
+    else -> "%.1f".format(raw)
+}
+
 @OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
 @Composable
 fun DashboardScreen(
@@ -1353,14 +1399,18 @@ fun DashboardScreen(
                 if (stat == com.eried.eucplanet.ui.settings.DashboardStat.NONE ||
                     stat == com.eried.eucplanet.ui.settings.DashboardStat.CURRENT ||
                     stat == com.eried.eucplanet.ui.settings.DashboardStat.EMPTY) return null
+                // Legacy six use their typed lists; every other supportsStats
+                // metric rides in the keyed extras map (POWER, GPS_SPEED,
+                // MOTOR_TEMP, ...). A key with no buffer resolves to an empty
+                // list -> placeholder, same as a cold-boot legacy buffer.
                 val buf = when (key) {
                     "BATTERY" -> history.battery
                     "TEMPERATURE" -> history.temperature
                     "VOLTAGE" -> history.voltage
                     "CURRENT" -> history.current
                     "LOAD" -> history.load
                     "SPEED" -> history.speed
-                    else -> return placeholder
+                    else -> history.extras[key].orEmpty()
                 }
                 if (buf.isEmpty()) return placeholder
                 val samples = buf.mapIndexed { idx, v ->
@@ -1369,20 +1419,9 @@ fun DashboardScreen(
                 val raw = com.eried.eucplanet.ui.settings.computeDashboardStatValue(
                     stat, samples, fallbackCurrent = buf.last()
                 ) ?: return placeholder
-                return when (key) {
-                    "BATTERY", "LOAD" -> "${raw.toInt()}%"
-                    // Buffers store raw °C / km/h, so the corner stat must run
-                    // the same unit conversion as the tile value or imperial
-                    // riders see metric numbers under an imperial label.
-                    "TEMPERATURE" -> "${com.eried.eucplanet.util.Units.temperature(raw, tempUnit).toInt()}°"
-                    "VOLTAGE" -> "%.1fV".format(raw)
-                    "CURRENT" -> "%.1fA".format(raw)
-                    "SPEED" -> "%.0f %s".format(
-                        com.eried.eucplanet.util.Units.speed(raw, speedUnit),
-                        speedUnitLabel
-                    )
-                    else -> "%.1f".format(raw)
-                }
+                return formatMetricStatValue(
+                    key, raw, speedUnit, speedUnitLabel, tempUnit, tempUnitLabel, distanceUnit
+                )
             }
 
             // Short stat label for the corner chip — "MAX", "MIN", "AVG",
@@ -1841,7 +1880,10 @@ fun DashboardScreen(
                                                 "CURRENT" -> historySnapshot.current
                                                 "LOAD" -> historySnapshot.load
                                                 "SPEED" -> historySnapshot.speed
-                                                else -> emptyList()
+                                                // Any other supportsStats cell
+                                                // (POWER, GPS_SPEED, MOTOR_TEMP,
+                                                // ...) reads its extras buffer.
+                                                else -> historySnapshot.extras[metricKey].orEmpty()
                                             }
                                             if (buf.size < 2) return@cellRenderer placeholder
                                             val samples = buf.mapIndexed { idx, v ->
@@ -1850,7 +1892,13 @@ fun DashboardScreen(
                                             val value = com.eried.eucplanet.ui.settings.computeDashboardStatValue(
                                                 stat, samples, fallbackCurrent = buf.last()
                                             ) ?: return@cellRenderer placeholder
-                                            "%.1f".format(value)
+                                            // Same unit-correct formatting the
+                                            // standalone corner chip uses so a
+                                            // composite MAX/AVG cell reads right.
+                                            formatMetricStatValue(
+                                                metricKey, value, speedUnit, speedUnitLabel,
+                                                tempUnit, tempUnitLabel, distanceUnit
+                                            )
                                         }
                                     // A composite always occupies one standard slot
                                     // (61 dp), exactly like every other dashboard tile.
@@ -1995,7 +2043,10 @@ fun DashboardScreen(
                                         },
                                         value = centerOverride ?: displayValueFor(key),
                                         accent = spec?.accent?.let { MaterialTheme.appColors.remap(it) } ?: primary,
-                                        sparkData = emptyList(),
+                                        // Generic tiles now get a sparkline too, from
+                                        // the metric's extras buffer (empty until the
+                                        // first sample or for unsourced metrics).
+                                        sparkData = history.extras[key].orEmpty(),
                                         sparkStyle = spec?.sparkline ?: SparklineStyle.NONE,
                                         sparklineEnabled = sparklineEnabled,
                                         bipolarBaseline = spec?.bipolarBaseline ?: 0f,

app/src/main/java/com/eried/eucplanet/ui/dashboard/DashboardViewModel.kt

@@ -40,7 +40,16 @@ data class MetricHistory(
     val voltage: List<Float> = emptyList(),
     val current: List<Float> = emptyList(),
     val load: List<Float> = emptyList(),
-    val speed: List<Float> = emptyList()
+    val speed: List<Float> = emptyList(),
+    /**
+     * Sparkline / stat window for every non-legacy catalog metric, keyed by
+     * metric key (MOTOR_POWER, GPS_SPEED, MOTOR_TEMP, ...). Mirrors the six
+     * typed lists above but data-driven off [FullMetricHistory.extras], so the
+     * dashboard's corner stats and sparklines work for any supportsStats tile,
+     * not just the legacy six. Values are raw (WheelData canonical units); the
+     * tile applies the rider's unit conversion at render time.
+     */
+    val extras: Map<String, List<Float>> = emptyMap()
 )
 
 @HiltViewModel
@@ -604,7 +613,12 @@ class DashboardViewModel @Inject constructor(
                 voltage = full.voltage.takeLast(SPARKLINE_SIZE).map { it.value },
                 current = full.current.takeLast(SPARKLINE_SIZE).map { it.value },
                 load = full.load.takeLast(SPARKLINE_SIZE).map { it.value },
-                speed = full.speed.takeLast(SPARKLINE_SIZE).map { it.value }
+                speed = full.speed.takeLast(SPARKLINE_SIZE).map { it.value },
+                // Same window as the legacy six, applied per extras buffer so
+                // every catalog metric's corner stats / sparkline resolve.
+                extras = full.extras.mapValues { (_, list) ->
+                    list.takeLast(SPARKLINE_SIZE).map { it.value }
+                }
             )
         }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), MetricHistory())

app/src/test/java/com/eried/eucplanet/data/repository/MetricStatBufferCoverageTest.kt

@@ -0,0 +1,56 @@
+package com.eried.eucplanet.data.repository
+
+import com.eried.eucplanet.data.model.MetricCatalog
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Drift guard (CONVENTIONS rule 13) for the dashboard stat buffers.
+ *
+ * Every catalog metric that advertises supportsStats = true must resolve to a
+ * rolling-history buffer, otherwise its min / max / avg / last pills and its
+ * sparkline have nothing to compute from and render an empty "--". That was
+ * the exact bug this test defends against: POWER / MAX GPS SPEED and friends
+ * showed blank pills because their buffer path was missing.
+ *
+ * The buffer path is either one of the six legacy typed lists on
+ * [FullMetricHistory], or an allocated extras buffer in
+ * [STAT_BUFFER_EXTRA_KEYS]. Since that set is derived from the catalog, a new
+ * supportsStats metric is covered automatically, and any future change that
+ * turns it into a hand-maintained list is caught here.
+ */
+class MetricStatBufferCoverageTest {
+
+    private val statKeys: List<String> =
+        MetricCatalog.all.filter { it.supportsStats }.map { it.key }
+
+    @Test
+    fun everyStatMetricHasABufferPath() {
+        val covered = (LEGACY_STAT_METRIC_KEYS + STAT_BUFFER_EXTRA_KEYS).toSet()
+        val missing = statKeys.filterNot { it in covered }
+        assertTrue(
+            "supportsStats metrics with no history buffer path: $missing",
+            missing.isEmpty()
+        )
+    }
+
+    @Test
+    fun legacyAndExtrasBuffersAreDisjoint() {
+        val overlap = STAT_BUFFER_EXTRA_KEYS.filter { it in LEGACY_STAT_METRIC_KEYS }
+        assertTrue("legacy keys must not also be extras buffers: $overlap", overlap.isEmpty())
+    }
+
+    @Test
+    fun extractorKeysAllHaveAllocatedBuffers() {
+        val wheelKeys = EXTRA_HISTORY_METRICS.map { it.first }
+        val unallocated = (wheelKeys + SOURCE_HISTORY_METRIC_KEYS)
+            .filterNot { it in STAT_BUFFER_EXTRA_KEYS }
+        assertTrue("extractor keys with no allocated buffer: $unallocated", unallocated.isEmpty())
+    }
+
+    @Test
+    fun extrasBufferKeysAreUnique() {
+        assertEquals(STAT_BUFFER_EXTRA_KEYS.size, STAT_BUFFER_EXTRA_KEYS.toSet().size)
+    }
+}