@@ -23,6 +23,7 @@ import com.mg4.control.model.AirFlow
 import com.mg4.control.model.BatteryHeating
 import com.mg4.control.model.CustomDriveScale
 import com.mg4.control.model.DriveMode
+import com.mg4.control.model.HvacPopup
 import com.mg4.control.model.RegenLevel
 import com.mg4.control.util.FirmwareInfo
 import com.mg4.control.util.GarageMode
@@ -5477,8 +5478,17 @@ object MG4Hardware {
         val defrostFront: Boolean?,
         val defrostRear: Boolean?,
         /** Sens de l'air, valeur brute 0–7 ([AirFlow]) ; null si illisible. */
-        val airFlow: Int?
-    )
+        val airFlow: Int?,
+        /** Dernier niveau de ventilation réglé à la main ([lastManualFan]) ; null si jamais vu. */
+        val lastManualFan: Int? = null
+    ) {
+        /**
+         * Température et ventilation vues par la logique commune au pop-up HVAC, à la page Clim
+         * et aux raccourcis — c'est elle qui sait qu'en AUTO le niveau annoncé (15) n'en est pas un.
+         */
+        fun reglages() = HvacPopup.Reglages(
+            tempC, tempMin, tempMax, fanLevel, fanMin, fanMax, autoOn, lastManualFan)
+    }
 
     /**
      * Vrai si le firmware expose le SDK clim SAIC (old-SDK : SWI133/68/165 ; absent sur A9).
@@ -5508,8 +5518,36 @@ object MG4Hardware {
      */
     fun getClimateState(): ClimateState? =
         (if (isClimateA9()) getClimateStateA9() else getClimateStateOldSdk())
+            ?.let { it.copy(lastManualFan = rememberManualFan(it)) }
             ?.also { traceAirFlowChange(it) }
 
