fix(diagnostics): keep the guidance artifact inside the export ceiling

The exporter drops an evidence file over 64 KiB and merely lists it as
skipped. A full 300-line trace with accented road names lands around 47 KiB,
so the one artifact a validation run exists to produce was one long road name
away from disappearing quietly into the manifest.

toBoundedJson trims oldest trace lines until the artifact fits, well inside
the exporter's own limit so a file cannot fail on a boundary. Oldest go
first, because the end of a drive is what an arrival forecast is judged on,
and trimming marks traceComplete false exactly as the ring overflowing does.

Refs: CP-040

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

Author: malys

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

@@ -68,3 +68,40 @@ class NavGuidanceProbeArtifactTest {
         traceComplete = traceComplete,
     )
 }
+
+class NavGuidanceProbeArtifactBoundTest {
+
+    private fun artifact(lines: Int, road: String) = NavGuidanceProbeArtifact.of(
+        savedAtMs = 1_700_000_000_000L,
+        firmware = "SWI68",
+        adapterBound = true,
+        listenerRegistered = true,
+        callbacks = lines,
+        census = mapOf(13 to lines),
+        censusBeyondCeiling = 0,
+        trace = List(lines) { "%5ds n=%-4d dist=%-8s road=%s".format(it, it, it * 10, road) },
+        traceComplete = true,
+    )
+
+    @Test fun `a full trace of accented road names still fits the export ceiling`() {
+        val json = artifact(300, "Avenue des Carabènes, Saint-Orens-de-Gam")
+            .toBoundedJson()
+        assertTrue(
+            "artifact must stay inside the exporter's per-file limit",
+            json.toByteArray(Charsets.UTF_8).size <= NavGuidanceProbeArtifact.MAX_ARTIFACT_BYTES,
+        )
+    }
+
+    @Test fun `a trace that has to be trimmed says so and keeps the end of the drive`() {
+        val json = artifact(300, "x".repeat(40)).toBoundedJson(maxBytes = 4_096)
+        assertTrue(json.toByteArray(Charsets.UTF_8).size <= 4_096)
+        assertTrue("trimming must mark the trace incomplete", json.contains("\"traceComplete\":false"))
+        // The last line of the drive is the one a forecast is judged on; it must survive.
+        assertTrue(json.contains("  299s"))
+    }
+
+    @Test fun `a short trace is left exactly as it was`() {
+        val full = artifact(5, "A61")
+        assertEquals(full.toJson(), full.toBoundedJson())
+    }
+}

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

@@ -44,7 +44,7 @@ object EvidenceCaptureHook {
             File(context.filesDir, NavGuidanceRecorder.EVIDENCE_DIRECTORY)
         )
         store.write(
-            NavGuidanceRecorder.artifact().toJson(),
+            NavGuidanceRecorder.artifact().toBoundedJson(),
             NavGuidanceProbeArtifact.KIND,
             firmware,
         )

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

@@ -32,13 +32,45 @@ internal data class NavGuidanceProbeArtifact(
 ) {
     fun toJson(): String = GSON.toJson(this)
 
+    /**
+     * The artifact, guaranteed to fit the diagnostic export's per-file ceiling.
+     *
+     * A file over that ceiling is not truncated by the exporter, it is dropped and merely
+     * listed as skipped — so the one artifact a validation run exists to produce would go
+     * missing quietly, and only a careful reader of the manifest would notice. 300 lines of
+     * trace with accented road names lands around 47 KB against a 64 KB limit, which is
+     * enough headroom until it is not.
+     *
+     * Oldest trace lines go first, because the end of a drive is what a forecast is judged
+     * on. Dropping any marks [traceComplete] false, exactly as the ring overflowing does.
+     */
+    fun toBoundedJson(maxBytes: Int = MAX_ARTIFACT_BYTES): String {
+        var candidate = this
+        var json = candidate.toJson()
+        while (json.toByteArray(Charsets.UTF_8).size > maxBytes && candidate.trace.isNotEmpty()) {
+            val keep = (candidate.trace.size * 3) / 4
+            candidate = candidate.copy(
+                trace = candidate.trace.takeLast(keep.coerceAtLeast(0)),
+                traceComplete = false,
+            )
+            json = candidate.toJson()
+        }
+        return json
+    }
+
     companion object {
         const val SCHEMA_VERSION = 1
         const val PROBE = "nav-guidance"
 
         /** File name kind, kept apart from the capture files sharing the evidence folder. */
         const val KIND = "navguidance"
 
+        /**
+         * Comfortably inside the exporter's own 64 KiB per-file ceiling, so a file that grew
+         * between the write and the export still travels.
+         */
+        const val MAX_ARTIFACT_BYTES = 48 * 1024
+
         private val GSON = Gson()
 
         private val NOTES = listOf(

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

@@ -150,7 +150,7 @@ internal object NavGuidanceRecorder {
     fun save(context: Context, nowMs: Long = System.currentTimeMillis()): File? {
         val firmware = FirmwareInfo.getGeneration().name
         return EvidenceCaptureFileStore(File(context.filesDir, EVIDENCE_DIRECTORY))
-            .write(artifact(nowMs).toJson(), NavGuidanceProbeArtifact.KIND, firmware)
+            .write(artifact(nowMs).toBoundedJson(), NavGuidanceProbeArtifact.KIND, firmware)
     }
 
     private fun Int?.show(): String = this?.toString() ?: DASH