@@ -6,6 +6,15 @@ All notable changes to this project are documented here. Format follows
 
 ## [Unreleased]
 
+### Fixed
+
+- **Repeated vehicle states no longer flood the diagnostic log.** The ignition condition
+  arrives about ten times a second and the gear is read once a second; both were logged every
+  time, so a 400-line retained log held under a minute of history and anything older had already
+  been evicted from the bundle a driver sends back. `StateChangeLog` lets a state through only
+  when it changed, keeping the transitions a diagnostic actually reads and dropping the repeats
+  between them. Only logging is gated — every callback is still dispatched.
+
 ## [1.14.0] - 2026-09-04
 
 ### Changed
 
@@ -1805,6 +1805,10 @@ object EVHardware {
      * while the service behind it is bound and answering. A null here blocks power-off and
      * costs the write gate its standstill fallback, so a second source is worth having.
      */
+    /** Keeps the repeated gear and ignition states out of the bounded diagnostic log. */
+    private val sGearLog = StateChangeLog<Int>()
+    private val sIgnitionLog = StateChangeLog<Int>()
+
     fun isVehicleInPark(): Boolean? {
         val gen = FirmwareInfo.getGeneration()
         val gear = when {
@@ -1818,7 +1822,10 @@ object EVHardware {
         }.takeIf { it >= 0 }
             ?: com.evsuite.hardware.saic.SaicVehicleCondition.gearOrNull()
             ?: return null
-        AppLogger.i(TAG, "isVehicleInPark — gen=$gen gear=$gear (P=$GEAR_PARK_VALUE)")
+        // Read once a second by the telemetry sampler; only gear changes are worth a line.
+        if (sGearLog.accept(gear)) {
+            AppLogger.i(TAG, "isVehicleInPark — gen=$gen gear=$gear (P=$GEAR_PARK_VALUE)")
+        }
         return gear == GEAR_PARK_VALUE
     }
 
@@ -3511,7 +3518,12 @@ object EVHardware {
                     try {
                         val ignition = bean.javaClass.getMethod("getVehicleIgnition").invoke(bean) as? Int
                         if (ignition != null) {
-                            AppLogger.i(TAG, "  Katman5 event: ignition=$ignition (${carIgnitionName(ignition)})")
+                            // The callback repeats at about 10 Hz whether or not anything
+                            // moved. Only the transitions are logged; every event is still
+                            // dispatched, because suppressing one would change behaviour.
+                            if (sIgnitionLog.accept(ignition)) {
+                                AppLogger.i(TAG, "  Katman5 event: ignition=$ignition (${carIgnitionName(ignition)})")
+                            }
                             dispatchVehicleConditionIgnition(ignition)
                         }
                     } catch (e: Exception) {
 
@@ -0,0 +1,38 @@
+package com.evsuite.hardware
+
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Lets a repeated state through only when it actually changed.
+ *
+ * Two vehicle callbacks report a state rather than an event: the ignition condition arrives
+ * about ten times a second and the gear is read once a second, and both were logged every
+ * time. On a 400-line retained diagnostic log that is under a minute of history — the bundle
+ * a driver sends back is then almost entirely one repeated line, and whatever went wrong
+ * before that minute has already been evicted. It also spends the head unit's CPU and log
+ * bandwidth continuously to say nothing new.
+ *
+ * A state worth logging is a state that changed. The transitions are what a diagnostic reads
+ * anyway; the repeats between them carry no information the timestamp of the next transition
+ * does not already give.
+ *
+ * Only logging is gated. Callers must still dispatch every callback they receive — dropping a
+ * dispatch would change behaviour, dropping a log line changes only noise.
+ */
+class StateChangeLog<T> {
+
+    private val last = AtomicReference<Any?>(NOTHING)
+
+    /**
+     * @return true when [value] differs from the previous accepted one, or nothing was seen yet.
+     */
+    fun accept(value: T): Boolean = last.getAndSet(value) != value
+
+    /** Forgets what was seen, so the next value logs as if it were the first. */
+    fun reset() = last.set(NOTHING)
+
+    private companion object {
+        /** Distinct from null, so a first value of null still counts as a change. */
+        val NOTHING = Any()
+    }
+}
@@ -0,0 +1,52 @@
+package com.evsuite.hardware
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class StateChangeLogTest {
+
+    @Test fun `the first value always passes`() {
+        assertTrue(StateChangeLog<Int>().accept(2))
+    }
+
+    @Test fun `a repeat is suppressed`() {
+        val gate = StateChangeLog<Int>()
+        assertTrue(gate.accept(2))
+        assertFalse(gate.accept(2))
+        assertFalse(gate.accept(2))
+    }
+
+    @Test fun `a transition passes and the repeats after it do not`() {
+        val gate = StateChangeLog<Int>()
+        gate.accept(2)
+        assertTrue(gate.accept(4))
+        assertFalse(gate.accept(4))
+        assertTrue(gate.accept(2))
+    }
+
+    @Test fun `the ignition flood collapses to its transitions`() {
+        // 10 Hz of "RUN/READY" either side of one real change, as the vehicle actually reports it.
+        val gate = StateChangeLog<Int>()
+        val stream = List(100) { 2 } + List(100) { 0 }
+        assertEquals(2, stream.count { gate.accept(it) })
+    }
+
+    @Test fun `a first null still counts as a change`() {
+        val gate = StateChangeLog<Int?>()
+        assertTrue(gate.accept(null))
+        assertFalse(gate.accept(null))
+        assertTrue(gate.accept(1))
+    }
+
+    @Test fun `reset makes the next value log again`() {
+        val gate = StateChangeLog<Int>()
+        gate.accept(2)
+        assertFalse(gate.accept(2))
+        gate.reset()
+        assertTrue(gate.accept(2))
+    }
+
+    private fun assertEquals(expected: Int, actual: Int) =
+        org.junit.Assert.assertEquals(expected.toLong(), actual.toLong())
+}