feat(diagnostics): record probes for the whole session, export them together

Validation had to be driven by hand: open a screen, arm a probe, remember a
save button, then export. That is the wrong default while the car is the
instrument. Evidence is collected on a drive, when nobody should be operating
a screen, and the most decision-relevant result — a probe that heard nothing
— is the one a driver is least likely to think worth saving.

The guidance listener and a new session-long signal recorder now arm when the
application starts, and the export writes every probe artifact itself. One
"Export to USB" carries the guidance trace with its transaction census, the
signal statistics for the whole session, and the recorded trip summaries.

NavGuidanceRecorder owns the trace at process scope, so the probe screen is a
window onto it rather than its owner and closing it no longer ends a capture.
Arming is deliberately not parked-gated: it registers a read-only listener
with no UI, and refusing because the car was moving when the app started
would lose the drive the evidence is being collected on.

Trip summaries travel because trips.json never left the car, so a wrong
distance could only be reported second-hand. Distance over duration gives the
average speed the integration believed in, which is what the speed-unit
question turns on.

Cost: one binder registration, and two 1 Hz ticks reading volatiles and
vehicle properties — the cadence the recording service already uses. Both
recorders keep constant memory; the trace ring is bounded and nothing is
written to disk until an export asks. The artifact pool grew from eight files
to twelve because an export now writes three of them.

Stable arms nothing, writes nothing, and contains none of these classes.

Refs: CP-040

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

