@@ -254,6 +254,31 @@ un réglage que l'utilisateur croit global, et il l'est.
 - Le nom du profil et le réglage « profil par défaut » restent visibles sur les trois onglets
 - Volant et sièges chauffants disposent d'un interrupteur de **prise en compte** : décoché, le
   profil ne touche pas au réglage au lieu de l'éteindre
+- **Climatisation** : bloc facultatif de l'onglet Confort, décoché par défaut, reprenant les
+  commandes du Dashboard — marche/arrêt, A/C, ventilation automatique, consigne, vitesse,
+  recyclage et dégivrages
+
+#### Bloc climatisation du profil
+Décoché, le profil ne touche pas à la climatisation : c'est le comportement de toujours, et celui
+de tous les profils déjà enregistrés. Coché, il applique ce qu'il porte au démarrage, au contact
+et à chaque application manuelle.
+
+Trois règles s'y appliquent, qui viennent du véhicule et non de l'interface :
+
+| Règle | Conséquence |
+|---|---|
+| Clim éteinte | Rien d'autre n'est écrit — une consigne posée sur une clim à l'arrêt la rallume sur certains firmwares |
+| Mode AUTO | La vitesse de ventilation n'est pas appliquée : la régler ferait sortir du mode auto |
+| « Inchangé » | Recyclage et dégivrages ne sont pas touchés — sans cette valeur, un profil qui ne s'en préoccupe pas les éteindrait |
+
+Les curseurs sont bornés à la saisie (15–33 °C, 1–11), mais les **vraies** limites sont lues sur le
+véhicule au moment d'appliquer et la consigne y est clampée : elles diffèrent entre A9 et les
+autres firmwares.
+
+> [!NOTE]
+> **Le profil est prioritaire sur l'automatisation A/C.** Si le profil actif porte un bloc
+> climatisation, l'automatisation par température ne fait rien et le journalise. Sans cette règle
+> les deux s'écriraient dessus au contact, dans un ordre que rien ne garantit.
 
 ### Compatibilité firmware inconnue (UNKNOWN)
 - Dialog d'avertissement au démarrage si le firmware n'est pas reconnu
@@ -1069,6 +1094,30 @@ users read as global, and it is.
 - The profile name and the "default profile" setting stay visible across the three tabs
 - Heated steering wheel and seats have an **apply** switch: unchecked, the profile leaves the
   setting alone instead of turning it off
+- **Air conditioning**: an optional block in the Comfort tab, unchecked by default, carrying the
+  Dashboard's own controls — on/off, A/C, auto fan, setpoint, fan speed, recirculation, defrosters
+
+#### The profile's climate block
+Unchecked, the profile does not touch the climate: that is the long-standing behaviour, and the
+one every stored profile keeps. Checked, it applies what it carries at startup, at ignition, and
+on every manual application.
+
+Three rules apply, and they come from the vehicle rather than the interface:
+
+| Rule | Consequence |
+|---|---|
+| Climate off | Nothing else is written — a setpoint sent to a stopped climate turns it back on with some firmwares |
+| AUTO mode | The fan speed is not applied: setting it would leave auto mode |
+| "Unchanged" | Recirculation and defrosters are left alone — without that value, a profile that says nothing about them would turn them off |
+
+The sliders are bounded for input (15–33 °C, 1–11), but the **real** limits are read from the
+vehicle when applying and the setpoint is clamped to them: they differ between A9 and the other
+firmwares.
+
+> [!NOTE]
+> **The profile wins over the A/C automation.** If the active profile carries a climate block, the
+> temperature automation does nothing and logs it. Without that rule the two would write over each
+> other at ignition, in an order nothing guarantees.
 
 ### Unknown firmware (UNKNOWN)
 - Warning dialog at startup when the firmware is not recognised
 
