@@ -103,6 +103,11 @@ object EnergyProbe {
         // ── Distance ────────────────────────────────────────────────────────
         Signal("Odomètre AOSP", 0x11600204, null),
         Signal("Kilométrage total SAIC", 0x21401566, null),
+        // Candidats à un odomètre plus fin que le kilomètre entier : le premier est dans la liste
+        // énumérée par le gestionnaire BMS, les deux autres viennent du combiné.
+        Signal("Odomètre BMS", 0x2140f447, BMS_SERVICE, validity = 0x2120f448),
+        Signal("Odomètre combiné", 0x21407b13, null),
+        Signal("Trajet combiné : départ", 0x21407b86, null),
         Signal("Trajet combiné : distance", 0x21407b81, null),
         Signal("Trajet combiné : vitesse moyenne", 0x21407b80, null),
         Signal("Trajet combiné : conso moyenne", 0x21407b82, null),
 
@@ -13,6 +13,13 @@ data class Trip(
     val startMs: Long,
     val endMs: Long,
     val distanceKm: Int,
+    /**
+     * Énergie **brute** relevée sur le compteur du véhicule : la régénération n'en est PAS déduite.
+     *
+     * Vérifié le 2026-09-20 en comparant avec l'écran d'origine — la voiture affichait 14,1
+     * kWh/100 km là où ce compteur donnait 17,1 sur la même distance, l'écart valant exactement la
+     * régénération. C'est donc [netEnergyKwh] qu'il faut montrer et facturer.
+     */
     val energyKwh: Float,
     val climateKwh: Float?,
     val accessoriesKwh: Float?,
@@ -23,6 +30,15 @@ data class Trip(
 ) {
     val durationMs: Long get() = max(0L, endMs - startMs)
 
+    /**
+     * Énergie réellement sortie de la batterie : brute moins ce que la régénération a rendu.
+     *
+     * C'est la convention de tout le monde — la voiture elle-même, Tesla, les planificateurs — et
+     * c'est la seule qui ait un sens pour le coût : on ne recharge que ce qu'on a vraiment dépensé.
+     */
+    val netEnergyKwh: Float
+        get() = (energyKwh - (regenKwh ?: 0f)).coerceAtLeast(0f).roundTenth()
+
     /**
      * Consommation moyenne en kWh/100 km, **null sous la distance plancher**.
      *
@@ -32,7 +48,7 @@ data class Trip(
      */
     val consumptionPer100: Float?
         get() = if (distanceKm >= MIN_DISTANCE_FOR_RATIO_KM && distanceKm > 0)
-            energyKwh * 100f / distanceKm else null
+            netEnergyKwh * 100f / distanceKm else null
 
     /**
      * Énergie du moteur : ce qui reste du total une fois la climatisation et les accessoires
@@ -45,6 +61,7 @@ data class Trip(
     val motorKwh: Float?
         get() {
             if (climateKwh == null && accessoriesKwh == null) return null
+            // Sur le BRUT : moteur + climatisation + accessoires − régénération = énergie nette.
             val reste = energyKwh - (climateKwh ?: 0f) - (accessoriesKwh ?: 0f)
             return reste.coerceAtLeast(0f).roundTenth()
         }
 
@@ -51,7 +51,9 @@ data class StatsSummary(
             val chargeCost = charges.sumOf { (it.cost(settings) ?: 0f).toDouble() }.toFloat()
             // Prix moyen réel : une session corrigée à la main tire donc la moyenne avec elle.
             val prixMoyen = if (chargedKwh > 0f) chargeCost / chargedKwh else null
-            val energie = trips.sumOf { it.energyKwh.toDouble() }.toFloat()
+            // Net, comme l'affichage d'origine : le compteur du véhicule est brut, régénération
+            // comprise. Voir [Trip.energyKwh].
+            val energie = trips.sumOf { it.netEnergyKwh.toDouble() }.toFloat()
             return StatsSummary(
                 tripCount = trips.size,
                 distanceKm = trips.sumOf { it.distanceKm },
 
@@ -231,7 +231,7 @@ class StatsFragment : Fragment() {
                 value1 = trip.consumptionPer100?.let { fmt(it) + " " + getString(R.string.stats_unit_per100) } ?: "—",
                 value2 = listOfNotNull(
                     trip.averageSpeedKmh?.let { "${it.toInt()} km/h" },
-                    kwh(trip.energyKwh),
+                    kwh(trip.netEnergyKwh),
                 ).joinToString(" · "),
                 onClick = { expanded = if (expanded == trip.startMs) null else trip.startMs; render() }))
             if (expanded == trip.startMs) list.addView(tripDetail(ctx, trip))
@@ -292,7 +292,9 @@ class StatsFragment : Fragment() {
         trip.motorKwh?.let { getString(R.string.stats_detail_motor) to kwh(it) },
         trip.climateKwh?.let { getString(R.string.stats_detail_climate) to kwh(it) },
         trip.accessoriesKwh?.let { getString(R.string.stats_detail_accessories) to kwh(it) },
-        trip.regenKwh?.let { getString(R.string.stats_detail_regen) to "+ ${kwh(it)}" },
+        // Signe négatif : dans un détail de consommation, la régénération RETRANCHE. Moteur +
+        // climatisation + accessoires − récupération donne bien le total affiché sur la ligne.
+        trip.regenKwh?.let { getString(R.string.stats_detail_regen) to "− ${kwh(it)}" },
         // Sous la distance plancher on dit POURQUOI il n'y a pas de ratio, plutôt qu'un tiret muet.
         getString(R.string.stats_detail_consumption) to (trip.consumptionPer100
             ?.let { fmt(it) + " " + getString(R.string.stats_unit_per100) }
@@ -586,10 +588,15 @@ class StatsFragment : Fragment() {
     private fun money(value: Float?, s: StatsSettings): String =
         value?.let { "${fmt(it)} ${s.currency}" } ?: "—"
 
+    /**
+     * Le véhicule publie le pourcentage au dixième (69,4 et non 69) : l'arrondir à l'entier jetait
+     * une précision déjà acquise, et rendait invérifiable un trajet court — 1 % vaut plus d'un demi
+     * kilowattheure sur cette batterie.
+     */
     private fun soc(start: Float?, end: Float?): String? {
         if (start == null && end == null) return null
-        val a = start?.let { "${it.toInt()} %" } ?: "?"
-        val b = end?.let { "${it.toInt()} %" } ?: "?"
+        val a = start?.let { "${fmt(it)} %" } ?: "?"
+        val b = end?.let { "${fmt(it)} %" } ?: "?"
         return "$a → $b"
     }
 
 
@@ -16,14 +16,14 @@ class StatsSummaryTest {
 
     private val settings = StatsSettings(priceAc = 0.2f, priceDc = 0.5f, capacityKwh = 60f)
 
-    private fun trip(km: Int, kwh: Float, dureeMin: Long = 30) = Trip(
+    private fun trip(km: Int, kwh: Float, dureeMin: Long = 30, regen: Float = 0f) = Trip(
         startMs = 0L,
         endMs = dureeMin * 60_000L,
         distanceKm = km,
         energyKwh = kwh,
         climateKwh = null,
         accessoriesKwh = null,
-        regenKwh = 1f,
+        regenKwh = regen,
         socStart = null,
         socEnd = null,
         outsideTempC = null,
@@ -57,6 +57,15 @@ class StatsSummaryTest {
         assertNull(sum.costPer100)
     }
 
+    @Test
+    fun `le resume compte l'energie NETTE des trajets`() {
+        // Le compteur du véhicule est brut : 20 kWh dont 4 rendus par la régénération font 16 nets.
+        val sum = StatsSummary.of(listOf(trip(100, 20f, regen = 4f)), emptyList(), settings)
+        assertEquals(16f, sum.energyKwh, 0.01f)
+        assertEquals(16f, sum.consumptionPer100!!, 0.01f)
+        assertEquals("la régénération reste affichée à part", 4f, sum.regenKwh, 0.01f)
+    }
+
     @Test
     fun `le prix moyen suit l'energie reellement rechargee`() {
         val sum = StatsSummary.of(
 
@@ -52,6 +52,24 @@ class TripTest {
         assertEquals(0f, trip(kwh = 0.4f, clim = 0.5f, accessoires = 0.5f).motorKwh!!, 0.01f)
     }
 
+    @Test
+    fun `l'energie nette retranche la regeneration`() {
+        val t = Trip(
+            startMs = 0L, endMs = 2_040_000L, distanceKm = 34, energyKwh = 5.8f,
+            climateKwh = 0f, accessoriesKwh = 0.1f, regenKwh = 1f,
+            socStart = 69f, socEnd = 60f, outsideTempC = 25f,
+        )
+        assertEquals(4.8f, t.netEnergyKwh, 0.01f)
+        // Relevé réel du 2026-09-20 : la voiture affichait 14,1 kWh/100 km sur ce trajet, quand le
+        // compteur brut donnait 17,1. Notre calcul doit tomber du côté de la voiture.
+        assertEquals(14.1f, t.consumptionPer100!!, 0.4f)
+    }
+
+    @Test
+    fun `sans regeneration connue le net vaut le brut`() {
+        assertEquals(20f, trip(kwh = 20f).netEnergyKwh, 0.01f)
+    }
+
     @Test
     fun `sous cinq kilometres aucun ratio n'est annonce`() {
         val court = trip(km = 2, kwh = 0.4f)
@@ -63,4 +81,14 @@ class TripTest {
     fun `au dela du plancher la consommation se calcule`() {
         assertEquals(20f, trip(km = 100, kwh = 20f).consumptionPer100!!, 0.01f)
     }
+
+    @Test
+    fun `la consommation suit le net, pas le brut`() {
+        val t = Trip(
+            startMs = 0L, endMs = 3_600_000L, distanceKm = 100, energyKwh = 20f,
+            climateKwh = null, accessoriesKwh = null, regenKwh = 4f,
+            socStart = null, socEnd = null, outsideTempC = null,
+        )
+        assertEquals(16f, t.consumptionPer100!!, 0.01f)
+    }
 }