+    // ── Dernier niveau de ventilation réglé à la main ─────────────────────────
+    // En AUTO la voiture n'annonce plus de cran : elle rend 15, que les écrans d'origine affichent
+    // « AUTO ». Pour en sortir, ces écrans écrivent le dernier niveau qu'ils ont vu, ± 1 ; ils le
+    // gardent en mémoire ET en préférences (`mLastVolume` / « air_volume » dans AcCardView du
+    // launcher SWI133 et HvacView de SystemUI SWI165). On fait de même.
+    private const val PREF_LAST_MANUAL_FAN = "clim_last_manual_fan"
+    @Volatile private var sLastManualFan: Int? = null
+
+    /** Retient le niveau lu s'il en est un vrai, et rend le dernier connu. */
+    private fun rememberManualFan(state: ClimateState): Int? {
+        state.reglages().ventilationReelle
+            ?.takeIf { it in state.fanMin..state.fanMax }
+            ?.let { noteManualFan(it) }
+        return lastManualFan()
+    }
+
+    private fun noteManualFan(level: Int) {
+        if (sLastManualFan == level) return
+        sLastManualFan = level
+        sAppContext?.getSharedPreferences("mg4_settings", 0)?.edit()
+            ?.putInt(PREF_LAST_MANUAL_FAN, level)?.apply()
+    }
+
+    private fun lastManualFan(): Int? = sLastManualFan
+        ?: sAppContext?.getSharedPreferences("mg4_settings", 0)
+            ?.getInt(PREF_LAST_MANUAL_FAN, -1)?.takeIf { it >= 0 }?.also { sLastManualFan = it }
+
     private fun getClimateStateOldSdk(): ClimateState? {
         if (sAirCondition == null) sAppContext?.let { initAirCondition(it) }
         if (sAirCondition == null) return null
@@ -5611,11 +5649,13 @@ object MG4Hardware {
         else
             acSet("setDrvTemp", celsius).also { climLog("temp=$celsius", it) }
 
+    /** Écrire un niveau fait aussi SORTIR du mode AUTO (voir [setClimateAuto]). */
     fun setClimateFan(level: Int): Boolean =
-        if (isClimateA9())
+        (if (isClimateA9())
             a9Set("setFanSpeed", level).also { climLog("A9 fan=$level", it) }
         else
-            acSet("setAirVolumeLevel", level).also { climLog("fan=$level", it) }
+            acSet("setAirVolumeLevel", level).also { climLog("fan=$level", it) })
+            .also { if (it) noteManualFan(level) }
 
     /**
      * A/C — bascule, comme la recirculation. L'encodage de lecture (1=ON, 0=OFF) a été mesuré
@@ -5630,11 +5670,37 @@ object MG4Hardware {
                 acSet("setAcStatus", 1)
             }
 
-    fun setClimateAuto(on: Boolean): Boolean =
-        if (isClimateA9())
-            a9CycleTo("auto", "getAutoStatus", if (on) 1 else 0, 2, "switchAutoStatus")
-        else
-            acSet("setAutoStatus", if (on) 1 else 0).also { climLog("auto=$on", it) }
+    /**
+     * Mode AUTO : la voiture règle elle-même la ventilation et le sens de l'air.
+     *
+     * ⚠️ Sur l'ancien SDK ce n'est PAS une affectation mais un APPUI, comme l'A/C : l'écran clim
+     * d'origine (HvacView, SystemUI SWI165) envoie `setAutoStatus(1)` à chaque clic, jamais 0.
+     * Un 0 reste sans effet — c'est pourquoi AUTO ne se coupait pas (constaté sur SWI133 le
+     * 2026-10-09). Et ces écrans ne « coupent » jamais AUTO : ils en SORTENT en écrivant un
+     * niveau de ventilation, le dernier réglé à la main. On fait pareil.
+     *
+     * On n'appuie pas si AUTO est déjà actif : rien ne dit qu'un second appui ne le couperait pas.
+     */
+    fun setClimateAuto(on: Boolean): Boolean {
+        if (isClimateA9()) {
+            // Bascule relue, validée sur SWI131 ; si elle ne suffit pas à couper, même repli.
+            if (a9CycleTo("auto", "getAutoStatus", if (on) 1 else 0, 2, "switchAutoStatus")) return true
+            return !on && quitterAutoParLaVentilation()
+        }
+        val actif = acInt("getAutoStatus")?.takeIf { it >= 0 }?.let { it == 1 }
+        if (actif == on) {
+            climLog("auto=$on (déjà)", true)
+            return true
+        }
+        return if (on) acSet("setAutoStatus", 1).also { climLog("auto=true (appui)", it) }
+               else quitterAutoParLaVentilation()
+    }
+
+    private fun quitterAutoParLaVentilation(): Boolean {
+        val etat = getClimateState() ?: return false
+        val niveau = HvacPopup.niveauDeSortie(etat.reglages())
+        return setClimateFan(niveau).also { climLog("auto=false → ventilation manuelle $niveau", it) }
+    }
 
     /**
      * Recirculation — commande **CYCLIQUE**, pas une affectation.
 
@@ -8,68 +8,102 @@ import com.mg4.control.accessibility.JoystickFocus
  * Ici le joystick ne déplace aucun focus, contrairement aux popups de profils : chaque direction
  * agit directement, comme dans la fenêtre clim d'origine de la voiture.
  *
- * |          | Action           |
- * |----------|------------------|
- * | Haut     | température + 1  |
- * | Bas      | température − 1  |
- * | Droite   | ventilation + 1  |
- * | Gauche   | ventilation − 1  |
- * | Clic     | ventilation AUTO |
+ * |          | Action                                   |
+ * |----------|------------------------------------------|
+ * | Haut     | température + 1                          |
+ * | Bas      | température − 1                          |
+ * | Droite   | ventilation + 1                          |
+ * | Gauche   | ventilation − 1                          |
+ * | Clic     | mode AUTO, ou retour au réglage manuel   |
  *
  * La fenêtre se ferme au doigt, par le raccourci qui l'a ouverte, ou seule après son délai.
+ *
+ * ## Le mode AUTO
+ *
+ * En AUTO la voiture règle elle-même la ventilation (et le sens de l'air), et n'annonce plus un
+ * cran mais **15** : c'est à ce 15 que les écrans d'origine reconnaissent AUTO et l'affichent
+ * (`HvacControlDialog` et `AcCardView` de SWI133, `HvacView` de SWI165). Ces mêmes écrans ne
+ * « coupent » jamais AUTO : ils en SORTENT en écrivant un niveau de ventilation — le dernier
+ * réglé à la main, plus ou moins un cran. C'est la règle reprise ici, et partagée avec la page
+ * Clim et les raccourcis « ventilation ± ».
  */
 object HvacPopup {
 
     sealed class Action {
         data class Temperature(val cible: Int) : Action()
+
+        /** Un niveau de ventilation écrit à la main — c'est aussi ce qui fait sortir d'AUTO. */
         data class Ventilation(val cible: Int) : Action()
-        /** Ventilation automatique : la case centrale de la croix. */
-        data class Auto(val actif: Boolean) : Action()
+
+        /** Passer en mode AUTO : la case centrale de la croix. */
+        object Auto : Action()
     }
 
     /** Ce qui est lu sur la voiture ; les bornes en viennent aussi. null = illisible. */
     data class Reglages(
         val temp: Int?, val tempMin: Int, val tempMax: Int,
         val fan: Int?, val fanMin: Int, val fanMax: Int,
-        /** Ventilation AUTO ; null = illisible. */
+        /** Mode AUTO annoncé par la voiture ; null = illisible. */
         val auto: Boolean? = null,
+        /** Dernier niveau de ventilation réglé à la main, retenu avant AUTO ; null = jamais vu. */
+        val dernierNiveau: Int? = null,
     ) {
         /**
-         * Niveau de ventilation à montrer et à régler, ou null s'il n'y en a pas : en AUTO la
-         * voiture annonce 15, qui n'est pas un cran (constaté sur SWI133 le 2026-10-09). Tout ce
-         * qui dépasse le maximum est traité de même — ce 15 peut traîner un instant après AUTO.
+         * AUTO actif : la voiture le dit, ou son niveau de ventilation le trahit — au-delà du
+         * maximum ce n'est plus un cran (15), et c'est à cela que les écrans d'origine s'y fient.
          */
-        val ventilationReelle: Int? get() = fan?.takeIf { auto != true && it <= fanMax }
+        val enAuto: Boolean get() = auto == true || (fan != null && fan > fanMax)
+
+        /** Niveau de ventilation à montrer et à régler ; null en AUTO ou s'il est illisible. */
+        val ventilationReelle: Int? get() = fan?.takeIf { !enAuto }
     }
 
     /** Action portée par [commande], ou null s'il n'y a rien à écrire (butée, valeur illisible). */
     fun action(commande: JoystickFocus.Commande, reglages: Reglages): Action? = when (commande) {
         JoystickFocus.Commande.HAUT    -> pas(reglages.temp, reglages.tempMin, reglages.tempMax, +1)?.let { Action.Temperature(it) }
         JoystickFocus.Commande.BAS     -> pas(reglages.temp, reglages.tempMin, reglages.tempMax, -1)?.let { Action.Temperature(it) }
-        JoystickFocus.Commande.DROITE  -> ventilation(reglages, +1)
-        JoystickFocus.Commande.GAUCHE  -> ventilation(reglages, -1)
-        // Sans état lisible on ne bascule pas : c'est l'inverse de l'intention qui pourrait partir.
-        JoystickFocus.Commande.VALIDER -> reglages.auto?.let { Action.Auto(!it) }
+        JoystickFocus.Commande.DROITE  -> pasVentilation(reglages, +1)?.let { Action.Ventilation(it) }
+        JoystickFocus.Commande.GAUCHE  -> pasVentilation(reglages, -1)?.let { Action.Ventilation(it) }
+        JoystickFocus.Commande.VALIDER -> when {
+            // Rendre la main : le dernier niveau, tel quel.
+            reglages.enAuto        -> Action.Ventilation(niveauDeSortie(reglages))
+            reglages.auto == false -> Action.Auto
+            // Sans état lisible on n'appuie pas : sur l'ancien SDK la commande est un APPUI, et
+            // rien ne dit qu'un second ne couperait pas le mode qu'on voulait activer.
+            else                   -> null
+        }
     }
 
     /**
-     * En AUTO, un geste sur la ventilation en SORT sans écrire de niveau : il n'y a pas de cran
-     * d'où partir, et partir du 15 annoncé écrirait le maximum même pour un « moins ». La voiture
-     * annonce ensuite son vrai niveau, et c'est le geste suivant qui le règle.
+     * Niveau de ventilation à écrire pour un cran de plus ([sens] = +1) ou de moins (−1) ; null
+     * s'il n'y a rien à écrire (butée, niveau illisible).
+     *
+     * En AUTO on repart du dernier niveau réglé à la main — surtout pas du 15 annoncé, d'où un
+     * « moins » écrirait le MAXIMUM — et on écrit MÊME en butée : c'est cette écriture qui rend
+     * la main, et l'utilisateur vient de demander à régler lui-même.
+     */
+    fun pasVentilation(reglages: Reglages, sens: Int): Int? =
+        if (reglages.enAuto) (niveauDeSortie(reglages) + sens).coerceIn(reglages.fanMin, reglages.fanMax)
+        else pas(reglages.fan, reglages.fanMin, reglages.fanMax, sens)
+
+    /**
+     * Niveau à écrire pour quitter AUTO sans rien changer d'autre : le dernier réglé à la main.
+     * Faute de l'avoir jamais vu (application neuve, voiture en AUTO depuis toujours), le milieu
+     * de l'échelle — ni le minimum ni le maximum ne feraient un point de départ raisonnable.
      */
-    private fun ventilation(reglages: Reglages, sens: Int): Action? =
-        if (reglages.auto == true) Action.Auto(false)
-        else pas(reglages.ventilationReelle, reglages.fanMin, reglages.fanMax, sens)?.let { Action.Ventilation(it) }
+    fun niveauDeSortie(reglages: Reglages): Int =
+        (reglages.dernierNiveau ?: ((reglages.fanMin + reglages.fanMax) / 2))
+            .coerceIn(reglages.fanMin, reglages.fanMax)
 
     // ── Taille de la fenêtre ─────────────────────────────────────────────────
-    private const val LARGEUR_DP = 780f      // la carte de overlay_hvac_popup.xml
+    private const val LARGEUR_DP = 900f      // la carte de overlay_hvac_popup.xml
     private const val HAUTEUR_DP = 390f      // sa hauteur en texte « Standard »
-    private const val PART_LARGEUR = 0.56f
+    private const val PART_LARGEUR = 0.63f
     private const val PART_HAUTEUR = 0.72f
 
     /**
      * Agrandissement à appliquer à la fenêtre, dessinée pour [LARGEUR_DP] × [HAUTEUR_DP] dp, pour
-     * qu'elle prenne la même part de l'ÉCRAN quelle que soit sa densité : au plus 56 % de la
+     * qu'elle prenne la même part de l'ÉCRAN quelle que soit sa densité : au plus 63 % de la
      * largeur et 72 % de la hauteur. Le reste de la hauteur laisse passer la barre d'état, le
      * texte « Très grand » et la ligne d'avertissement sans déborder.
      *