@@ -5495,6 +5495,74 @@ object MG4Hardware {
      *
      * ⚠️ Bloquant (plusieurs secondes avec les bascules) → appeler depuis un thread IO.
      */
+    /**
+     * Applique le bloc clim d'un profil — exactement ce qu'il porte, et rien d'autre.
+     *
+     * Distinct d'[applyClimatePreset], qui force marche et A/C à ON : un préréglage
+     * d'automatisation sert toujours à FAIRE fonctionner la clim, alors qu'un profil doit aussi
+     * pouvoir l'éteindre. D'où deux entrées plutôt qu'un paramètre de plus, les deux appelants
+     * n'ayant pas la même intention.
+     *
+     * Les `null` valent « ne pas y toucher », comme dans l'automatisation : un profil qui ne se
+     * prononce pas sur le dégivrage ne doit pas l'éteindre au passage.
+     */
+    fun applyProfileClimate(
+        power: Boolean,
+        ac: Boolean,
+        autoMode: Boolean,
+        targetTemp: Int,
+        fanLevel: Int,
+        defrostFront: Boolean?,
+        defrostRear: Boolean?,
+        loopMode: Int?
+    ): Boolean {
+        val state = getClimateState() ?: run {
+            AppLogger.w(CLIM_TAG, "Profil : état clim illisible → abandon")
+            return false
+        }
+        // Clim éteinte : tout le reste n'aurait aucun sens, et écrire une consigne sur une clim
+        // à l'arrêt la rallume sur certains firmwares.
+        if (!power) {
+            val ok = setClimatePower(false)
+            AppLogger.i(CLIM_TAG, "Profil : climatisation ÉTEINTE → ok=$ok")
+            return ok
+        }
+        var ok = setClimatePower(true)
+        ok = setClimateAc(ac) && ok
+        ok = setClimateTemp(targetTemp.coerceIn(state.tempMin, state.tempMax)) && ok
+
+        // ⚠️ Mode auto et ventilation manuelle s'excluent : régler une vitesse fait sortir du
+        // mode auto, et activer le mode auto reprend la main sur la vitesse. Appliquer les deux
+        // donnerait un état final décidé par le seul ordre des appels, pas par l'utilisateur.
+        if (autoMode) {
+            ok = setClimateAuto(true) && ok
+        } else {
+            ok = setClimateFan(fanLevel.coerceIn(state.fanMin, state.fanMax)) && ok
+        }
+
+        // Deux conditions : que le profil se prononce, ET que le véhicule expose le réglage.
+        if (defrostFront != null && state.defrostFront != null) {
+            ok = setClimateDefrostFront(defrostFront) && ok
+        }
+        if (defrostRear != null && state.defrostRear != null) {
+            ok = setClimateDefrostRear(defrostRear) && ok
+        }
+        if (loopMode != null) {
+            val mode = when (loopMode) {
+                0    -> LoopMode.INNER
+                1    -> LoopMode.OUTSIDE
+                else -> LoopMode.AUTO
+            }
+            ok = setClimateLoopMode(mode) && ok
+        }
+
+        AppLogger.i(CLIM_TAG, "Profil : clim=ON A/C=$ac consigne=$targetTemp " +
+            (if (autoMode) "ventilation=AUTO" else "vent=$fanLevel") +
+            " dégAV=${defrostFront ?: "inchangé"} dégAR=${defrostRear ?: "inchangé"} " +
+            "recyclage=${loopMode ?: "inchangé"} → ok=$ok")
+        return ok
+    }
+
     fun applyClimatePreset(
         targetTemp: Int,
         fanLevel: Int,
 
@@ -54,6 +54,28 @@ data class DrivingProfile(
     val escEnabled: Boolean? = null,
     val drowsinessEnabled: Boolean? = null,
     val drowsinessSensitivity: Int? = null,   // 1=Faible, 2=Standard, 3=Élevé
+    // ── Climatisation ────────────────────────────────────────────────────────────
+    /**
+     * Interrupteur du bloc clim. FAUX par défaut, et c'est ce que Gson donne aux profils
+     * enregistrés avant la fonctionnalité (champ absent → défaut de la JVM) : aucun d'eux ne se
+     * met donc à piloter la climatisation.
+     *
+     * ⚠️ C'est aussi ce qui rend les défauts ci-dessous sans conséquence. Un profil ancien les
+     * lit à 0/false, ce qui n'aurait aucun sens appliqué tel quel — mais ils ne sont JAMAIS lus
+     * tant que celui-ci est faux.
+     */
+    val hvacEnabled: Boolean = false,
+    val hvacPower: Boolean = true,
+    val hvacAc: Boolean = true,
+    /** Ventilation automatique. Exclusive de [hvacFan] : voir MG4Hardware.applyProfileClimate. */
+    val hvacAuto: Boolean = false,
+    val hvacTemp: Int = 21,
+    val hvacFan: Int = 4,
+    /** `null` = ne pas y toucher. Même convention que l'automatisation A/C. */
+    val hvacDefrostFront: Boolean? = null,
+    val hvacDefrostRear: Boolean? = null,
+    /** `null` = inchangé, sinon 0=Intérieur, 1=Extérieur, 2=Auto. */
+    val hvacLoopMode: Int? = null,
     // [BT-PROFILES] MAC de l'appareil Bluetooth associé à ce profil (null = aucun)
     val btDeviceMac: String? = null
 ) {
 
@@ -117,6 +117,23 @@ object ProfileApplier {
                 }
             }
 
+            // Climatisation — facultative, décochée par défaut. Enchaîne des bascules qui
+            // prennent plusieurs secondes, mais on est déjà sur le dispatcher IO sous verrou :
+            // rien d'autre n'écrit sur le véhicule pendant ce temps.
+            if (profile.hvacEnabled && MG4Hardware.hasClimateControl()) {
+                val climOk = MG4Hardware.applyProfileClimate(
+                    power        = profile.hvacPower,
+                    ac           = profile.hvacAc,
+                    autoMode     = profile.hvacAuto,
+                    targetTemp   = profile.hvacTemp,
+                    fanLevel     = profile.hvacFan,
+                    defrostFront = profile.hvacDefrostFront,
+                    defrostRear  = profile.hvacDefrostRear,
+                    loopMode     = profile.hvacLoopMode
+                )
+                AppLogger.i(TAG, "  Climatisation du profil appliquée → $climOk")
+            }
+
             AppLogger.i(TAG, "Profil '${profile.name}' Katman1 terminé — ok=$ok")
             onComplete?.invoke(ok)
 
 
@@ -33,6 +33,7 @@ import com.mg4.control.hardware.MG4Hardware
 import com.mg4.control.hardware.MG4Hardware.AebMode
 import com.mg4.control.hardware.MG4Hardware.Swi68Mode
 import com.mg4.control.model.RegenLevel
+import com.mg4.control.profile.ActiveProfile
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.shortcut.RegenCycle
@@ -1265,6 +1266,19 @@ class MG4ControlService : Service() {
             AppLogger.i(TAG, "Auto A/C ($origin) : clim non pilotable sur ce firmware")
             return
         }
+        // LE PROFIL EST PRIORITAIRE. S'il porte son propre bloc clim, l'automatisation n'a rien
+        // à dire : sans cette règle les deux s'écriraient dessus au contact, dans un ordre que
+        // rien ne garantit, et le résultat dépendrait de qui finit en dernier.
+        //
+        // Le profil actif est renseigné DÈS L'ENTRÉE de ProfileApplier.apply(), avant même les
+        // écritures véhicule : quand cette vérification a lieu, il désigne bien le profil du
+        // cycle en cours.
+        val profilActif = ActiveProfile.id(ctx)?.let { ProfileManager(ctx).getById(it) }
+        if (profilActif?.hvacEnabled == true) {
+            AppLogger.i(TAG, "Auto A/C ($origin) : le profil actif '${profilActif.name}' porte " +
+                "sa propre climatisation — priorité au profil")
+            return
+        }
         val since = System.currentTimeMillis() - climateAutoLastRunMs
         if (climateAutoLastRunMs != 0L && since < CLIMATE_AUTO_DEBOUNCE_MS) {
             AppLogger.i(TAG, "Auto A/C ($origin) : déjà appliquée il y a ${since / 1000}s — skip")
 
@@ -9,6 +9,7 @@ import android.widget.*
 import androidx.fragment.app.Fragment
 import androidx.navigation.fragment.findNavController
 import com.google.android.material.button.MaterialButton
+import com.google.android.material.slider.Slider
 import com.mg4.control.R
 import com.mg4.control.bluetooth.BluetoothProfileManager
 import com.mg4.control.hardware.MG4Hardware
@@ -37,6 +38,14 @@ import kotlinx.coroutines.withContext
 class ProfileEditFragment : Fragment() {
 
     companion object {
+        /** Bornes des curseurs de climatisation — les VRAIES limites sont lues sur le véhicule
+         *  au moment d'appliquer, et la consigne y est clampée. Celles-ci ne servent qu'à la
+         *  saisie, et doivent couvrir tous les firmwares (A9 accepte 17–33 °C et 1–11). */
+        const val HVAC_TEMP_MIN = 15
+        const val HVAC_TEMP_MAX = 33
+        const val HVAC_FAN_MIN  = 1
+        const val HVAC_FAN_MAX  = 11
+
         /**
          * Passage de données depuis [ProfileFragment]. Un profil complet ne tient pas
          * confortablement dans un Bundle (enums + une vingtaine de champs) et l'écran n'est ouvert
@@ -105,6 +114,19 @@ class ProfileEditFragment : Fragment() {
         var seatHeatEnabled = data.appliesSeatHeat
         var seatLeft        = data.seatHeatLeft
         var seatRight       = data.seatHeatRight
+        var hvacEnabledSel  = data.hvacEnabled
+        var hvacPowerSel    = data.hvacPower
+        var hvacAcSel       = data.hvacAc
+        var hvacAutoSel     = data.hvacAuto
+        // ⚠️ CLAMPÉS À LA LECTURE, et ce n'est pas de la prudence gratuite : Gson n'appelle pas
+        // le constructeur Kotlin, donc un profil enregistré avant cette fonctionnalité rend 0
+        // pour ces deux champs. Le curseur Material LÈVE une exception si on lui pose une valeur
+        // hors de [valueFrom, valueTo] — l'éditeur planterait à l'ouverture d'un ancien profil.
+        var hvacTempSel     = data.hvacTemp.coerceIn(HVAC_TEMP_MIN, HVAC_TEMP_MAX)
+        var hvacFanSel      = data.hvacFan.coerceIn(HVAC_FAN_MIN, HVAC_FAN_MAX)
+        var hvacDfSel       = data.hvacDefrostFront
+        var hvacDrSel       = data.hvacDefrostRear
+        var hvacLoopSel     = data.hvacLoopMode
         var adasMode        = data.adasMode
         var swi68Mode       = data.swi68AdasMode
         var swi132SasMode   = data.swi132SasMode                       // 0=Off, 2=Manuel, 3=Intelligent
@@ -220,6 +242,97 @@ class ProfileEditFragment : Fragment() {
             setBtnsEnabled(seatLeftBtns + seatRightBtns, checked)
         }
 
+        // ── Climatisation — bloc facultatif du profil ────────────────────────
+        val swHvac    = view.findViewById<Switch>(R.id.sw_hvac_enabled)
+        val btnPower  = view.findViewById<MaterialButton>(R.id.btn_hvac_power)
+        val btnAc     = view.findViewById<MaterialButton>(R.id.btn_hvac_ac)
+        val btnAuto   = view.findViewById<MaterialButton>(R.id.btn_hvac_auto)
+        val sldTemp   = view.findViewById<Slider>(R.id.sld_hvac_temp)
+        val tvTemp    = view.findViewById<TextView>(R.id.tv_hvac_temp)
+        val sldFan    = view.findViewById<Slider>(R.id.sld_hvac_fan)
+        val tvFan     = view.findViewById<TextView>(R.id.tv_hvac_fan)
+        val loopBtns  = listOf(
+            view.findViewById<MaterialButton>(R.id.btn_hvac_loop_in),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_loop_out),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_loop_auto),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_loop_none)
+        )
+        val dfBtns = listOf(
+            view.findViewById<MaterialButton>(R.id.btn_hvac_df_off),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_df_on),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_df_none)
+        )
+        val drBtns = listOf(
+            view.findViewById<MaterialButton>(R.id.btn_hvac_dr_off),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_dr_on),
+            view.findViewById<MaterialButton>(R.id.btn_hvac_dr_none)
+        )
+
+        /**
+         * Trois grisages en cascade, qui reproduisent des règles du véhicule et non des choix
+         * d'interface :
+         *  • interrupteur sur OFF → le profil ne touche pas à la clim, rien n'est modifiable ;
+         *  • clim éteinte → consigne, ventilation et le reste n'ont plus de sens ;
+         *  • mode AUTO → la ventilation manuelle est exclue, régler une vitesse ferait sortir
+         *    du mode auto (voir MG4Hardware.applyProfileClimate).
+         */
+        fun majHvac() {
+            val actif  = hvacEnabledSel
+            val allume = actif && hvacPowerSel
+            setBtnsEnabled(listOf(btnPower), actif)
+            setBtnsEnabled(listOf(btnAc, btnAuto) + loopBtns + dfBtns + drBtns, allume)
+            listOf(sldTemp, sldFan).forEach { it.isEnabled = allume }
+            sldFan.isEnabled = allume && !hvacAutoSel
+            sldTemp.alpha = if (allume) 1f else 0.35f
+            sldFan.alpha  = if (allume && !hvacAutoSel) 1f else 0.35f
+            tvTemp.alpha  = sldTemp.alpha
+            tvFan.alpha   = sldFan.alpha
+            activateBtn(btnPower, hvacPowerSel)
+            activateBtn(btnAc,    hvacAcSel)
+            activateBtn(btnAuto,  hvacAutoSel)
+        }
+
+        bindGroup(listOf(
+            loopBtns[0] to 0, loopBtns[1] to 1, loopBtns[2] to 2, loopBtns[3] to null
+        ), hvacLoopSel) { hvacLoopSel = it }
+        bindGroup(listOf(
+            dfBtns[0] to false, dfBtns[1] to true, dfBtns[2] to null
+        ), hvacDfSel) { hvacDfSel = it }
+        bindGroup(listOf(
+            drBtns[0] to false, drBtns[1] to true, drBtns[2] to null
+        ), hvacDrSel) { hvacDrSel = it }
+
+        // Bascules et non groupes : ce sont les mêmes commandes que sur le Dashboard, où un
+        // bouton unique s'allume quand le réglage est actif.
+        btnPower.setOnClickListener { hvacPowerSel = !hvacPowerSel; majHvac() }
+        btnAc.setOnClickListener    { hvacAcSel    = !hvacAcSel;    majHvac() }
+        btnAuto.setOnClickListener  { hvacAutoSel  = !hvacAutoSel;  majHvac() }
+
+        sldTemp.value = hvacTempSel.toFloat()
+        tvTemp.text = getString(R.string.profile_hvac_temp_value, hvacTempSel)
+        sldTemp.addOnChangeListener { _, v, _ ->
+            hvacTempSel = v.toInt()
+            tvTemp.text = getString(R.string.profile_hvac_temp_value, hvacTempSel)
+        }
+        sldFan.value = hvacFanSel.toFloat()
+        tvFan.text = hvacFanSel.toString()
+        sldFan.addOnChangeListener { _, v, _ ->
+            hvacFanSel = v.toInt()
+            tvFan.text = hvacFanSel.toString()
+        }
+
+        swHvac.isChecked = hvacEnabledSel
+        swHvac.setOnCheckedChangeListener { _, checked ->
+            hvacEnabledSel = checked
+            majHvac()
+        }
+        majHvac()
+
+        // Firmware sans clim pilotable : la section entière disparaît, comme la page Clim du
+        // Dashboard. Proposer des réglages qui n'écriraient rien serait pire que rien.
+        view.findViewById<View>(R.id.section_hvac)?.visibility =
+            if (MG4Hardware.hasClimateControl()) View.VISIBLE else View.GONE
+
         // ── Sections Climat — masquées si pas de chauffage (SWI69/SWI131) ────
         val hasHeat = FirmwareInfo.hasHeatFeatures()
         val heatVis = if (hasHeat) View.VISIBLE else View.GONE
@@ -537,6 +650,15 @@ class ProfileEditFragment : Fragment() {
                 lasVibrationReminder = lasVibrationReminderSel,
                 energySaving   = energySavingSel,
                 tsrEnabled     = tsrEnabledSel,
+                hvacEnabled      = hvacEnabledSel,
+                hvacPower        = hvacPowerSel,
+                hvacAc           = hvacAcSel,
+                hvacAuto         = hvacAutoSel,
+                hvacTemp         = hvacTempSel,
+                hvacFan          = hvacFanSel,
+                hvacDefrostFront = hvacDfSel,
+                hvacDefrostRear  = hvacDrSel,
+                hvacLoopMode     = hvacLoopSel,
                 btDeviceMac    = selectedBtMac   // [BT-PROFILES]
             )
             manager.save(profile)