@@ -122,7 +122,16 @@ d'appui**, la **fonction**, puis *Modifier* et *Supprimer*. Réattribuer un bout
 le même type d'appui demande confirmation et nomme la fonction qui va être remplacée.
 
 Les réglages associés à une action ne s'affichent que si cette action est réellement attribuée
-(niveau de repli du mode 1 Pédale, crans du cycle ADAS).
+(niveau de repli du mode 1 Pédale, crans du cycle ADAS). Le **cycle de régénération** va plus loin :
+dès que la fonction est attribuée — ou même simplement choisie dans le formulaire avancé — une
+sous-entrée apparaît dans le rail de gauche et ouvre sa propre page.
+
+On y compose la séquence parcourue par la touche : toucher un mode l'ajoute **en fin de cycle**,
+le toucher à nouveau le retire, et l'ordre des appuis est celui du cycle. Les cinq modes proposés
+sont Faible, Moyen, Fort, Adaptatif et 1 Pédale ; deux au minimum, faute de quoi le raccourci
+n'aurait plus rien à parcourir après le premier appui. Le réglage est **global** — la même
+séquence pour tous les boutons qui déclenchent la fonction — et sans réglage, le comportement
+d'origine reste inchangé (Faible → Moyen → Fort → Adaptatif).
 
 ### Automatisation
 - **Application d'un profil selon la température extérieure** : seuil, sens
@@ -254,7 +263,7 @@ MG4Control/
 │   │   ├── model/
 │   │   │   ├── DrivingProfile.kt      # Modèle de données d'un profil
 │   │   │   ├── DriveMode.kt           # Enum modes de conduite (ECO/NORMAL/SPORT/SNOW/CUSTOM)
-│   │   │   ├── RegenLevel.kt          # Enum niveaux de régénération + ordre d'usage du cycle
+│   │   │   ├── RegenLevel.kt          # Enum niveaux de régénération + ordre du cycle par défaut
 │   │   │   └── ProfileBackup.kt       # Format de la sauvegarde véhicule
 │   │   │
 │   │   ├── profile/
@@ -271,6 +280,7 @@ MG4Control/
 │   │   │   └── AdvancedShortcuts.kt   # Stockage (touche, type d'appui) → action
 │   │   │
 │   │   ├── shortcut/
+│   │   │   ├── RegenCycle.kt          # Séquence du cycle de régénération choisie par l'utilisateur
 │   │   │   └── ShortcutAction.kt      # Catalogue des actions, partagé par les deux systèmes
 │   │   │
 │   │   ├── bluetooth/
@@ -843,7 +853,16 @@ Each row of the advanced list shows the **button** (name and code), the **press
 asks for confirmation and names the action about to be replaced.
 
 Settings attached to an action appear only when that action is actually assigned (One Pedal
-fallback level, ADAS cycle notches).
+fallback level, ADAS cycle notches). The **regeneration cycle** goes further: as soon as the action
+is assigned — or merely picked in the advanced form — a sub-entry appears in the left rail and
+opens a page of its own.
+
+There you compose the sequence the key walks through: tapping a mode appends it **at the end of the
+cycle**, tapping it again removes it, and the order of your taps is the order of the cycle. The five
+modes on offer are Low, Medium, High, Adaptive and One Pedal; two at the very least, otherwise the
+shortcut would have nothing left to walk through after the first press. The setting is **global** —
+the same sequence for every button triggering the action — and with no setting at all, the original
+behaviour stands unchanged (Low → Medium → High → Adaptive).
 
 ### Automation
 - **Apply a profile from the outside temperature**: threshold, direction (below/above), profile to
@@ -971,7 +990,7 @@ MG4Control/
 │   │   ├── model/
 │   │   │   ├── DrivingProfile.kt      # Profile data model
 │   │   │   ├── DriveMode.kt           # Drive mode enum (ECO/NORMAL/SPORT/SNOW/CUSTOM)
-│   │   │   ├── RegenLevel.kt          # Regen level enum + shortcut cycle order
+│   │   │   ├── RegenLevel.kt          # Regen level enum + default shortcut cycle order
 │   │   │   └── ProfileBackup.kt       # Vehicle backup format
 │   │   │
 │   │   ├── profile/
