@@ -8,6 +8,21 @@ All notable changes to this project are documented here. Format follows
 
 ### Added
 
+- **A consumption model for a car that publishes no battery power — which is this car.**
+  `CarPropertyEvidence` has recorded since 2026-09-04 that SWI68 never publishes battery power:
+  three diagnostic bundles, 51 samples, zero readings. The consequence was that the kWh model
+  could never train on it, and three finished screens stayed blank. `SocConsumptionModel` fits
+  the same shape — rolling plus aero times speed squared plus a thermal term — in **percent of
+  charge per 100 km**, from the state of charge the car does publish and the distance the speed
+  integral already gives. No pack capacity enters it, which matters because the capacity here is
+  a specification sheet rather than a measurement: fitting in percent removes an unmeasured
+  multiplier from every number instead of carrying it. Training points are whole segments of
+  road, accumulated until the charge has moved by two points, because a state of charge read
+  sample by sample is quantisation and a fit built on it would be fitting the quantiser. A hole
+  in the track ends a segment rather than being driven through, a distance recorded under a
+  conversion no longer believed contributes nothing, and a history that has only seen one
+  temperature fits two coefficients instead of inventing a third.
+
 - **The col between here and there costs charge, and the forecast knows it.** CP-031 refused a
   grade source on good grounds — no vehicle signal, no proven barometric reference, and
   power-derived grade is circular — but every candidate it weighed described the road *behind*
 
