feat(chargepilot): CP-078/CP-079 continuous trip and charge learning

Close the unstable loop: automatic trip retention feeds the trip model,
battery ledger entries refresh charge-session analysis and health
estimates without an activity restart, and stable/unstable default
seams split for eco coach and charge learning.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: malys

README.md

@@ -104,8 +104,10 @@ Automatic detection is enabled by default. A foreground service owns the sampler
 and recording continue when the driver opens another app. On firmware where speed stays
 unavailable, ten consecutive misses suspend idle background polling; opening the dashboard
 performs a bounded retry. Active trips remain fail-closed and under manual control. The unstable
-build keeps automatically detected trips only above 5 km, concentrating the same bounded history
-budget on drives useful to the local consumption model. Manual recordings are always kept. A
+The unstable build keeps every automatically detected trip with a positive trustworthy
+distance. The shared store still caps history at 200 trips and 512 KiB, discarding oldest
+sample tracks before oldest summaries. Each successful save refreshes the local model.
+Manual recordings are always kept.
 trip's reported duration is the time actually covered by usable samples, not wall clock: a suspended
 sampler adds nothing to duration, distance or energy, so consumption averages compare values
 measured over the same interval.
@@ -154,6 +156,9 @@ self-update.
 ## Configuration
 
 Automatic trip detection is enabled by default. Its switch, and the manual start/stop action,
+
+Unstable shows the live eco-advice line by default so a fresh install starts learning without a
+setup step. Stable keeps that line opt-in. Spoken advice remains opt-in in both channels.
 can be changed only while the vehicle reports zero speed. If speed is unavailable, the controls
 fail closed and the dashboard explains why.
 

app/src/main/java/com/evsuite/chargepilot/BatteryHealthActivity.kt

@@ -8,19 +8,13 @@ import android.os.Bundle
 import android.os.IBinder
 import android.view.View
 import com.evsuite.chargepilot.databinding.ActivityBatteryHealthBinding
-import com.evsuite.hardware.telemetry.BatteryExposure
 import com.evsuite.hardware.telemetry.BatteryExposureReport
-import com.evsuite.hardware.telemetry.BatteryLedgerStore
-import com.evsuite.hardware.telemetry.CalibrationDrift
 import com.evsuite.hardware.telemetry.CalibrationDriftReport
 import com.evsuite.hardware.telemetry.CalibrationVerdict
-import com.evsuite.hardware.telemetry.ChargeEnergyAnalyzer
 import com.evsuite.hardware.telemetry.ChargeEnergyReport
 import com.evsuite.hardware.telemetry.SohEnergySource
 import com.evsuite.hardware.telemetry.StateOfHealthEstimate
-import com.evsuite.hardware.telemetry.StateOfHealthEstimator
 import com.evsuite.hardware.telemetry.StateOfHealthResult
-import java.io.File
 import java.util.Locale
 import java.util.concurrent.Executors
 import kotlin.math.abs
@@ -49,6 +43,7 @@ class BatteryHealthActivity : PrimaryNavigationActivity() {
     }
 
     private var recorder: TripRecordingService? = null
+    private var loadedBatteryRevision = -1
     private var bound = false
     private var speedKmh: Float? = null
     private var speedObservedAtMs: Long? = null
