@@ -1815,11 +1815,31 @@ object MG4Hardware {
         val bean = if (family == CustomDriveScale.Family.VSM_68) customFromBean(method) else null
         // La première voie qui rend une position connue l'emporte ; -1 est le « je ne sais pas »
         // commun aux deux (service non lié côté SDK, exception côté VPM).
-        val reponses = listOfNotNull(direct, bean).filter { it >= 0 }
-        reponses.forEach { raw ->
-            CustomDriveScale.index(setting, raw, family)?.let { return CustomSetting.Known(it) }
+        listOf("directe" to direct, "instantané" to bean).forEach { (nom, raw) ->
+            if (raw == null || raw < 0) return@forEach
+            CustomDriveScale.index(setting, raw, family)?.let {
+                logCustomSource(setting, nom, direct, bean)
+                return CustomSetting.Known(it)
+            }
         }
-        return reponses.firstOrNull()?.let { CustomSetting.Unknown(it) } ?: CustomSetting.Unavailable
+        val repondu = listOfNotNull(direct, bean).firstOrNull { it >= 0 }
+        return repondu?.let { CustomSetting.Unknown(it) } ?: CustomSetting.Unavailable
+    }
+
+    /**
+     * Une ligne par réglage et par démarrage : quelle voie a répondu, et ce que rendaient les
+     * autres. C'est le seul moyen de savoir laquelle garder — une fois les six firmwares passés,
+     * les voies inutiles et ce journal partent ensemble.
+     */
+    private val sCustomSourceSeen =
+        java.util.Collections.synchronizedSet(mutableSetOf<CustomDriveScale.Setting>())
+
+    private fun logCustomSource(
+        setting: CustomDriveScale.Setting, retenue: String, direct: Int?, bean: Int?
+    ) {
+        if (!sCustomSourceSeen.add(setting)) return
+        AppLogger.i(CUSTOM_TAG, "SOURCE $setting : voie $retenue retenue — " +
+            "directe=${direct ?: "muette"} · instantané=${bean ?: "n/a"} (${customFamily()})")
     }
 
     /** Puissance du mode Personnalisé. [index] : 0=Éco, 1=Normal, 2=Sport. */
@@ -1945,15 +1965,28 @@ object MG4Hardware {
      */
     fun getDriveMode(): DriveMode? {
         val rawCpm = getIntPropertyCPM(PROP_DRIVE_MODE, AREA_GLOBAL)
-        DriveMode.fromValueOrNull(rawCpm)?.let { return it }
+        DriveMode.fromValueOrNull(rawCpm)?.let {
+            logDriveModeSource("propriété", rawCpm, null)
+            return it
+        }
         val rawSdk = (callVsm(driveModeGetter()) as? Int)
         val mode = rawSdk?.let { DriveMode.fromValueOrNull(it) }
-        if (mode == null && logEnabled)
+        if (mode != null) logDriveModeSource("SDK ${driveModeGetter()}", rawCpm, rawSdk)
+        else if (logEnabled)
             AppLogger.d(TAG, "  mode de conduite illisible : CPM=$rawCpm " +
                 "${driveModeGetter()}=${rawSdk ?: "muet"}")
         return mode
     }
 
+    /** Idem pour le mode de conduite : une ligne au premier succès, puis silence. */
+    private val sDriveModeSourceLogged = java.util.concurrent.atomic.AtomicBoolean(false)
+
+    private fun logDriveModeSource(retenue: String, rawCpm: Int, rawSdk: Int?) {
+        if (sDriveModeSourceLogged.getAndSet(true)) return
+        AppLogger.i(CUSTOM_TAG, "SOURCE mode de conduite : voie $retenue retenue — " +
+            "CPM 0x${PROP_DRIVE_MODE.toString(16)}=$rawCpm · ${driveModeGetter()}=${rawSdk ?: "non interrogé"}")
+    }
+
     /** Méthode du SDK qui rend le mode de conduite (l'A9 la nomme autrement). */
     private fun driveModeGetter(): String =
         if (customFamily() == CustomDriveScale.Family.A9) "getDrivingMode" else "getDriveMode"
 
@@ -130,6 +130,16 @@ object PowerWindows {
     }
 
     /** Enregistre la calibration ; l'assistant finit sur une montée complète, la vitre est donc fermée. */
+    /**
+     * Vitres sans capteur dont la calibration manque encore.
+     *
+     * Sert de garde-fou à la fermeture automatique : elle ferme au temps mesuré, une vitre non
+     * calibrée partirait sur la course par défaut sans que personne puisse le vérifier depuis
+     * l'extérieur de la voiture.
+     */
+    fun uncalibrated(context: Context): List<PowerWindow> =
+        PowerWindow.entries.filter { !it.hasPositionSensor && calibration(context, it) == null }
+
     fun saveCalibration(context: Context, window: PowerWindow, cal: WindowCalibration) {
         context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit {
             putLong(calKey(window, "down_ms"), cal.downMs)
 
@@ -1,6 +1,8 @@
 package com.mg4.control.hardware
 
 import android.content.Context
+import android.media.AudioManager
+import android.media.ToneGenerator
 import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
@@ -35,9 +37,21 @@ object WindowAutoClose {
     private const val KEY_TIME_MIN = "win_autoclose_time_min"
     private const val KEY_BOTH = "win_autoclose_both"
     private const val KEY_DELAY_S = "win_autoclose_delay_s"
+    private const val KEY_BEEP = "win_autoclose_beep"
+    private const val KEY_BEEP_VOLUME = "win_autoclose_beep_volume"
 
     private const val TICK_MS = 1_000L
 
+    /** Bip d'avertissement, repris de winclose : un par seconde pendant le délai. */
+    private const val BEEP_MS = 150
+    /** Volume du [ToneGenerator], en pour cent. Le minimum n'est pas 0 : couper, c'est décocher. */
+    const val BEEP_VOLUME_MIN = 10
+    const val BEEP_VOLUME_MAX = 100
+    const val BEEP_VOLUME_STEP = 5
+    const val BEEP_VOLUME_DEFAULT = 80
+    /** Bip d'essai hors surveillance : on rend la piste audio peu après. */
+    private const val PREVIEW_RELEASE_MS = 2_000L
+
     enum class Result { PENDING, DONE, PARTIAL, CANCELLED }
 
     data class Status(
@@ -58,6 +72,8 @@ object WindowAutoClose {
         val timeMin: Int,
         val requireBoth: Boolean,
         val delayS: Int,
+        val beep: Boolean,
+        val beepVolume: Int,
     ) {
         fun toArming() = Arming(
             speedKmh = if (speedOn) speedKmh.toFloat() else null,
@@ -71,6 +87,12 @@ object WindowAutoClose {
     private var running = false
     private var lastResult: Result? = null
     private var lastResultAt = 0L
+    /** Recopié depuis les réglages : le tic ne doit pas relire les préférences chaque seconde. */
+    private var beepOn = false
+    private var beepVolume = BEEP_VOLUME_DEFAULT
+    private var tone: ToneGenerator? = null
+    /** Volume du générateur en place : il se fixe à la construction, pas à l'appel. */
+    private var toneVolume = -1
 
     fun isEnabled(context: Context): Boolean =
         context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).getBoolean(KEY_ENABLED, false)
@@ -94,6 +116,11 @@ object WindowAutoClose {
             requireBoth = p.getBoolean(KEY_BOTH, false),
             delayS = p.getInt(KEY_DELAY_S, WindowAutoCloseTrigger.DELAY_DEFAULT_S)
                 .coerceIn(WindowAutoCloseTrigger.DELAY_MIN_S, WindowAutoCloseTrigger.DELAY_MAX_S),
+            // Décoché par défaut : le bip est une gêne pour qui n'en veut pas, et la fermeture
+            // automatique est déjà une option qu'on active en connaissance de cause.
+            beep = p.getBoolean(KEY_BEEP, false),
+            beepVolume = p.getInt(KEY_BEEP_VOLUME, BEEP_VOLUME_DEFAULT)
+                .coerceIn(BEEP_VOLUME_MIN, BEEP_VOLUME_MAX),
         )
     }
 
@@ -106,6 +133,8 @@ object WindowAutoClose {
             putInt(KEY_TIME_MIN, s.timeMin)
             putBoolean(KEY_BOTH, s.requireBoth)
             putInt(KEY_DELAY_S, s.delayS)
+            putBoolean(KEY_BEEP, s.beep)
+            putInt(KEY_BEEP_VOLUME, s.beepVolume)
         }
         main.post { apply(s) }
         AppLogger.i(TAG, "fermeture auto : réglages = ${describe(s)}")
@@ -122,6 +151,9 @@ object WindowAutoClose {
     private fun apply(s: Settings) {
         trigger.arming = s.toArming()
         trigger.delayMs = s.delayS * 1000L
+        beepOn = s.beep
+        beepVolume = s.beepVolume
+        if (!beepOn) releaseTone()
     }
 
     private fun describe(s: Settings): String {
@@ -131,7 +163,8 @@ object WindowAutoClose {
         )
         val arming = if (parts.isEmpty()) "aucune condition (jamais armée)"
                      else parts.joinToString(if (s.requireBoth) " ET " else " OU ")
-        return "armement $arming, délai ${s.delayS} s"
+        val bip = if (s.beep) "oui à ${s.beepVolume} %" else "non"
+        return "armement $arming, délai ${s.delayS} s, bip $bip"
     }
 
     // ── Surveillance ────────────────────────────────────────────────────────
@@ -163,6 +196,7 @@ object WindowAutoClose {
             running = false
             main.removeCallbacks(tick)
             ReadyWatcher.remove(readyListener)
+            releaseTone()
             if (trigger.cancelPending()) {
                 setResult(Result.CANCELLED)
                 AppLogger.i(TAG, "fermeture auto : attente abandonnée (option désactivée)")
@@ -210,16 +244,67 @@ object WindowAutoClose {
 
     private fun handle(outcome: WindowAutoCloseTrigger.Outcome) {
         when (outcome.action) {
-            Action.SCHEDULE -> setResult(Result.PENDING)
+            Action.SCHEDULE -> {
+                setResult(Result.PENDING)
+                beep()
+            }
             Action.CANCEL   -> {
                 setResult(Result.CANCELLED)
+                releaseTone()
                 AppLogger.i(TAG, "fermeture auto : annulée (${outcome.reason})")
             }
-            Action.CLOSE    -> closeAll(outcome.reason)
-            Action.NONE     -> Unit
+            Action.CLOSE    -> {
+                releaseTone()
+                closeAll(outcome.reason)
+            }
+            // Rien à faire, sauf le bip de chaque seconde d'attente.
+            Action.NONE     -> if (trigger.isPending) beep()
+        }
+    }
+
+    /**
+     * Un bip par seconde pendant le délai, comme winclose : le seul avertissement possible pour
+     * qui est à côté de la voiture, l'écran ne se voyant pas de l'extérieur. Décoché par défaut.
+     * Un échec (piste audio occupée, flux refusé) ne doit jamais empêcher la fermeture.
+     */
+    private fun beep() {
+        if (beepOn) playBeep(beepVolume)
+    }
+
+    /**
+     * Bip d'essai pendant que l'utilisateur déplace le curseur : régler un volume à l'aveugle
+     * n'aurait pas de sens. Muet si l'avertissement est décoché.
+     */
+    fun previewBeep(context: Context) {
+        val s = settings(context)
+        if (!s.beep) return
+        playBeep(s.beepVolume)
+        // Hors surveillance, personne ne viendra rendre la piste audio : on s'en charge.
+        if (!running) {
+            main.removeCallbacks(releasePreview)
+            main.postDelayed(releasePreview, PREVIEW_RELEASE_MS)
         }
     }
 
+    private val releasePreview = Runnable { if (!running) releaseTone() }
+
+    private fun playBeep(volume: Int) {
+        runCatching {
+            // Le volume est figé à la construction : un réglage déplacé impose un nouveau générateur.
+            if (toneVolume != volume) releaseTone()
+            val t = tone ?: ToneGenerator(AudioManager.STREAM_NOTIFICATION, volume)
+                .also { tone = it; toneVolume = volume }
+            t.startTone(ToneGenerator.TONE_PROP_BEEP, BEEP_MS)
+        }.onFailure { AppLogger.w(TAG, "fermeture auto : bip impossible (${it.javaClass.simpleName}: ${it.message})") }
+    }
+
+    /** Le générateur tient une piste audio : on le rend dès que l'attente est finie. */
+    private fun releaseTone() {
+        tone?.release()
+        tone = null
+        toneVolume = -1
+    }
+
     private fun closeAll(reason: String) {
         val context = MG4Hardware.appContext()
         if (context != null && GarageMode.isOn(context)) {
 
@@ -31,10 +31,12 @@ import com.mg4.control.model.DriveMode
 import com.mg4.control.bluetooth.BluetoothProfileManager
 import com.mg4.control.debug.AppLogger
 import com.mg4.control.hardware.MG4Hardware
+import com.mg4.control.hardware.PowerWindows
 import com.mg4.control.hardware.WindowAutoClose
 import com.mg4.control.hardware.MG4Hardware.AebMode
 import com.mg4.control.hardware.MG4Hardware.Swi68Mode
 import com.mg4.control.model.RegenLevel
+import com.mg4.control.model.WindowCommand
 import com.mg4.control.profile.ActiveProfile
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
@@ -920,6 +922,23 @@ class MG4ControlService : Service() {
             return
         }
 
+        // Vitres : action directe, aucune bascule — une pression = une course complète.
+        // La FERMETURE emprunte le chemin de la fermeture automatique, le seul qui aille au bout
+        // sans personne devant l'écran : au volant, l'utilisateur ne regarde pas l'application.
+        if (action == ShortcutAction.WINDOWS_OPEN_ALL || action == ShortcutAction.WINDOWS_CLOSE_ALL) {
+            val ouvrir = action == ShortcutAction.WINDOWS_OPEN_ALL
+            AppLogger.i(TAG, "SHORTCUT vitres : tout ${if (ouvrir) "ouvrir" else "fermer"}")
+            PowerWindows.prepare()
+            if (ouvrir) {
+                PowerWindows.autoAll(WindowCommand.Direction.DOWN)
+            } else {
+                PowerWindows.closeAllAutomatically { ok ->
+                    AppLogger.i(TAG, "SHORTCUT vitres : fermeture ${if (ok) "complète" else "incomplète"}")
+                }
+            }
+            return
+        }
+
         // VEHICLE_POWER_OFF : check P → confirmation (overlay) → extinction. Sinon message "en P".
         if (action == ShortcutAction.VEHICLE_POWER_OFF) {
             showVehiclePowerOffConfirm()
 
@@ -49,7 +49,13 @@ enum class ShortcutAction(val id: Int) {
     // Volume : réglage du VÉHICULE, contrairement aux trois précédentes. Il ne dépend d'aucune
     // application et fonctionne donc même quand les touches média restent sans effet.
     VOLUME_UP(34),
-    VOLUME_DOWN(35);
+    VOLUME_DOWN(35),
+
+    // Vitres : actions directes, sans état à suivre — chaque pression lance la course complète
+    // des quatre vitres. La voiture ne renvoyant rien sur leur position (hors vitre conducteur),
+    // une bascule mémorisée n'aurait rien à quoi se raccrocher.
+    WINDOWS_OPEN_ALL(36),
+    WINDOWS_CLOSE_ALL(37);
 
     companion object {
         fun fromId(id: Int) = entries.firstOrNull { it.id == id } ?: NONE
 
@@ -26,6 +26,9 @@ class AutomationFragment : Fragment() {
 
     private var profiles: List<DrivingProfile> = emptyList()
 
+    /** Carte des vitres : le panneau survit à la vue, comme au tableau de bord avant le déplacement. */
+    private val windowsPanel = WindowsPanel()
+
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
     ): View = inflater.inflate(R.layout.fragment_automation, container, false)
@@ -51,6 +54,7 @@ class AutomationFragment : Fragment() {
             prefs.edit().putBoolean(AutomationSettings.KEY_ENABLED, checked).apply()
         }
         bindExpander(view.findViewById(R.id.btn_automation_expand), rowConfig, expanded = enabled)
+        bindWindowsCard(view)
 
         fun commitTemp() {
             val clamped = AutomationSettings.clampTemp(inputTemp.text.toString().toIntOrNull())
@@ -286,6 +290,9 @@ class AutomationFragment : Fragment() {
             val prefs = requireContext().getSharedPreferences(AutomationSettings.PREFS, Context.MODE_PRIVATE)
             setupSpinner(sp, prefs)
         }
+        // Carte des vitres : le sondage ne reprend que si elle est restée dépliée.
+        if (view?.findViewById<View>(R.id.row_windows_config)?.visibility == View.VISIBLE)
+            windowsPanel.onShown()
     }
 
     private fun setupSpinner(spinner: Spinner, prefs: android.content.SharedPreferences) {
@@ -319,14 +326,38 @@ class AutomationFragment : Fragment() {
      * en repliant la carte. L'etat initial suit quand meme l'activation — une automatisation
      * eteinte s'ouvre repliee, ce qui reproduit le comportement precedent.
      */
-    private fun bindExpander(btn: MaterialButton, content: View, expanded: Boolean) {
+    private fun bindExpander(
+        btn: MaterialButton, content: View, expanded: Boolean, onToggle: ((Boolean) -> Unit)? = null
+    ) {
         var open = expanded
         fun apply() {
             content.visibility = if (open) View.VISIBLE else View.GONE
             btn.text = if (open) "▾" else "▸"   // chevron bas / droite
+            onToggle?.invoke(open)
         }
         apply()
         btn.setOnClickListener { open = !open; apply() }
     }
 
+    /**
+     * Carte des vitres, repliée par défaut : la commande manuelle et la calibration ne sont pas
+     * des automatismes, on ne les ouvre que quand on les cherche.
+     *
+     * Le sondage des positions (et donc l'abonnement véhicule) ne tourne que carte ouverte ET
+     * écran au premier plan — ailleurs il consommerait pour une valeur que personne ne regarde.
+     */
+    private fun bindWindowsCard(view: View) {
+        windowsPanel.bind(view)
+        val content = view.findViewById<View>(R.id.row_windows_config)
+        bindExpander(view.findViewById(R.id.btn_windows_expand), content, expanded = false) { open ->
+            if (open && isResumed) windowsPanel.onShown() else windowsPanel.onHidden()
+        }
+    }
+
+    /** Écran quitté : plus de sondage, et aucune vitre ne reste en mouvement sans surveillance. */
+    override fun onPause() {
+        super.onPause()
+        windowsPanel.onHidden()
+    }
+
 }