@@ -11,6 +11,7 @@ All notable changes to this project are documented here. Format follows
 - **Custom drive mode settings (CR-040).** When a profile selects Custom, the editor offers power response (Eco / Normal / Sport), steering and brake-pedal feel (Comfort / Normal / Sport). They are written after the drive mode, only when the profile's mode is Custom, 150 ms apart and behind the standstill gate. On the dashboard, tapping Custom while the car is already in Custom opens the same three settings live. Available on SWI68, SWI165, SWI69, SWI131 and SWI132; not on SWI133. The value scales beyond the read/write codes recorded in RI-006 still need an on-vehicle confirmation.
 - **Climate in profiles (CR-041).** An optional climate block on the comfort tab, unchecked by default: power, setpoint, AUTO, fan, A/C, recirculation and the two defrosters, the last three with an "Unchanged" choice. Climate off writes nothing else, and the fan is written only in manual mode, so a profile never knocks the unit out of AUTO. Climate is a comfort write, like seat heating, and is not speed-gated. Not offered on SWI133, which has no climate write path.
 - Profiles saved before this release configure neither feature and behave exactly as before.
+- **Read-back logging for the parked on-vehicle tests (RI-006, CR-040, CR-041).** `[READBACK]` INFO lines in the log console and diagnostic export record the car's state before and after the dashboard's regen and Custom writes (500 ms and 300 ms after), around a profile's drive/regen block, its Custom block and its climate plan. Reads only: no write, value, order, delay or lock changed, and a failed read is logged as text. One-pedal has no reader in EVHardware, so it is logged as such.
 
 ## [3.0.4] - 2026-09-22
 
 