@@ -66,9 +61,20 @@ class BatteryHealthActivity : PrimaryNavigationActivity() {
         override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
             val value = (service as? TripRecordingService.LocalBinder)?.service ?: return
             recorder = value
+            if (ChargeLearningDefaults.AUTO_REFRESH) {
+                loadedBatteryRevision = value.batteryRevision
+                load()
+            }
             value.setListener(this@BatteryHealthActivity) { snapshot ->
                 speedKmh = snapshot.speedKmh
                 speedObservedAtMs = snapshot.timestampMs
+                if (
+                    ChargeLearningDefaults.AUTO_REFRESH &&
+                    value.batteryRevision != loadedBatteryRevision
+                ) {
+                    loadedBatteryRevision = value.batteryRevision
+                    load()
+                }
                 renderApply()
             }
             speedKmh = value.latest?.speedKmh
@@ -120,24 +126,18 @@ class BatteryHealthActivity : PrimaryNavigationActivity() {
 
     private fun load() {
         disk.execute {
-            val entries = BatteryLedgerStore(File(filesDir, BatteryLedgerStore.FILE_NAME)).read()
             val settings = VehicleSettings.read(this)
-            val estimate = StateOfHealthEstimator()
-                .estimate(entries, settings.usableCapacityKwhWhenNew)
-            val ready = (estimate as? StateOfHealthResult.Ready)?.estimate
-            val report = CalibrationDrift().analyse(entries, System.currentTimeMillis(), ready)
-            val exposureReport = BatteryExposure().analyse(entries)
-            // The sessions come from the exposure report rather than being cut again here, so
-            // the two blocks on this screen can never disagree about what counts as a charge.
-            val chargeReport = ChargeEnergyAnalyzer()
-                .analyse(entries, exposureReport?.sessions.orEmpty())
+            val learned = LocalBatteryLearning.refresh(
+                filesDir,
+                settings.usableCapacityKwhWhenNew,
+            )
             runOnUiThread {
                 if (isFinishing || isDestroyed) return@runOnUiThread
                 declared = settings
-                health = estimate
-                drift = report
-                exposure = exposureReport
-                charge = chargeReport
+                health = learned.health
+                drift = learned.drift
+                exposure = learned.exposure
+                charge = learned.charge
                 render()
             }
         }

app/src/main/java/com/evsuite/chargepilot/EcoCoach.kt

@@ -9,14 +9,13 @@ import com.evsuite.hardware.telemetry.EcoDrivingMonitor
 import com.evsuite.hardware.telemetry.EcoLever
 import com.evsuite.hardware.telemetry.EcoVerdict
 import com.evsuite.hardware.telemetry.EnergySnapshot
-import com.evsuite.hardware.telemetry.EnergyTripHistoryStore
 import com.evsuite.hardware.telemetry.EnergyTripSession
 import com.evsuite.hardware.telemetry.Provenanced
+import com.evsuite.hardware.telemetry.StoredTrip
 import com.evsuite.hardware.telemetry.UnavailableReason
 import com.evsuite.hardware.telemetry.model.SocConsumptionFitResult
 import com.evsuite.hardware.telemetry.model.SocConsumptionFitter
 import com.evsuite.hardware.telemetry.model.SocConsumptionModel
-import java.io.File
 import kotlin.math.roundToInt
 
 /**
@@ -53,11 +52,8 @@ class EcoCoach(context: Context) {
     private var spokenLine: String? = null
     private var lastSpokeAtMs = 0L
 
-    /** Reads the trip history and fits CP-052's model. Call on a worker thread. */
-    fun load() {
-        val trips = runCatching {
-            EnergyTripHistoryStore(File(app.filesDir, HISTORY_FILE)).read()
-        }.getOrDefault(emptyList())
+    /** Fits CP-052's model from the current bounded history. Call on a worker thread. */
+    fun load(trips: List<StoredTrip>) {
         val fit = SocConsumptionFitter().fit(trips, FirmwareInfo.getGeneration())
         model = (fit as? SocConsumptionFitResult.Ready)?.model
     }
@@ -198,15 +194,14 @@ class EcoCoach(context: Context) {
         private const val SPEAK_COOLDOWN_MS = 120_000L
 
         private const val UTTERANCE_ID = "chargepilot-eco"
-        private const val HISTORY_FILE = "trips.json"
         private const val DASH = "—"
 
         private const val PREFERENCES = "eco_coach"
         private const val PREF_ADVICE = "advice_enabled"
         private const val PREF_VOICE = "voice_enabled"
 
-        /** Off until asked for: a driver who never opens settings gets the tile and silence. */
-        fun adviceEnabled(context: Context): Boolean = prefs(context).getBoolean(PREF_ADVICE, false)
+        fun adviceEnabled(context: Context): Boolean =
+            prefs(context).getBoolean(PREF_ADVICE, EcoCoachDefaults.ADVICE_ENABLED)
 
         fun voiceEnabled(context: Context): Boolean = prefs(context).getBoolean(PREF_VOICE, false)
 

app/src/main/java/com/evsuite/chargepilot/LocalBatteryLearning.kt

@@ -0,0 +1,49 @@
+package com.evsuite.chargepilot
+
+import com.evsuite.hardware.telemetry.BatteryExposure
+import com.evsuite.hardware.telemetry.BatteryExposureReport
+import com.evsuite.hardware.telemetry.BatteryLedgerStore
+import com.evsuite.hardware.telemetry.CalibrationDrift
+import com.evsuite.hardware.telemetry.CalibrationDriftReport
+import com.evsuite.hardware.telemetry.ChargeEnergyAnalyzer
+import com.evsuite.hardware.telemetry.ChargeEnergyReport
+import com.evsuite.hardware.telemetry.StateOfHealthEstimator
+import com.evsuite.hardware.telemetry.StateOfHealthResult
+import java.io.File
+
+/** Existing battery analyses evaluated together from one bounded ledger snapshot. */
+internal data class BatteryLearningSnapshot(
+    val entryCount: Int,
+    val lastEntryAtMs: Long?,
+    val health: StateOfHealthResult,
+    val drift: CalibrationDriftReport?,
+    val exposure: BatteryExposureReport?,
+    val charge: ChargeEnergyReport,
+)
+
+internal object LocalBatteryLearning {
+    @Volatile
+    var latest: BatteryLearningSnapshot? = null
+        private set
+
+    /** Reads and analyses the ledger. Call only from a worker thread. */
+    @Synchronized
+    fun refresh(
+        filesDir: File,
+        usableCapacityKwhWhenNew: Double,
+        nowMs: Long = System.currentTimeMillis(),
+    ): BatteryLearningSnapshot {
+        val entries = BatteryLedgerStore(File(filesDir, BatteryLedgerStore.FILE_NAME)).read()
+        val health = StateOfHealthEstimator().estimate(entries, usableCapacityKwhWhenNew)
+        val ready = (health as? StateOfHealthResult.Ready)?.estimate
+        val exposure = BatteryExposure().analyse(entries)
+        return BatteryLearningSnapshot(
+            entryCount = entries.size,
+            lastEntryAtMs = entries.lastOrNull()?.atMs,
+            health = health,
+            drift = CalibrationDrift().analyse(entries, nowMs, ready),
+            exposure = exposure,
+            charge = ChargeEnergyAnalyzer().analyse(entries, exposure?.sessions.orEmpty()),
+        ).also { latest = it }
+    }
+}

app/src/main/java/com/evsuite/chargepilot/LocalEnergyModel.kt

@@ -17,9 +17,9 @@ object LocalEnergyModel {
     ): EnergyModel? {
         val store = EnergyModelStore(File(filesDir, MODEL_FILE))
         val stored = store.read()?.takeIf { it.evidence == evidence }
-        if (stored != null || evidence == null) return stored
+        if (evidence == null) return stored
         val trained = EnergyModelTrainer().train(trips, evidence.firmware)
-        if (trained !is EnergyModelTrainingResult.Ready) return null
+        if (trained !is EnergyModelTrainingResult.Ready) return stored
         store.write(trained.model)
         return trained.model
     }

app/src/main/java/com/evsuite/chargepilot/MainActivity.kt

@@ -63,6 +63,7 @@ class MainActivity : PrimaryNavigationActivity() {
 
     /** The recorder owns the sampler; this screen is one of its readers. */
     private var recorder: TripRecordingService? = null
+    private var loadedHistoryRevision = -1
     /** Exact normalized service frame; the parked-only actions re-read it rather than the UI. */
     @Volatile private var latestSnapshot: EnergySnapshot? = null
 
@@ -182,7 +183,6 @@ class MainActivity : PrimaryNavigationActivity() {
         // The consumption fit reads the whole trip history, so it happens once per visit to
         // this screen and only when there is actually a plan being followed.
         background.execute { runCatching { drift.load() } }
-        background.execute { runCatching { eco.load() } }
         bindService(
             Intent(this, TripRecordingService::class.java), connection, Context.BIND_AUTO_CREATE
         )
@@ -209,7 +209,10 @@ class MainActivity : PrimaryNavigationActivity() {
                 AppLogger.w(TAG, "trip stop ignored: recorder not bound")
                 return
             }
-            service.stopTrip(::loadRecentTrips)
+            service.stopTrip {
+                loadedHistoryRevision = service.historyRevision
+                loadRecentTrips()
+            }
             // The next drive is judged on its own window, not on the one that just ended.
             eco.reset()
             service.latest?.let(::render)
@@ -220,6 +223,15 @@ class MainActivity : PrimaryNavigationActivity() {
 
     private fun render(value: EnergySnapshot) {
         latestSnapshot = value
+        recorder?.historyRevision?.let { revision ->
+            if (loadedHistoryRevision < 0) {
+                loadedHistoryRevision = revision
+            } else if (revision != loadedHistoryRevision) {
+                loadedHistoryRevision = revision
+                eco.reset()
+                loadRecentTrips()
+            }
+        }
         // The calculators are fed the reading as it arrived, unvalidated firmware included.
         // A power figure the vehicle publishes is still a power figure; what an unproven
         // property costs it is its provenance, not its existence, and DashboardReadings
@@ -592,7 +604,9 @@ class MainActivity : PrimaryNavigationActivity() {
     private fun loadRecentTrips() {
         runCatching {
             background.execute {
-                val summaries = EnergyTripHistoryStore(File(filesDir, HISTORY_FILE)).readSummaries()
+                val trips = EnergyTripHistoryStore(File(filesDir, HISTORY_FILE)).read()
+                eco.load(trips)
+                val summaries = trips.map { it.summary }
                 runOnUiThread {
                     if (isFinishing || isDestroyed) return@runOnUiThread
                     recentTrips = summaries

app/src/main/java/com/evsuite/chargepilot/TripRecordingService.kt

@@ -67,6 +67,8 @@ class TripRecordingService : Service() {
     private lateinit var batteryLedger: BatteryLedgerRecorder
     private val detector = TripDetector()
     private val pendingHistoryWrites = AtomicInteger()
+    private val historyRevisionCounter = AtomicInteger()
+    private val batteryRevisionCounter = AtomicInteger()
     private val missingSpeedSamples = AtomicInteger()
 
     private var samplingTask: ScheduledFuture<*>? = null
@@ -88,6 +90,8 @@ class TripRecordingService : Service() {
     val missingSpeedSampleCount: Int get() = missingSpeedSamples.get()
     val boundClientCount: Int get() = boundClients
     val pendingHistoryWriteCount: Int get() = pendingHistoryWrites.get()
+    val historyRevision: Int get() = historyRevisionCounter.get()
+    val batteryRevision: Int get() = batteryRevisionCounter.get()
 
     override fun onCreate() {
         super.onCreate()
@@ -258,6 +262,16 @@ class TripRecordingService : Service() {
                 }.getOrDefault(false)
                 if (!saved) AppLogger.w(TAG, "trip history could not be saved")
                 if (saved) {
+                    runCatching {
+                        val trips = tripStore.read()
+                        val evidence = trips.firstNotNullOfOrNull {
+                            it.summary.batteryPowerEvidence
+                        }
+                        LocalEnergyModel.loadOrTrain(filesDir, trips, evidence)
+                    }.onFailure {
+                        AppLogger.w(TAG, "local energy model refresh failed: ${it.message}")
+                    }
+                    historyRevisionCounter.incrementAndGet()
                     AppLogger.i(
                         TAG,
                         "trip recording saved; started_epoch_ms=${recorded.summary.startedAtMs}; " +
@@ -310,8 +324,24 @@ class TripRecordingService : Service() {
         // charge, a change of charging state, or a quarter of an hour — so this costs one
         // comparison on all the other samples. It runs on the sampler thread, which is the
         // thread that already owns this file's neighbours.
-        runCatching { batteryLedger.observe(value) }
+        val batteryEntryWritten = runCatching { batteryLedger.observe(value) }
             .onFailure { AppLogger.w(TAG, "battery ledger write failed: ${it.message}") }
+            .getOrDefault(false)
+        if (batteryEntryWritten) {
+            if (ChargeLearningDefaults.AUTO_REFRESH) {
+                runCatching {
+                    val settings = VehicleSettings.read(this)
+                    LocalBatteryLearning.refresh(
+                        filesDir,
+                        settings.usableCapacityKwhWhenNew,
+                        value.timestampMs,
+                    )
+                }.onFailure {
+                    AppLogger.w(TAG, "battery learning refresh failed: ${it.message}")
+                }
+            }
+            batteryRevisionCounter.incrementAndGet()
+        }
         if (automaticDetectionEnabled) {
             updateAutomaticMonitorAvailability(value)
             val previousState = detector.state

app/src/stable/java/com/evsuite/chargepilot/ChargeLearningDefaults.kt

@@ -0,0 +1,6 @@
+package com.evsuite.chargepilot
+
+/** Stable keeps existing on-open battery analysis. */
+internal object ChargeLearningDefaults {
+    const val AUTO_REFRESH = false
+}

app/src/stable/java/com/evsuite/chargepilot/EcoCoachDefaults.kt

@@ -0,0 +1,6 @@
+package com.evsuite.chargepilot
+
+/** Stable preserves CP-074's explicit opt-in. */
+internal object EcoCoachDefaults {
+    const val ADVICE_ENABLED = false
+}

app/src/test/java/com/evsuite/chargepilot/LocalBatteryLearningTest.kt

@@ -0,0 +1,50 @@
+package com.evsuite.chargepilot
+
+import com.evsuite.hardware.telemetry.BatteryLedgerEntry
+import com.evsuite.hardware.telemetry.BatteryLedgerStore
+import java.nio.file.Files
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Test
+
+class LocalBatteryLearningTest {
+    @Test
+    fun `growing ledger refreshes derived charge sessions`() {
+        val directory = Files.createTempDirectory("chargepilot-battery-learning").toFile()
+        try {
+            val store = BatteryLedgerStore(
+                directory.resolve(BatteryLedgerStore.FILE_NAME)
+            )
+            store.append(entry(0L, 40f))
+            store.append(entry(HOUR, 50f))
+
+            val first = LocalBatteryLearning.refresh(directory, 61.7, nowMs = HOUR)
+            assertEquals(2, first.entryCount)
+            assertEquals(1, first.charge.charges.size)
+
+            store.append(entry(2 * HOUR, 45f))
+            store.append(entry(3 * HOUR, 55f))
+
+            val refreshed = LocalBatteryLearning.refresh(directory, 61.7, nowMs = 3 * HOUR)
+            assertEquals(4, refreshed.entryCount)
+            assertEquals(2, refreshed.charge.charges.size)
+            assertSame(refreshed, LocalBatteryLearning.latest)
+        } finally {
+            directory.deleteRecursively()
+        }
+    }
+
+    private fun entry(atMs: Long, socPercent: Float) = BatteryLedgerEntry(
+        atMs = atMs,
+        socPercent = socPercent,
+        odometerKm = 10_000f,
+        outsideTempCelsius = 20f,
+        chargingStatus = 1,
+        chargePortConnected = true,
+        parked = true,
+    )
+
+    private companion object {
+        const val HOUR = 3_600_000L
+    }
+}