Author: malys

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes follow [Keep a Changelog](https://keepachangelog.com/en/1.1.
 
 ## [Unreleased]
 
+### Added
+
+- **The unstable channel records its own evidence and the export carries all of it.** Validation
+  had to be driven by hand: open a screen, arm a probe, remember a save button, then export —
+  and the run that mattered most, the one where a probe heard nothing, was the one nobody
+  thought worth saving. The guidance listener and a session-long signal recorder now arm when
+  the application starts, and one "Export to USB" writes the guidance trace, the signal
+  statistics and the recorded trip summaries into the bundle by itself. The probe screen became
+  a window onto the recorder rather than its owner, so closing it no longer ends a capture.
+  Trip summaries travel because a distance integrated from a wrong speed scale shows up there
+  first. Stable arms nothing and contains none of it.
+
 ### Fixed
 
 - **The dashboard now asks for the vehicle signals it already declared.** AAOS classifies

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

@@ -7,6 +7,9 @@ class ChargePilotApp : Application() {
     override fun onCreate() {
         super.onCreate()
         CrashLogger.install(this, "EVChargePilot")
+        // Unstable arms the validation probes here so a drive is recorded without anyone
+        // opening a screen first; stable does nothing, and contains none of this.
+        EvidenceCaptureHook.startProbes(this)
     }
 }
 

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

@@ -513,6 +513,10 @@ class MainActivity : AppCompatActivity() {
             // volatile latest sample at the last responsible moment so parking cannot go stale.
             val decision = diagnosticExportDecision(service?.latest)
             val file = if (decision == DiagnosticExportPolicy.Decision.ALLOWED) {
+                // Every always-on probe writes its current artifact first, so one export
+                // carries the guidance trace, the signal statistics and the trip record
+                // without anyone having remembered to save them during the drive.
+                EvidenceCaptureHook.saveProbeArtifacts(appContext)
                 // Rebuild after USB selection so timestamps, logs and last sample match export.
                 DiagnosticExporter.export(appContext, diagnosticsReport(), directory)
             } else null

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

@@ -1,18 +1,25 @@
 package com.evsuite.chargepilot
 
 import android.app.Activity
+import android.content.Context
 
 /**
  * Stable channel: no evidence capture, by construction.
  *
  * The capture screen is a development instrument — it samples faster than the dashboard, writes
  * files a driver has no use for, and exists to answer questions about firmware behaviour. It is
  * not disabled here; it is not in the APK. Nothing in a stable build can be persuaded to start
- * recording property statistics.
+ * recording property statistics, or to register a listener on a head-unit service.
  */
 object EvidenceCaptureHook {
     const val IS_SUPPORTED = false
 
     /** Does nothing. */
     fun open(activity: Activity) = Unit
+
+    /** Does nothing. Stable arms no probe. */
+    fun startProbes(context: Context) = Unit
+
+    /** Does nothing. Stable has no probe artifact to write. */
+    fun saveProbeArtifacts(context: Context) = Unit
 }

app/src/testUnstable/java/com/evsuite/chargepilot/EvidenceCaptureFileStoreTest.kt

@@ -61,7 +61,10 @@ class EvidenceCaptureFileStoreTest {
                 .mapNotNull { TelemetryEvidenceFormat.fromJson(it.readText())?.snapshots }
                 .toSet()
             assertEquals(EvidenceCaptureFileStore.MAX_CAPTURE_FILES, retainedSnapshots.size)
-            assertEquals((3..10).toSet(), retainedSnapshots)
+            // The two oldest of the writes above are evicted; the rest survive, whatever the
+            // pool size happens to be.
+            val newest = EvidenceCaptureFileStore.MAX_CAPTURE_FILES + 2
+            assertEquals((3..newest).toSet(), retainedSnapshots)
         } finally {
             directory.deleteRecursively()
         }

app/src/unstable/java/com/evsuite/chargepilot/EvidenceCaptureFileStore.kt

@@ -78,7 +78,11 @@ internal class EvidenceCaptureFileStore(
     }
 
     companion object {
-        internal const val MAX_CAPTURE_FILES = 8
+        /**
+     * One export now writes three artifacts — guidance, signal statistics and trips — so the
+     * pool holds four full exports rather than eight of a single kind.
+     */
+    internal const val MAX_CAPTURE_FILES = 12
         internal const val CAPTURE_KIND = "evidence"
         private val CAPTURE_NAME = Regex("^(.*-\\d{8}-\\d{6}-\\d{3})(?:-(\\d+))?$")
     }

app/src/unstable/java/com/evsuite/chargepilot/EvidenceCaptureHook.kt

@@ -1,13 +1,58 @@
 package com.evsuite.chargepilot
 
 import android.app.Activity
-import android.content.Intent
+import android.content.Context
+import com.evsuite.hardware.FirmwareInfo
+import java.io.File
 
 /** Unstable channel: the capture screen exists and is reachable from the dashboard. */
 object EvidenceCaptureHook {
     const val IS_SUPPORTED = true
 
     fun open(activity: Activity) {
-        activity.startActivity(Intent(activity, EvidenceCaptureActivity::class.java))
+        activity.startActivity(
+            android.content.Intent(activity, EvidenceCaptureActivity::class.java)
+        )
+    }
+
+    /**
+     * Arms the always-on probes when the application starts.
+     *
+     * During validation the guidance listener has to be running before the drive begins, not
+     * after somebody remembers to open a screen. It costs one binder registration and a 1 Hz
+     * tick, and it is read-only.
+     */
+    fun startProbes(context: Context) {
+        NavGuidanceRecorder.start(context)
+        SignalEvidenceRecorder.start(context)
+    }
+
+    /**
+     * Writes every always-on probe artifact into the folder the diagnostic export bundles.
+     *
+     * Called on the export path so one "Export to USB" always carries the current state of
+     * every probe, including the states nobody would think to save by hand: an adapter that
+     * never bound, or a listener that was registered all drive and heard nothing.
+     */
+    fun saveProbeArtifacts(context: Context) {
+        // A late arm is better than none: the app may have started before the vehicle
+        // services were up, and an export is a good moment to find out.
+        NavGuidanceRecorder.start(context)
+        SignalEvidenceRecorder.start(context)
+        val firmware = FirmwareInfo.getGeneration().name
+        val store = EvidenceCaptureFileStore(
+            File(context.filesDir, NavGuidanceRecorder.EVIDENCE_DIRECTORY)
+        )
+        store.write(
+            NavGuidanceRecorder.artifact().toJson(),
+            NavGuidanceProbeArtifact.KIND,
+            firmware,
+        )
+        store.write(SignalEvidenceRecorder.capture())
+        store.write(
+            TripHistoryArtifact.of(context).toJson(),
+            TripHistoryArtifact.KIND,
+            firmware,
+        )
     }
 }

app/src/unstable/java/com/evsuite/chargepilot/NavGuidanceProbeActivity.kt

@@ -3,17 +3,11 @@ package com.evsuite.chargepilot
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
-import android.os.SystemClock
 import androidx.appcompat.app.AppCompatActivity
 import com.evsuite.chargepilot.databinding.ActivityNavGuidanceProbeBinding
-import com.evsuite.hardware.FirmwareInfo
-import com.evsuite.hardware.saic.NavGuidance
 import com.evsuite.hardware.saic.SaicNavGuidance
 import com.evsuite.hardware.telemetry.EnergyTelemetryReader
 import com.google.android.material.snackbar.Snackbar
-import java.io.File
-import java.util.ArrayDeque
-import java.util.Locale
 
 /**
  * Records what the head unit's navigation actually reports during a drive.
@@ -36,22 +30,16 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
 
     private lateinit var binding: ActivityNavGuidanceProbeBinding
     private lateinit var reader: EnergyTelemetryReader
-    private lateinit var fileStore: EvidenceCaptureFileStore
 
     private val ticker = Handler(Looper.getMainLooper())
-    private val trace = ArrayDeque<String>()
-    private var lastEvents = -1
     private var visible = false
-    private var startedAtElapsedMs: Long? = null
-    private var dropped = false
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = ActivityNavGuidanceProbeBinding.inflate(layoutInflater)
         setContentView(binding.root)
         reader = EnergyTelemetryReader(applicationContext)
-        fileStore = EvidenceCaptureFileStore(File(filesDir, EVIDENCE_DIRECTORY))
-        SaicNavGuidance.connect(applicationContext)
+        NavGuidanceRecorder.start(applicationContext)
         binding.probeAction.setOnClickListener { toggle() }
         binding.saveAction.setOnClickListener { saveTrace() }
         ticker.post(tick)
@@ -69,57 +57,27 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
         super.onStop()
     }
 
+    /**
+     * Leaves the recorder running. It belongs to the process now, so closing this screen
+     * neither unregisters the listener nor discards the trace — which is the whole reason a
+     * drive no longer has to be spent with a diagnostic screen in front of the driver.
+     */
     override fun onDestroy() {
         ticker.removeCallbacks(tick)
-        SaicNavGuidance.stop()
         super.onDestroy()
     }
 
     private val tick = object : Runnable {
         override fun run() {
-            record(SaicNavGuidance.latest())
             if (visible) render()
             ticker.postDelayed(this, TICK_MS)
         }
     }
 
-    /**
-     * Appends a line only when the listener actually saw something new.
-     *
-     * A drive that produces no line is the finding, not a failure of this screen — which is
-     * why the trace is never padded with repeats of an unchanged state.
-     */
-    private fun record(guidance: NavGuidance) {
-        if (guidance.events == lastEvents) return
-        lastEvents = guidance.events
-        if (guidance.events == 0) return
-        val since = startedAtElapsedMs?.let { (SystemClock.elapsedRealtime() - it) / 1_000L } ?: 0L
-        if (trace.size >= TRACE_LINES) {
-            trace.removeFirst()
-            dropped = true
-        }
-        trace.addLast(
-            String.format(
-                Locale.ROOT,
-                "%5ds n=%-4d status=%-4s dist=%-8s min=%-6s turn=%-8s road=%s",
-                since, guidance.events,
-                guidance.guideStatus.show(),
-                guidance.remainingDistanceRaw.show(),
-                guidance.remainingMinutes.show(),
-                guidance.nextTurnDistanceRaw.show(),
-                // A road name is head-unit text of unknown length; the saved artifact has to
-                // stay under the export's per-file ceiling whatever it contains.
-                (guidance.road ?: guidance.direction ?: DASH).take(ROAD_CHARS),
-            )
-        )
-    }
-
     /** Rechecks speed at the moment of the press; a disabled button is not a safety boundary. */
     private fun toggle() {
-        if (SaicNavGuidance.isListening) {
-            SaicNavGuidance.stop()
-            startedAtElapsedMs = null
-            lastEvents = -1
+        if (NavGuidanceRecorder.isRunning) {
+            NavGuidanceRecorder.stop()
             render()
             return
         }
@@ -128,38 +86,19 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
             Snackbar.make(binding.root, R.string.nav_probe_refused, Snackbar.LENGTH_LONG).show()
             return
         }
-        if (SaicNavGuidance.start()) {
-            startedAtElapsedMs = SystemClock.elapsedRealtime()
-            trace.clear()
-            dropped = false
-            lastEvents = -1
-        }
+        NavGuidanceRecorder.start(applicationContext)
+        NavGuidanceRecorder.clear()
         render()
     }
 
     /**
-     * Writes the trace where the diagnostic export finds it.
+     * Saves now, rather than waiting for the next export to do it.
      *
-     * The clipboard was never a way off this head unit: the file goes into the evidence
-     * folder, and the dashboard's "Export to USB" carries it out with the rest of the bundle.
-     * The write is a bounded JSON file on internal storage, so it stays on the click.
+     * The export writes this artifact on its own, so this button is a convenience for a
+     * driver who wants the current state pinned before carrying on.
      */
     private fun saveTrace() {
-        val saved = fileStore.write(
-            NavGuidanceProbeArtifact.of(
-                savedAtMs = System.currentTimeMillis(),
-                firmware = FirmwareInfo.getGeneration().name,
-                adapterBound = SaicNavGuidance.isAvailable,
-                listenerRegistered = SaicNavGuidance.isListening,
-                callbacks = SaicNavGuidance.latest().events,
-                census = SaicNavGuidance.census(),
-                censusBeyondCeiling = SaicNavGuidance.censusBeyondCeiling(),
-                trace = trace.toList(),
-                traceComplete = !dropped,
-            ).toJson(),
-            NavGuidanceProbeArtifact.KIND,
-            FirmwareInfo.getGeneration().name,
-        )
+        val saved = NavGuidanceRecorder.save(applicationContext)
         Snackbar.make(
             binding.root,
             if (saved == null) R.string.nav_probe_save_failed else R.string.nav_probe_saved,
@@ -169,7 +108,7 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
 
     private fun render() {
         val guidance = SaicNavGuidance.latest()
-        val listening = SaicNavGuidance.isListening
+        val listening = NavGuidanceRecorder.isRunning
         binding.probeAction.setText(
             if (listening) R.string.nav_probe_stop else R.string.nav_probe_start
         )
@@ -188,6 +127,7 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
                 else -> R.string.nav_probe_hint_ready
             }
         )
+        val trace = NavGuidanceRecorder.trace()
         binding.probeTrace.text = if (trace.isEmpty()) {
             getString(R.string.nav_probe_no_data)
         } else {
@@ -200,15 +140,7 @@ class NavGuidanceProbeActivity : AppCompatActivity() {
         binding.saveAction.isEnabled = true
     }
 
-    private fun Int?.show(): String = this?.toString() ?: DASH
-
     private companion object {
         const val TICK_MS = 1_000L
-        /** Three hours of change at one line per second would not fit; the newest lines win. */
-        const val TRACE_LINES = 300
-        /** A road name past this adds nothing a decision uses, and the file has a ceiling. */
-        const val ROAD_CHARS = 40
-        const val DASH = "—"
-        const val EVIDENCE_DIRECTORY = "evidence"
     }
 }