@@ -988,6 +1007,7 @@ MG4Control/
 │   │   │   └── AdvancedShortcuts.kt   # Storage for (key, press type) → action
 │   │   │
 │   │   ├── shortcut/
+│   │   │   ├── RegenCycle.kt          # User-composed regeneration cycle sequence
 │   │   │   └── ShortcutAction.kt      # Action catalogue, shared by both systems
 │   │   │
 │   │   ├── bluetooth/
 
@@ -11,11 +11,11 @@ android {
         applicationId = "com.mg4.control"
         minSdk = 28
         targetSdk = 34
-        versionCode = 18
+        versionCode = 19
         // Suffixe injecte par la CI beta : -Pmg4.versionSuffix=-beta42 produit "2.6.6-beta42".
         // L'APK installe annonce alors EXACTEMENT ce que dit le tag de la release, sans quoi
         // l'OTA reproposerait la meme mise a jour indefiniment.
-        versionName = "2.6.6" + (project.findProperty("mg4.versionSuffix") as String? ?: "")
+        versionName = "2.6.7" + (project.findProperty("mg4.versionSuffix") as String? ?: "")
     }
 
     // Signature avec la clé plateforme de la ROM (requise par sharedUserId=android.uid.system).
 
@@ -4226,6 +4226,47 @@ object MG4Hardware {
      * 4. **La touche média Android**, dernier recours : c'est la seule voie sur les firmwares A9,
      *    où ce service SAIC n'existe pas, et la seule qui atteigne une session Bluetooth.
      */
+    /** `getCurrentAudioType` de `ICarAudioService` (A9). */
+    private const val AUDIO_GET_CURRENT_TYPE = 0x2c
+
+    /**
+     * SONDE — source audio déclarée par le véhicule sur A9, ou `null` si indisponible.
+     *
+     * Elle ne sert encore À RIEN dans les décisions : elle est là pour être relevée dans les
+     * rapports, parce qu'il nous manque une information et une seule.
+     *
+     * Le problème mesuré sur SWI132 : quand un téléphone est connecté, la session Bluetooth et
+     * celle de la radio se déclarent **toutes deux en lecture**. Relevé sur un essai radio :
+     * 18 fois la radio retenue, 16 fois le Bluetooth — un tirage au sort. Départager par
+     * l'ordre de la liste ne peut pas marcher.
+     *
+     * `getCurrentAudioType` est la seule source qui sache dire quelle source est réellement
+     * audible. Il reste à apprendre son espace de valeurs : d'où cette lecture, journalisée
+     * dans les cas ambigus et dans le rapport de diagnostic. Deux rapports — un sur radio, un
+     * sur Bluetooth — suffiront à établir la table, et l'aiguillage deviendra déterministe.
+     *
+     * ⚠️ Absent du launcher SWI131 (interface plus ancienne, 0x2c hors plage) : la transaction
+     * y est rejetée sans effet de bord. Vérifié dans le smali avant d'oser l'appel.
+     */
+    private fun typeAudioCourant(): Int? {
+        if (!isA9Sound()) return null
+        val h = sAudioHelper ?: return null
+        if (!h.isBinderAlive) return null
+        val data = Parcel.obtain()
+        val reply = Parcel.obtain()
+        return try {
+            data.writeInterfaceToken(sAudioDescriptor)
+            if (!h.transact(AUDIO_GET_CURRENT_TYPE, data, reply, 0)) return null
+            reply.readException()
+            reply.readInt()
+        } catch (e: Exception) {
+            null
+        } finally {
+            data.recycle()
+            reply.recycle()
+        }
+    }
+
     /**
      * Une session est-elle en lecture ? `null` si on ne peut pas les consulter.
      *
@@ -4275,7 +4316,16 @@ object MG4Hardware {
             return false
         }
 
-        val joue = sessions.firstOrNull { it.playbackState?.state == PlaybackState.STATE_PLAYING }
+        // SONDE : plusieurs sessions qui se déclarent en lecture EN MÊME TEMPS, c'est le cas
+        // qu'on ne sait pas trancher. On le journalise avec le type audio du véhicule — le
+        // choix ci-dessous, lui, est inchangé.
+        val enLecture = sessions.filter { it.playbackState?.state == PlaybackState.STATE_PLAYING }
+        if (enLecture.size > 1) {
+            AppLogger.w(MEDIA_TAG, "AMBIGU : ${enLecture.size} sessions se déclarent en lecture " +
+                "(${enLecture.joinToString { it.packageName ?: "?" }}) — type audio véhicule = " +
+                "${typeAudioCourant() ?: "non exposé"} — retenue : ${enLecture[0].packageName}")
+        }
+        val joue = enLecture.firstOrNull()
         val cible = joue
             ?: if (cmd == CmdMedia.LECTURE_PAUSE)
                    // ⚠️ Pour REPRENDRE, on ne demande pas un état précis mais une CAPACITÉ.
@@ -4587,6 +4637,9 @@ object MG4Hardware {
         val am = ctx.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
         AppLogger.i(MEDIA_TAG, "── DIAG média ────────────────────────────────")
         AppLogger.i(MEDIA_TAG, "lecture en cours (isMusicActive) = ${am?.isMusicActive}")
+        // Type audio déclaré par le véhicule (A9). À relever une fois par source pour établir
+        // la table — voir [typeAudioCourant].
+        AppLogger.i(MEDIA_TAG, "type audio véhicule (A9) = ${typeAudioCourant() ?: "non exposé"}")
 
         // Sessions média : c'est ce qui a montré que les touches média ne pouvaient pas aboutir.
         try {
 
@@ -23,15 +23,34 @@ enum class RegenLevel(val value: Int, val label: String) {
         val CYCLE_ORDER = listOf(LOW, MEDIUM, HIGH, ADAPTIVE)
 
         /**
-         * Niveau suivant dans [CYCLE_ORDER], en rebouclant à la fin.
+         * Modes qu'on accepte de voir figurer dans un cycle composé par l'utilisateur.
          *
-         * Un niveau hors cycle ([OFF] ou [ONE_PEDAL]) fait entrer par le premier cran : sur une
-         * touche de volant, ne rien faire passerait pour une panne.
+         * [ONE_PEDAL] en fait partie : il reste hors du cycle PAR DÉFAUT ci-dessus, mais rien
+         * n'interdit à quelqu'un de le vouloir dans sa séquence — c'est un mode de conduite qui
+         * s'écrit exactement comme les autres.
+         *
+         * [OFF] non : couper la régénération n'est pas un cran de dosage, le launcher d'origine
+         * ne le propose pas davantage, et le traverser à chaque tour serait subi plus que choisi.
+         */
+        val CYCLE_SELECTABLE = listOf(LOW, MEDIUM, HIGH, ADAPTIVE, ONE_PEDAL)
+
+        /**
+         * Niveau suivant dans le cycle, en rebouclant à la fin.
+         *
+         * [order] est la séquence à parcourir — [CYCLE_ORDER] par défaut, ou celle que
+         * l'utilisateur a composée (voir `RegenCycle`). Une séquence vide retombe sur l'ordre
+         * d'origine : un cycle sans mode ne pourrait produire aucun niveau à écrire.
+         *
+         * Un niveau absent du cycle (parce qu'il n'y figure pas, ou plus) fait entrer par le
+         * premier cran : sur une touche de volant, ne rien faire passerait pour une panne.
          */
-        fun nextInCycle(current: RegenLevel): RegenLevel {
-            val idx = CYCLE_ORDER.indexOf(current)
-            return if (idx < 0) CYCLE_ORDER.first()
-                   else CYCLE_ORDER[(idx + 1) % CYCLE_ORDER.size]
+        fun nextInCycle(
+            current: RegenLevel,
+            order: List<RegenLevel> = CYCLE_ORDER
+        ): RegenLevel {
+            val cycle = if (order.isEmpty()) CYCLE_ORDER else order
+            val idx = cycle.indexOf(current)
+            return if (idx < 0) cycle.first() else cycle[(idx + 1) % cycle.size]
         }
     }
 }