@@ -96,6 +96,8 @@ object ProfileApplier {
             val roadWrites = VehicleWriteGate.allow("profile '${profile.name}' — driving settings")
 
             if (roadWrites) {
+                // RI-006 read-back: before the block's first write, never between its writes.
+                ReadBack.regen("ProfileApplier", "before")
                 // Mode de conduite (rapide — binder call)
                 val dmOk = EVHardware.setDriveMode(profile.driveMode)
                 AppLogger.i(TAG, "  DriveMode=${profile.driveMode.label} → $dmOk")
@@ -123,6 +125,10 @@ object ProfileApplier {
             // Climate (CR-041) — comfort, like the heating above: not speed-gated.
             profile.climate?.let { applyClimate(it) }
 
+            // RI-006 read-back, after the Katman1 block's last write. No wait added: there is
+            // no existing delay after it, and a new one here would hold up every profile.
+            if (roadWrites) ReadBack.regen("ProfileApplier", "after Katman1 (no added wait)")
+
             AppLogger.i(TAG, "Profile '${profile.name}' Katman1 completed — ok=$ok")
             onComplete?.invoke(ok)
 
@@ -268,6 +274,9 @@ object ProfileApplier {
      * and stays where the car has it.
      */
     private fun applyCustomDrive(profile: DrivingProfile) {
+        // CR-040 read-back: a snapshot before the first write and after the last write's own
+        // 150 ms — never between two writes, so the existing spacing stays exactly as it is.
+        ReadBack.custom("ProfileApplier", "before")
         listOf(
             CustomDrive.Setting.POWER to profile.customPower,
             CustomDrive.Setting.STEERING to profile.customSteering,
@@ -282,6 +291,7 @@ object ProfileApplier {
             AppLogger.i(TAG, "  Custom $setting=$index → $done")
             try { Thread.sleep(150) } catch (_: InterruptedException) {}
         }
+        ReadBack.custom("ProfileApplier", "after")
     }
 
     /** Runs [ClimatePlan]'s steps, spaced like every other multi-write sequence here. */
@@ -290,10 +300,13 @@ object ProfileApplier {
             AppLogger.w(TAG, "  Climate skipped — climate service not available")
             return
         }
+        ReadBack.climate("before")   // CR-041 read-back
         ClimatePlan.steps(climate).forEachIndexed { i, step ->
             if (i > 0) try { Thread.sleep(150) } catch (_: InterruptedException) {}
             AppLogger.i(TAG, "  Climate ${step.control}=${step.value} → ${ClimatePlan.write(step)}")
         }
+        // After the plan's last write; the spec's ~2 s wait is not added (it would be a new delay).
+        ReadBack.climate("after (no added wait)")
     }
 
     /**
 
@@ -0,0 +1,46 @@
+package com.evsuite.profile.profile
+
+import android.os.Looper
+import com.evsuite.hardware.AppLogger
+import com.evsuite.hardware.CustomDrive
+import com.evsuite.hardware.EVHardware
+import com.evsuite.hardware.saic.SaicClimate
+
+/**
+ * Read-back lines for the owner's parked tests (RI-006, CR-040, CR-041): the car's state just
+ * before and after a write, so the log carries a read/write/read triple per step.
+ *
+ * Reads only. Nothing here writes, waits, or throws: a failed or null read is a word in the
+ * line, and a call on the main thread logs that it skipped instead of blocking on the binder.
+ */
+object ReadBack {
+
+    /** RI-006. EVHardware publishes no one-pedal reader, and [EVHardware.getRegenLevel] maps an
+     *  unknown code to MEDIUM — so this is the mapped level, not the raw int. */
+    fun regen(where: String, phase: String) = line("EV_HW", where, phase) {
+        "regen=${show { EVHardware.getRegenLevel()?.let { "${it.name}(${it.value})" } }} onePedal=no reader"
+    }
+
+    /** CR-040. [CustomDrive.read] answers the position index; null is unreadable or off-scale. */
+    fun custom(where: String, phase: String, settings: List<CustomDrive.Setting> = CustomDrive.Setting.values().toList()) =
+        line("EV_CUSTOM", where, phase) { settings.joinToString(" ") { "$it=${show { CustomDrive.read(it) }}" } }
+
+    /** CR-041. Every climate reader the plan writes. */
+    fun climate(phase: String) = line("EV_PROFILE", "Climate", phase) {
+        "power=${show { SaicClimate.powerOn() }} auto=${show { SaicClimate.autoOn() }} " +
+            "ac=${show { SaicClimate.acOn() }} temp=${show { SaicClimate.driverTemp() }} " +
+            "fan=${show { SaicClimate.fanLevel() }} recirc=${show { SaicClimate.recirculationOn() }} " +
+            "frontDefrost=${show { SaicClimate.frontDefrostOn() }} rearDefrost=${show { SaicClimate.rearDefrostOn() }}"
+    }
+
+    /** [read]'s value as text; null and exceptions become words, never a throw. */
+    internal fun show(read: () -> Any?): String =
+        try { read()?.toString() ?: "unreadable" } catch (e: Exception) { "exc(${e.javaClass.simpleName})" }
+
+    private fun line(tag: String, where: String, phase: String, body: () -> String) {
+        try {
+            val text = if (Looper.myLooper() == Looper.getMainLooper()) "skipped — main thread" else body()
+            AppLogger.i(tag, "  [READBACK] $where $phase: $text")
+        } catch (_: Exception) {}
+    }
+}
@@ -23,8 +23,10 @@ import com.evsuite.hardware.EVHardware.Swi68Mode
 import com.evsuite.hardware.model.DriveMode
 import com.evsuite.hardware.model.RegenLevel
 import com.evsuite.hardware.FirmwareInfo
+import com.evsuite.profile.profile.ReadBack
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
@@ -279,7 +281,13 @@ class DashboardFragment : Fragment() {
         regenButtons.forEach { (level, btn) ->
             btn.setOnClickListener {
                 applyRegenUI(level)
-                CoroutineScope(Dispatchers.IO).launch { EVHardware.setRegenLevel(level) }
+                CoroutineScope(Dispatchers.IO).launch {
+                    // RI-006 read-back around the one write; the wait comes after it, never before.
+                    ReadBack.regen("Dashboard", "before ${level.name}")
+                    EVHardware.setRegenLevel(level)
+                    delay(500)
+                    ReadBack.regen("Dashboard", "500 ms after ${level.name}")
+                }
             }
         }
 
@@ -663,8 +671,12 @@ class DashboardFragment : Fragment() {
                         b.alpha = if (available) 1f else 0.35f
                         b.setOnClickListener {
                             CoroutineScope(Dispatchers.IO).launch {
+                                // CR-040 read-back; the wait follows the highlight, so the UI is not held.
+                                ReadBack.custom("Dashboard", "before $index", listOf(setting))
                                 val ok = CustomDrive.write(setting, index)
                                 withContext(Dispatchers.Main) { if (ok && isAdded) highlight(index) }
+                                delay(300)
+                                ReadBack.custom("Dashboard", "300 ms after $index", listOf(setting))
                             }
                         }
                     }
 
@@ -0,0 +1,21 @@
+package com.evsuite.profile.profile
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/** A read-back sits inside a write sequence: a failed read must become text, never a throw. */
+class ReadBackTest {
+
+    @Test fun valueNullAndExceptionAreAllText() {
+        assertEquals("2", ReadBack.show { 2 })
+        assertEquals("unreadable", ReadBack.show { null })
+        assertEquals("exc(IllegalStateException)", ReadBack.show { throw IllegalStateException("binder") })
+    }
+
+    @Test fun lineNeverThrowsOffDevice() {
+        // No car and no CarPropertyManager in a JVM test: every reader fails, nothing escapes.
+        ReadBack.regen("test", "before")
+        ReadBack.custom("test", "before")
+        ReadBack.climate("before")
+    }
+}