@@ -16,14 +16,26 @@ data class EnergyModelEnvelope(
 ) {
     fun contains(speedKmh: Double, outsideTempCelsius: Double): Boolean =
         speedKmh.isFinite() && outsideTempCelsius.isFinite() &&
-            speedKmh in minSpeedKmh..maxSpeedKmh &&
-            outsideTempCelsius in minOutsideTempCelsius..maxOutsideTempCelsius
+            speedKmh in (minSpeedKmh - EDGE_TOLERANCE)..(maxSpeedKmh + EDGE_TOLERANCE) &&
+            outsideTempCelsius in
+            (minOutsideTempCelsius - EDGE_TOLERANCE)..(maxOutsideTempCelsius + EDGE_TOLERANCE)
 
     internal fun isValid(): Boolean =
         minSpeedKmh.isFinite() && maxSpeedKmh.isFinite() && minSpeedKmh > 0.0 &&
             minSpeedKmh <= maxSpeedKmh &&
             minOutsideTempCelsius.isFinite() && maxOutsideTempCelsius.isFinite() &&
             minOutsideTempCelsius <= maxOutsideTempCelsius
+
+    private companion object {
+        /**
+         * The bounds are means of measured intervals, so an edge lands on 90.000000000000011
+         * rather than on 90. Refusing to predict the very speed the fit was trained on, by a
+         * ten-thousandth of a millionth of a km/h, is a floating-point artifact and not a
+         * statement about what the model knows. A micro-degree and a micro-km/h are nothing
+         * physically; anything wider would be a claim.
+         */
+        const val EDGE_TOLERANCE = 1e-6
+    }
 }
 
 /**
 
@@ -40,7 +40,7 @@ class EnergyModelTrainer(
         trips: List<StoredTrip>,
         evidence: BatteryPowerEvidence,
     ): EnergyModelTrainingResult {
-        val equations = NormalEquations()
+        val equations = LeastSquares3()
         var minSpeed = Double.POSITIVE_INFINITY
         var maxSpeed = Double.NEGATIVE_INFINITY
         var minTemp = Double.POSITIVE_INFINITY
@@ -124,61 +124,6 @@ class EnergyModelTrainer(
         return accepted
     }
 
-    private class NormalEquations {
-        private val matrix = Array(FEATURES) { DoubleArray(FEATURES) }
-        private val vector = DoubleArray(FEATURES)
-
-        fun add(speedKmh: Double, outsideTempCelsius: Double, consumption: Double) {
-            val speedSquared = speedKmh * speedKmh
-            val temperatureOffset = abs(outsideTempCelsius - EnergyModel.COMFORT_TEMP_CELSIUS)
-            for (row in 0 until FEATURES) {
-                val rowValue = feature(row, speedSquared, temperatureOffset)
-                vector[row] += rowValue * consumption
-                for (column in 0 until FEATURES) {
-                    matrix[row][column] += rowValue *
-                        feature(column, speedSquared, temperatureOffset)
-                }
-            }
-        }
-
-        private fun feature(index: Int, speedSquared: Double, temperatureOffset: Double) =
-            when (index) {
-                0 -> 1.0
-                1 -> speedSquared
-                else -> temperatureOffset
-            }
-
-        fun solve(): DoubleArray? {
-            val augmented = Array(FEATURES) { row ->
-                DoubleArray(FEATURES + 1) { column ->
-                    if (column == FEATURES) vector[row] else matrix[row][column]
-                }
-            }
-            for (column in 0 until FEATURES) {
-                val pivot = (column until FEATURES).maxBy { abs(augmented[it][column]) }
-                if (abs(augmented[pivot][column]) < MIN_PIVOT) return null
-                val swap = augmented[column]
-                augmented[column] = augmented[pivot]
-                augmented[pivot] = swap
-                val divisor = augmented[column][column]
-                for (index in column..FEATURES) augmented[column][index] /= divisor
-                for (row in 0 until FEATURES) {
-                    if (row == column) continue
-                    val factor = augmented[row][column]
-                    for (index in column..FEATURES) {
-                        augmented[row][index] -= factor * augmented[column][index]
-                    }
-                }
-            }
-            return DoubleArray(FEATURES) { augmented[it][FEATURES] }
-        }
-
-        companion object {
-            private const val FEATURES = 3
-            private const val MIN_PIVOT = 1e-9
-        }
-    }
-
     companion object {
         const val MIN_TRAINING_SAMPLES = 60
         const val MAX_TRAINING_SAMPLES = 50_000
 
@@ -0,0 +1,80 @@
+package com.evsuite.hardware.telemetry.model
+
+import kotlin.math.abs
+
+/**
+ * The three-coefficient normal-equations fit both consumption models are built on.
+ *
+ * `constant + a × speed² + b × |outside − comfort|` is the same shape whether the left-hand
+ * side is kWh per 100 km or percent of charge per 100 km, and the arithmetic that solves it
+ * has no opinion about units. It lives here so there is one of it: a second copy would drift
+ * from this one on the day someone fixes a pivot and only remembers one file.
+ *
+ * O(1) working memory, O(n) in samples. Call from a worker thread.
+ */
+internal class LeastSquares3(private val features: Int = FEATURES) {
+    private val matrix = Array(features) { DoubleArray(features) }
+    private val vector = DoubleArray(features)
+
+    init {
+        require(features in 2..FEATURES) { "two or three features" }
+    }
+
+    fun add(speedKmh: Double, outsideTempCelsius: Double, consumption: Double) {
+        val speedSquared = speedKmh * speedKmh
+        val temperatureOffset = abs(outsideTempCelsius - EnergyModel.COMFORT_TEMP_CELSIUS)
+        for (row in 0 until features) {
+            val rowValue = feature(row, speedSquared, temperatureOffset)
+            vector[row] += rowValue * consumption
+            for (column in 0 until features) {
+                matrix[row][column] += rowValue *
+                    feature(column, speedSquared, temperatureOffset)
+            }
+        }
+    }
+
+    private fun feature(index: Int, speedSquared: Double, temperatureOffset: Double) =
+        when (index) {
+            0 -> 1.0
+            1 -> speedSquared
+            else -> temperatureOffset
+        }
+
+    /**
+     * The coefficients, or null when the points do not determine them.
+     *
+     * Two features is not a lesser fit, it is a different claim: a driver who has only ever
+     * recorded trips at one outside temperature has no evidence about temperature, and a
+     * thermal coefficient invented from that would be read as knowledge. The envelope keeps
+     * the narrow range, so such a model refuses the cold rather than guessing at it.
+     */
+    fun solve(): DoubleArray? {
+        val augmented = Array(features) { row ->
+            DoubleArray(features + 1) { column ->
+                if (column == features) vector[row] else matrix[row][column]
+            }
+        }
+        for (column in 0 until features) {
+            val pivot = (column until features).maxBy { abs(augmented[it][column]) }
+            if (abs(augmented[pivot][column]) < MIN_PIVOT) return null
+            val swap = augmented[column]
+            augmented[column] = augmented[pivot]
+            augmented[pivot] = swap
+            val divisor = augmented[column][column]
+            for (index in column..features) augmented[column][index] /= divisor
+            for (row in 0 until features) {
+                if (row == column) continue
+                val factor = augmented[row][column]
+                for (index in column..features) {
+                    augmented[row][index] -= factor * augmented[column][index]
+                }
+            }
+        }
+        return DoubleArray(features) { augmented[it][features] }
+    }
+
+    private companion object {
+        const val FEATURES = 3
+        const val MIN_PIVOT = 1e-9
+    }
+}