@@ -35,6 +35,7 @@ import com.mg4.control.hardware.MG4Hardware.Swi68Mode
 import com.mg4.control.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
+import com.mg4.control.shortcut.RegenCycle
 import com.mg4.control.shortcut.ShortcutAction
 import com.mg4.control.util.FirmwareInfo
 import com.mg4.control.util.ThemeHelper
@@ -575,10 +576,16 @@ class MG4ControlService : Service() {
                         "imposé par le véhicule")
                     return
                 }
-                // L'ordre du cycle vit à côté de l'enum, où se trouve le piège : l'ordre de
+                // La séquence est celle que l'utilisateur a composée, et à défaut l'ordre
+                // d'origine. Elle est relue À CHAQUE APPUI : le réglage vit dans un autre écran,
+                // et le service n'est pas redémarré quand on le modifie.
+                //
+                // L'ordre par défaut vit à côté de l'enum, où se trouve le piège : l'ordre de
                 // déclaration n'est pas l'ordre d'usage. Il y est couvert par des tests.
-                val suivant = RegenLevel.nextInCycle(actuel)
-                AppLogger.i(TAG, "SHORTCUT régénération : ${actuel.label} → ${suivant.label}")
+                val ordre   = RegenCycle.order(this)
+                val suivant = RegenLevel.nextInCycle(actuel, ordre)
+                AppLogger.i(TAG, "SHORTCUT régénération : ${actuel.label} → ${suivant.label} " +
+                    "(cycle ${ordre.joinToString("/") { it.label }})")
                 MG4Hardware.setRegenLevel(suivant)
             }
 
 
