@@ -51,6 +51,31 @@ L'application communique avec le véhicule via le SDK propriétaire SAIC, en acc
 - **Mode de conduite** : ECO / NORMAL / SPORT / SNOW / CUSTOM
 - **Régénération** : Off / Faible / Moyen / Fort / Adaptatif / 1 Pédale
 
+#### Mode de conduite Personnalisé
+Trois réglages que le véhicule n'expose que dans ce mode : **puissance** (Éco / Normal / Sport),
+**direction** et **force sur la pédale** (Confort / Normal / Sport). Disponibles sur les six
+firmwares, par deux voies distinctes — signaux `VehiclePropertyManager` en SWI133/68/165,
+méthodes `CarVehicleSettingClient` sur A9.
+
+Présents à deux endroits, avec une règle d'apparition différente :
+
+| Écran | La carte apparaît quand |
+|---|---|
+| Dashboard, onglet Conduite | la **voiture** est en mode Personnalisé, y compris si le mode a été mis depuis l'écran d'origine |
+| Éditeur de profil, onglet Conduite | le **profil** en cours d'édition a Personnalisé pour mode |
+
+Sur le Dashboard, une ligne dont le véhicule ne rend pas l'état disparaît : la commande existe sur
+tous les firmwares, mais rien ne garantit que la finition porte l'équipement.
+
+> [!WARNING]
+> Les trois réglages n'ont pas la même échelle côté véhicule, et la pédale est un piège :
+> **Normal y vaut 0**, pas la valeur du milieu. La puissance vaut 1/2/3 en SWI133/68/165 mais
+> 2/3/4 sur A9, où la voiture réutilise l'échelle des modes de conduite. L'application ne
+> manipule donc jamais ces nombres — elle passe un index 0/1/2 et la conversion vit dans
+> `MG4Hardware`.
+
+Dans un profil, ils ne sont écrits que si son mode de conduite est Personnalisé, et un profil
+enregistré avant cette fonctionnalité n'écrit rien tant qu'il n'a pas été rouvert et sauvegardé.
 ### Sécurité
 - **ESC** : ON / OFF
 - **Avertissement de somnolence** : ON / OFF, avec sensibilité Faible / Standard / Élevé
@@ -899,6 +924,30 @@ The app communicates with the vehicle through the proprietary SAIC SDK, accessin
 - **Drive mode**: ECO / NORMAL / SPORT / SNOW / CUSTOM
 - **Regenerative braking**: Off / Low / Medium / High / Adaptive / One Pedal
 
+#### Custom drive mode
+Three settings the vehicle only exposes in that mode: **power** (Eco / Normal / Sport),
+**steering** and **pedal force** (Comfort / Normal / Sport). Available on all six firmwares
+through two distinct routes — `VehiclePropertyManager` signals on SWI133/68/165, and
+`CarVehicleSettingClient` methods on A9.
+
+Present in two places, with a different reveal rule:
+
+| Screen | The card appears when |
+|---|---|
+| Dashboard, Driving tab | the **car** is in Custom mode, including when it was set from the stock screen |
+| Profile editor, Driving tab | the **profile** being edited has Custom as its mode |
+
+On the Dashboard, a row whose state the vehicle does not report disappears: the command exists on
+every firmware, but nothing guarantees the trim carries the hardware.
+
+> [!WARNING]
+> The three settings do not share one scale, and the pedal is a trap: **Normal is 0 there**, not
+> the middle value. Power is 1/2/3 on SWI133/68/165 but 2/3/4 on A9, where the car reuses the
+> drive-mode scale. The app therefore never handles those numbers — it passes a 0/1/2 index and
+> the conversion lives in `MG4Hardware`.
+
+In a profile they are only written when its drive mode is Custom, and a profile saved before this
+feature writes nothing until it has been reopened and saved.
 ### Safety
 - **ESC**: ON / OFF
 - **Drowsiness warning**: ON / OFF, with Low / Standard / High sensitivity
 
@@ -1686,6 +1686,115 @@ object MG4Hardware {
         return ok
     }
 