@@ -0,0 +1,58 @@
+package com.mg4.control.shortcut
+
+import android.content.Context
+import com.mg4.control.model.RegenLevel
+
+/**
+ * Ordre du cycle de régénération, tel que l'utilisateur l'a composé.
+ *
+ * Réglage GLOBAL et non par emplacement : la même touche, qu'elle vienne des raccourcis
+ * classiques ou des avancés, doit parcourir la même séquence. Deux cycles concurrents sur deux
+ * boutons se contrediraient au premier appui, puisque le cycle repart toujours du niveau
+ * réellement lu sur le véhicule.
+ *
+ * Rien n'est écrit tant que l'utilisateur n'a rien composé : l'absence de clé signifie
+ * « comportement d'origine », soit [RegenLevel.CYCLE_ORDER]. C'est ce qui garantit qu'une mise à
+ * jour ne change le cycle de personne.
+ */
+object RegenCycle {
+
+    /** Même fichier que le reste des raccourcis — un seul endroit à sauvegarder. */
+    private const val PREFS = "mg4_shortcuts"
+    private const val KEY   = "shortcut_regen_cycle_order"
+
+    /**
+     * En dessous de deux modes, il n'y a plus de cycle mais une consigne fixe : le premier appui
+     * agirait, tous les suivants seraient sans effet, et le raccourci passerait pour cassé.
+     */
+    const val MIN_MODES = 2
+
+    /**
+     * Séquence à parcourir. Toujours exploitable : une valeur illisible, un mode inconnu ou un
+     * cycle trop court retombent sur l'ordre d'origine plutôt que de rendre le raccourci muet.
+     */
+    fun order(ctx: Context): List<RegenLevel> {
+        val brut = prefs(ctx).getString(KEY, null) ?: return RegenLevel.CYCLE_ORDER
+        // On ne passe PAS par RegenLevel.fromValue : elle rend MEDIUM pour toute valeur inconnue,
+        // ce qui transformerait une préférence corrompue en cycle plausible mais faux.
+        val lus = brut.split(',').mapNotNull { morceau ->
+            morceau.trim().toIntOrNull()?.let { v ->
+                RegenLevel.CYCLE_SELECTABLE.firstOrNull { it.value == v }
+            }
+        }.distinct()
+        return if (lus.size >= MIN_MODES) lus else RegenLevel.CYCLE_ORDER
+    }
+
+    fun save(ctx: Context, ordre: List<RegenLevel>) {
+        prefs(ctx).edit().putString(KEY, ordre.joinToString(",") { it.value.toString() }).apply()
+    }
+
+    /** Revient au comportement d'origine en RETIRANT la clé, pas en écrivant l'ordre par défaut :
+     *  le réglage suivra ainsi une éventuelle évolution de [RegenLevel.CYCLE_ORDER]. */
+    fun reset(ctx: Context) {
+        prefs(ctx).edit().remove(KEY).apply()
+    }
+
+    private fun prefs(ctx: Context) =
+        ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+}