+    // ── Mode de conduite Personnalisé : puissance, direction, pédale ─────────
+    //
+    // Ces trois réglages n'existent que dans le mode Personnalisé du véhicule. Ils sont présents
+    // sur les six firmwares, mais par deux voies différentes.
+
+    /**
+     * Signaux du SDK vehiclesettings (SWI133/68/165).
+     *
+     * ⚠️ Ce ne sont PAS des identifiants de propriété VHAL : l'app d'origine passe par
+     * `VehiclePropertyManager` avec sa propre numérotation. Les équivalents VHAL existent
+     * (0x2140a18c / 0x2140a18d / 0x2140a18e) si cette voie devenait un jour nécessaire.
+     */
+    private const val SIG_CUSTOM_POWER    = 0x2040002
+    private const val SIG_CUSTOM_STEERING = 0x2040004
+    private const val SIG_CUSTOM_PEDAL    = 0x2040005
+
+    /** Index manipulés par l'application — jamais les valeurs véhicule, voir [valeurPuissance]. */
+    object CustomDrive {
+        const val ECO_COMFORT = 0
+        const val NORMAL      = 1
+        const val SPORT       = 2
+    }
+
+    /**
+     * A9 : SWI69, SWI131, SWI132. Même ensemble que la clim, mais fonction distincte à dessein —
+     * changer la règle d'un domaine ne doit pas déplacer l'autre en silence.
+     */
+    private fun isDriveCustomA9(): Boolean {
+        val gen = FirmwareInfo.getGeneration()
+        return gen == FirmwareInfo.Gen.SWI69 || gen == FirmwareInfo.Gen.SWI131 ||
+               gen == FirmwareInfo.Gen.SWI132
+    }
+
+    // ⚠️ TROIS ÉCHELLES DIFFÉRENTES, relevées dans le code d'origine des deux familles :
+    //  • direction : 1/2/3 partout ;
+    //  • pédale : 1/0/2 partout — Normal vaut ZÉRO, et non la valeur du milieu. Le smali SWI133
+    //    réassigne le registre entre deux branches, ce qui se lit 1/2/3 si on va trop vite ;
+    //    le dispatch A9 sur les libellés comfort/normal/sport donne le même résultat ;
+    //  • puissance : 1/2/3 en old-SDK mais 2/3/4 sur A9, où la voiture réutilise l'échelle des
+    //    modes de conduite (ÉCO=2, NORMAL=3, SPORT=4).
+    //
+    // D'où l'index 0/1/2 exposé au reste de l'application : personne d'autre ne manipule ces
+    // nombres, et une échelle qui changerait ne se corrige qu'ici.
+    private fun valeurPuissance(index: Int): Int = index + (if (isDriveCustomA9()) 2 else 1)
+    private fun valeurDirection(index: Int): Int = index + 1
+    private fun valeurPedale(index: Int): Int = when (index) {
+        CustomDrive.ECO_COMFORT -> 1
+        CustomDrive.SPORT       -> 2
+        else                    -> 0
+    }
+
+    private fun indexPuissance(v: Int): Int? =
+        (v - (if (isDriveCustomA9()) 2 else 1)).takeIf { it in 0..2 }
+    private fun indexDirection(v: Int): Int? = (v - 1).takeIf { it in 0..2 }
+    private fun indexPedale(v: Int): Int? = when (v) {
+        1    -> CustomDrive.ECO_COMFORT
+        0    -> CustomDrive.NORMAL
+        2    -> CustomDrive.SPORT
+        else -> null
+    }
+
+    /** Puissance en chevaux du mode Personnalisé. [index] : 0=Éco, 1=Normal, 2=Sport. */
+    fun setCustomPower(index: Int): Boolean {
+        if (index !in 0..2) return false
+        val v = valeurPuissance(index)
+        if (logEnabled) AppLogger.i(TAG, "setCustomPower → index=$index valeur=$v")
+        return if (isDriveCustomA9()) callVsmVoid("setDrivingPowerTrainMode", v)
+               else setIntPropertyVpmRecovery(SIG_CUSTOM_POWER, v)
+    }
+
+    /** Direction du mode Personnalisé. [index] : 0=Confort, 1=Normal, 2=Sport. */
+    fun setCustomSteering(index: Int): Boolean {
+        if (index !in 0..2) return false
+        val v = valeurDirection(index)
+        if (logEnabled) AppLogger.i(TAG, "setCustomSteering → index=$index valeur=$v")
+        // A9 : setSteeringMode, et NON setDrivingEpsMode — les deux existent, seule la première
+        // est appelée par l'app d'origine. Vérifié en traçant fragment → presenter → model.
+        return if (isDriveCustomA9()) callVsmVoid("setSteeringMode", v)
+               else setIntPropertyVpmRecovery(SIG_CUSTOM_STEERING, v)
+    }
+
+    /** Force exercée sur la pédale. [index] : 0=Confort, 1=Normal, 2=Sport. */
+    fun setCustomPedal(index: Int): Boolean {
+        if (index !in 0..2) return false
+        val v = valeurPedale(index)
+        if (logEnabled) AppLogger.i(TAG, "setCustomPedal → index=$index valeur=$v")
+        return if (isDriveCustomA9()) callVsmVoid("setBrakePedalMode", v)
+               else setIntPropertyVpmRecovery(SIG_CUSTOM_PEDAL, v)
+    }
+
+    /**
+     * Lectures — `null` si le véhicule ne répond pas OU rend une valeur hors échelle.
+     *
+     * C'est le seul garde-fou honnête pour savoir si la voiture porte réellement ces réglages :
+     * ils existent sur les six firmwares, mais rien ne dit qu'ils sont montés sur toutes les
+     * finitions. Un `null` fait masquer la ligne plutôt que d'offrir un bouton sans effet.
+     */
+    fun getCustomPower(): Int? = indexPuissance(
+        if (isDriveCustomA9()) (callVsm("getDrivingPowerTrainMode") as? Int) ?: -1
+        else getIntPropertyVpm(SIG_CUSTOM_POWER))
+
+    fun getCustomSteering(): Int? = indexDirection(
+        if (isDriveCustomA9()) (callVsm("getSteeringMode") as? Int) ?: -1
+        else getIntPropertyVpm(SIG_CUSTOM_STEERING))
+
+    fun getCustomPedal(): Int? = indexPedale(
+        if (isDriveCustomA9()) (callVsm("getBrakePedalMode") as? Int) ?: -1
+        else getIntPropertyVpm(SIG_CUSTOM_PEDAL))
+
     fun setRegenLevel(level: RegenLevel): Boolean {
         if (logEnabled) AppLogger.i(TAG, "setRegenLevel → ${level.label} (${level.value})")
         return if (level == RegenLevel.ONE_PEDAL) {
 
@@ -54,6 +54,20 @@ data class DrivingProfile(
     val escEnabled: Boolean? = null,
     val drowsinessEnabled: Boolean? = null,
     val drowsinessSensitivity: Int? = null,   // 1=Faible, 2=Standard, 3=Élevé
+    // ── Mode de conduite Personnalisé ────────────────────────────────────────
+    //
+    // Index 0/1/2 (Éco ou Confort, Normal, Sport) — jamais les valeurs véhicule, dont l'échelle
+    // varie d'un firmware à l'autre. La conversion vit dans MG4Hardware.
+    //
+    // ⚠️ NULLABLES À DESSEIN, comme les chauffages : Gson n'appelle pas le constructeur Kotlin,
+    // donc un profil enregistré avant cette fonctionnalité rend `null` et n'écrit RIEN. Un
+    // `Int = 1` aurait rendu 0 (défaut de la JVM) et se serait appliqué comme « Éco/Confort »
+    // sur tous les profils Personnalisé existants.
+    //
+    // Ils ne sont appliqués que si [driveMode] vaut CUSTOM : le véhicule les ignore ailleurs.
+    val customPower: Int? = null,
+    val customSteering: Int? = null,
+    val customPedal: Int? = null,
     // ── Climatisation ────────────────────────────────────────────────────────────
     /**
      * Interrupteur du bloc clim. FAUX par défaut, et c'est ce que Gson donne aux profils
 
@@ -3,6 +3,7 @@ package com.mg4.control.profile
 import com.mg4.control.debug.AppLogger
 import com.mg4.control.hardware.MG4Hardware
 import com.mg4.control.hardware.MG4Hardware.Swi68Mode
+import com.mg4.control.model.DriveMode
 import com.mg4.control.model.DrivingProfile
 import com.mg4.control.util.FirmwareInfo
 import kotlinx.coroutines.CoroutineScope
@@ -117,6 +118,20 @@ object ProfileApplier {
                 }
             }
 
+            // Mode Personnalisé — les trois réglages n'ont d'effet que dans ce mode, les
+            // écrire ailleurs serait au mieux sans effet, au pire refusé par le véhicule.
+            if (profile.driveMode == DriveMode.CUSTOM) {
+                profile.customPower?.let {
+                    AppLogger.i(TAG, "  Puissance personnalisée=$it → ${MG4Hardware.setCustomPower(it)}")
+                }
+                profile.customSteering?.let {
+                    AppLogger.i(TAG, "  Direction personnalisée=$it → ${MG4Hardware.setCustomSteering(it)}")
+                }
+                profile.customPedal?.let {
+                    AppLogger.i(TAG, "  Pédale personnalisée=$it → ${MG4Hardware.setCustomPedal(it)}")
+                }
+            }
+
             // 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.
 
@@ -17,6 +17,7 @@ import androidx.fragment.app.Fragment
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.slider.Slider
 import com.mg4.control.R
+import com.mg4.control.debug.AppLogger
 import com.mg4.control.hardware.MG4Hardware
 import com.mg4.control.hardware.MG4Hardware.AebMode
 import com.mg4.control.hardware.MG4Hardware.AebSensitivity
@@ -86,6 +87,12 @@ class DashboardFragment : Fragment() {
     /** Dernier mode de conduite connu — nécessaire pour arbitrer les exclusions SNOW / Éco énergie. */
     private var currentDriveMode: DriveMode? = null
 
+    // ── Mode Personnalisé — puissance / direction / pédale ───────────────────
+    // Une entrée par ligne : le bouton, et l'index qu'il représente (0/1/2).
+    private val customPowerButtons  = mutableMapOf<Int, Button>()
+    private val customSteerButtons  = mutableMapOf<Int, Button>()
+    private val customPedalButtons  = mutableMapOf<Int, Button>()
+
     // ── AEB : page 0 pour VSM-based, page 1 (SWI133) pour les autres ───────────
     private var switchAeb: Switch? = null
     private var btnAebAlarm: Button? = null
@@ -320,6 +327,17 @@ class DashboardFragment : Fragment() {
         switchSoundWarning = view.findViewById(R.id.switch_sound_warning)
         alertsGroupSwi133  = view.findViewById(R.id.alerts_group_swi133)
 
+        // Mode Personnalisé — trois lignes de trois boutons
+        customPowerButtons[0] = view.findViewById(R.id.btn_cd_power_eco)
+        customPowerButtons[1] = view.findViewById(R.id.btn_cd_power_normal)
+        customPowerButtons[2] = view.findViewById(R.id.btn_cd_power_sport)
+        customSteerButtons[0] = view.findViewById(R.id.btn_cd_steer_comfort)
+        customSteerButtons[1] = view.findViewById(R.id.btn_cd_steer_normal)
+        customSteerButtons[2] = view.findViewById(R.id.btn_cd_steer_sport)
+        customPedalButtons[0] = view.findViewById(R.id.btn_cd_pedal_comfort)
+        customPedalButtons[1] = view.findViewById(R.id.btn_cd_pedal_normal)
+        customPedalButtons[2] = view.findViewById(R.id.btn_cd_pedal_sport)
+
         // TSR + Économie d'énergie
         switchTsr       = view.findViewById(R.id.switch_tsr)
         btnEnergySaving = view.findViewById(R.id.btn_energy_saving)
@@ -363,6 +381,22 @@ class DashboardFragment : Fragment() {
             }
         }
 
+        // Mode Personnalisé — chaque ligne écrit son réglage et rien d'autre.
+        listOf(
+            Triple(customPowerButtons, MG4Hardware::setCustomPower,    "puissance"),
+            Triple(customSteerButtons, MG4Hardware::setCustomSteering, "direction"),
+            Triple(customPedalButtons, MG4Hardware::setCustomPedal,    "pédale")
+        ).forEach { (boutons, ecrire, nom) ->
+            boutons.forEach { (index, btn) ->
+                btn.setOnClickListener {
+                    highlightCustomRow(boutons, index)
+                    CoroutineScope(Dispatchers.IO).launch {
+                        AppLogger.i("MG4_DASH", "mode personnalisé — $nom = $index → ${ecrire(index)}")
+                    }
+                }
+            }
+        }
+
         // Regen
         regenButtons.forEach { (level, btn) ->
             btn.setOnClickListener {
@@ -906,8 +940,68 @@ class DashboardFragment : Fragment() {
         setRegenEnabled(!active && currentDriveMode != DriveMode.SNOW)
     }
 
+    /** Surligne l'option retenue d'une ligne du mode Personnalisé. */
+    private fun highlightCustomRow(boutons: Map<Int, Button>, actif: Int?) {
+        boutons.forEach { (index, btn) ->
+            val on = index == actif
+            btn.backgroundTintList = ColorStateList.valueOf(if (on) colorActive else colorInactive)
+            btn.setTextColor(if (on) colorTextActive else colorTextInactive)
+        }
+    }
+
+    /**
+     * Révèle la carte du mode Personnalisé et y reporte l'état du véhicule.
+     *
+     * Deux niveaux de masquage, et ils ne disent pas la même chose :
+     *  • la CARTE n'apparaît que si la voiture est réellement en mode Personnalisé — ces trois
+     *    réglages n'ont aucun effet ailleurs ;
+     *  • une LIGNE disparaît si le véhicule ne rend pas son état. Les six firmwares exposent la
+     *    commande, mais rien ne garantit que la finition porte l'équipement — une direction à
+     *    assistance variable, par exemple. Un bouton qui n'écrirait nulle part vaut moins que
+     *    pas de bouton du tout.
+     */
+    private fun refreshCustomDrive(mode: DriveMode?) {
+        val vue = view ?: return
+        val carte = vue.findViewById<View>(R.id.section_custom_drive) ?: return
+        if (mode != DriveMode.CUSTOM) {
+            carte.visibility = View.GONE
+            return
+        }
+        CoroutineScope(Dispatchers.IO).launch {
+            val puissance = MG4Hardware.getCustomPower()
+            val direction = MG4Hardware.getCustomSteering()
+            val pedale    = MG4Hardware.getCustomPedal()
+            withContext(Dispatchers.Main) {
+                if (!isAdded) return@withContext
+                // L'état a pu changer pendant la lecture (l'utilisateur quitte le mode) : on
+                // revérifie avant d'afficher, sinon la carte réapparaîtrait toute seule.
+                if (currentDriveMode != DriveMode.CUSTOM) { carte.visibility = View.GONE; return@withContext }
+                val lignes = listOf(
+                    Triple(customPowerButtons, puissance, R.id.row_cd_power),
+                    Triple(customSteerButtons, direction, R.id.row_cd_steer),
+                    Triple(customPedalButtons, pedale,    R.id.row_cd_pedal)
+                )
+                lignes.forEach { (boutons, valeur, rowId) ->
+                    vue.findViewById<View>(rowId)?.visibility =
+                        if (valeur == null) View.GONE else View.VISIBLE
+                    highlightCustomRow(boutons, valeur)
+                }
+                // Aucune ligne lisible : la carte n'aurait qu'un titre à montrer.
+                val lisible = lignes.any { it.second != null }
+                carte.visibility = if (lisible) View.VISIBLE else View.GONE
+                // Trois lectures nulles d'un coup, c'est plus vraisemblablement une couche
+                // véhicule pas encore prête qu'une voiture dépourvue des trois équipements.
+                // Même repli que refreshDriveRegen, qui réessaie pour la même raison.
+                if (!lisible) view?.postDelayed({
+                    if (isAdded && currentDriveMode == DriveMode.CUSTOM) refreshCustomDrive(currentDriveMode)
+                }, 3_000)
+            }
+        }
+    }
+
     private fun applyDriveModeUI(mode: DriveMode) {
         currentDriveMode = mode
+        refreshCustomDrive(mode)
         driveModeButtons.forEach { (m, btn) ->
             val (bg, text) = when {
                 m != mode            -> colorInactive to colorTextInactive