Update app.py

app.py

@@ -7,25 +7,11 @@ Workflow:
   3. Qwen3-0.6B-Q4_K_M (llama-cpp) évalue la réponse de 0 à 10.
   4. Score ≥ 6 → réussi. Score < 6 → retour au début, réécoute obligatoire.
 Multi-utilisateur sécurisé via gr.State (JSON par session).
+Compatible gradio 5.x + Python 3.13.
 """
 
-# ── Patch gradio_client 0.8 schema bug ───────────────────────────────────────
-import gradio as gr
-try:
-    import gradio_client.utils as _gcu
-    import gradio.blocks as _gb
-    _orig = _gcu.json_schema_to_python_type
-    def _safe(schema):
-        try: return _orig(schema)
-        except Exception: return "Any"
-    _gcu.json_schema_to_python_type = _safe
-    _gb.client_utils.json_schema_to_python_type = _safe
-except Exception:
-    pass
-# ─────────────────────────────────────────────────────────────────────────────
-
 import os, glob, json, time, tempfile, random, threading
-
+import gradio as gr
 from gtts import gTTS
 
 try:
@@ -35,7 +21,7 @@ except ImportError:
     _LLAMA_OK = False
 
 # ── LLM singleton ─────────────────────────────────────────────────────────────
-_llm = None
+_llm      = None
 _llm_lock = threading.Lock()
 
 def get_llm():
@@ -64,114 +50,113 @@ def get_llm():
 
 # ── Contenu du cours (droit civil français) ───────────────────────────────────
 LECTURE_TEXT = """
-Cours de droit civil – Introduction aux sources du droit français.
+Cours de droit civil. Introduction aux sources du droit français.
 
 Première partie : Les sources formelles du droit.
 
-Le droit français repose sur plusieurs sources hiérarchisées. 
-Au sommet se trouve la Constitution du 4 octobre 1958, loi fondamentale 
-de la République française. Elle établit les règles d'organisation de 
+Le droit français repose sur plusieurs sources hiérarchisées.
+Au sommet se trouve la Constitution du 4 octobre 1958, loi fondamentale
+de la République française. Elle établit les règles d'organisation de
 l'État et garantit les droits fondamentaux des citoyens.
 
-Sous la Constitution, on trouve les traités internationaux et le droit 
-de l'Union européenne. En vertu de l'article 55 de la Constitution, 
-les traités régulièrement ratifiés ont une autorité supérieure à celle 
+Sous la Constitution, on trouve les traités internationaux et le droit
+de l'Union européenne. En vertu de l'article 55 de la Constitution,
+les traités régulièrement ratifiés ont une autorité supérieure à celle
 des lois ordinaires.
 
-Vient ensuite la loi, votée par le Parlement. La loi ordinaire est 
-adoptée par l'Assemblée nationale et le Sénat selon la procédure 
-législative prévue par la Constitution. Les lois organiques, 
-quant à elles, complètent et précisent certaines dispositions 
+Vient ensuite la loi, votée par le Parlement. La loi ordinaire est
+adoptée par l'Assemblée nationale et le Sénat selon la procédure
+législative prévue par la Constitution. Les lois organiques,
+quant à elles, complètent et précisent certaines dispositions
 constitutionnelles et bénéficient d'un statut intermédiaire.
 
-Le règlement constitue la quatrième source majeure. Il émane du 
-pouvoir exécutif : décrets du Président de la République et du 
-Premier ministre, arrêtés ministériels, préfectoraux et municipaux. 
-L'article 37 de la Constitution confère au gouvernement un domaine 
+Le règlement constitue la quatrième source majeure. Il émane du
+pouvoir exécutif : décrets du Président de la République et du
+Premier ministre, arrêtés ministériels, préfectoraux et municipaux.
+L'article 37 de la Constitution confère au gouvernement un domaine
 réglementaire autonome.
 
 Deuxième partie : Les sources matérielles du droit.
 
-La jurisprudence, bien qu'elle ne soit pas officiellement reconnue 
-comme source formelle, joue un rôle fondamental dans le système 
-juridique français. Les décisions de la Cour de cassation et du 
-Conseil d'État interprètent et précisent la portée des textes légaux. 
-Le Conseil constitutionnel, par ses décisions, contrôle la 
+La jurisprudence, bien qu'elle ne soit pas officiellement reconnue
+comme source formelle, joue un rôle fondamental dans le système
+juridique français. Les décisions de la Cour de cassation et du
+Conseil d'État interprètent et précisent la portée des textes légaux.
+Le Conseil constitutionnel, par ses décisions, contrôle la
 constitutionnalité des lois.
 
-La doctrine regroupe l'ensemble des travaux des juristes : 
-professeurs, avocats, magistrats. Elle propose des analyses, 
-des systématisations et des critiques du droit positif. 
-Sans force obligatoire, elle influence néanmoins la jurisprudence 
+La doctrine regroupe l'ensemble des travaux des juristes :
+professeurs, avocats, magistrats. Elle propose des analyses,
+des systématisations et des critiques du droit positif.
+Sans force obligatoire, elle influence néanmoins la jurisprudence
 et le législateur.
 
-La coutume, source ancienne, est aujourd'hui d'application limitée. 
-Elle consiste en une pratique ancienne, constante et répétée, 
-acceptée comme obligatoire par la population. En droit commercial, 
+La coutume, source ancienne, est aujourd'hui d'application limitée.
+Elle consiste en une pratique ancienne, constante et répétée,
+acceptée comme obligatoire par la population. En droit commercial,
 les usages professionnels conservent une importance certaine.
 
 Troisième partie : Le principe de hiérarchie des normes.
 
-Hans Kelsen, juriste autrichien du vingtième siècle, a théorisé 
-la pyramide des normes. Selon cette théorie, chaque norme tire 
-sa validité d'une norme supérieure. En France, le Conseil 
-constitutionnel assure le respect de cette hiérarchie en contrôlant 
+Hans Kelsen, juriste autrichien du vingtième siècle, a théorisé
+la pyramide des normes. Selon cette théorie, chaque norme tire
+sa validité d'une norme supérieure. En France, le Conseil
+constitutionnel assure le respect de cette hiérarchie en contrôlant
 la conformité des lois à la Constitution.
 
-Le contrôle de légalité permet quant à lui de vérifier que les 
-actes administratifs sont conformes aux lois qui leur sont 
-supérieures. Tout acte contraire à une norme supérieure est 
+Le contrôle de légalité permet quant à lui de vérifier que les
+actes administratifs sont conformes aux lois qui leur sont
+supérieures. Tout acte contraire à une norme supérieure est
 susceptible d'être annulé ou écarté.
 
 Quatrième partie : Le droit des contrats.
 
-Le contrat est un accord de volontés entre deux ou plusieurs 
-personnes destiné à créer, modifier, transmettre ou éteindre 
-des obligations. Le Code civil, dans sa rédaction issue de 
-l'ordonnance du 10 février 2016, définit les conditions de 
-validité du contrat : le consentement des parties, leur capacité 
+Le contrat est un accord de volontés entre deux ou plusieurs
+personnes destiné à créer, modifier, transmettre ou éteindre
+des obligations. Le Code civil, dans sa rédaction issue de
+l'ordonnance du 10 février 2016, définit les conditions de
+validité du contrat : le consentement des parties, leur capacité
 à contracter, et un contenu licite et certain.
 
-Le consentement doit être libre et éclairé. Il est vicié lorsqu'il 
-a été donné par erreur, obtenu par dol ou arraché par violence. 
-Dans ces cas, le contrat peut être annulé à la demande de la 
+Le consentement doit être libre et éclairé. Il est vicié lorsqu'il
+a été donné par erreur, obtenu par dol ou arraché par violence.
+Dans ces cas, le contrat peut être annulé à la demande de la
 partie dont le consentement a été vicié.
 
-La capacité contractuelle est la règle. L'incapacité est 
-l'exception et concerne principalement les mineurs non émancipés 
+La capacité contractuelle est la règle. L'incapacité est
+l'exception et concerne principalement les mineurs non émancipés
 et les majeurs protégés sous tutelle ou curatelle.
 
-L'exécution du contrat obéit au principe de la force obligatoire : 
-le contrat tient lieu de loi entre les parties qui l'ont conclu. 
-En cas d'inexécution, la partie lésée dispose de plusieurs recours : 
+L'exécution du contrat obéit au principe de la force obligatoire :
+le contrat tient lieu de loi entre les parties qui l'ont conclu.
+En cas d'inexécution, la partie lésée dispose de plusieurs recours :
 l'exécution forcée, la résolution du contrat ou des dommages et intérêts.
 
 Cinquième partie : La responsabilité civile.
 
-La responsabilité civile a pour fonction de réparer le préjudice 
-causé à autrui. Elle se distingue de la responsabilité pénale 
+La responsabilité civile a pour fonction de réparer le préjudice
+causé à autrui. Elle se distingue de la responsabilité pénale
 qui vise à sanctionner l'auteur d'une infraction.
 
-La responsabilité délictuelle repose sur trois conditions : 
-une faute, un dommage et un lien de causalité entre les deux. 
-L'article 1240 du Code civil dispose que tout fait quelconque 
-de l'homme qui cause à autrui un dommage oblige son auteur 
+La responsabilité délictuelle repose sur trois conditions :
+une faute, un dommage et un lien de causalité entre les deux.
+L'article 1240 du Code civil dispose que tout fait quelconque
+de l'homme qui cause à autrui un dommage oblige son auteur
 à le réparer.
 
-La responsabilité sans faute, dite objective, est reconnue 
-dans certains cas : responsabilité du fait des choses, 
-responsabilité du fait d'autrui, responsabilité des produits 
-défectueux. L'évolution jurisprudentielle et législative tend 
+La responsabilité sans faute, dite objective, est reconnue
+dans certains cas : responsabilité du fait des choses,
+responsabilité du fait d'autrui, responsabilité des produits
+défectueux. L'évolution jurisprudentielle et législative tend
 à élargir ces hypothèses pour mieux protéger les victimes.
 
-Conclusion : Le droit est un système dynamique en constante évolution. 
-La maîtrise de ses sources et de ses principes fondamentaux est 
-indispensable à tout juriste. La rigueur dans l'analyse textuelle, 
-combinée à la connaissance de la jurisprudence, permet d'appliquer 
+Conclusion : Le droit est un système dynamique en constante évolution.
+La maîtrise de ses sources et de ses principes fondamentaux est
+indispensable à tout juriste. La rigueur dans l'analyse textuelle,
+combinée à la connaissance de la jurisprudence, permet d'appliquer
 le droit de manière correcte et juste.
 """
 
-# ── Questions du cours ────────────────────────────────────────────────────────
 QUESTIONS = [
     {
         "q": "Quelle est la source au sommet de la hiérarchie des normes en droit français, et quelle est sa date ?",
@@ -191,7 +176,7 @@ QUESTIONS = [
     },
     {
         "q": "Quelles sont les trois conditions nécessaires pour engager la responsabilité délictuelle ?",
-        "hint": "faute, dommage, lien de causalité – article 1240 Code civil",
+        "hint": "faute, dommage, lien de causalité, article 1240 Code civil",
     },
     {
         "q": "Expliquez la différence entre la responsabilité civile et la responsabilité pénale.",
@@ -208,21 +193,9 @@ QUESTIONS = [
 ]
 
 LISTEN_SECONDS = 15 * 60   # 15 minutes
-PASS_SCORE     = 6          # seuil de réussite sur 10
+PASS_SCORE     = 6
 
-# ── État de session ────────────────────────────────────────────────────────────
-def fresh():
-    return json.dumps({
-        "phase":        "listen",   # listen | quiz | pass | fail
-        "listen_start": None,
-        "question_idx": None,
-        "attempts":     0,
-    })
-
-def S(s): return json.loads(s)
-def D(d): return json.dumps(d)
-
-# ── TTS français ──────────────────────────────────────────────────────────────
+# ── Audio cache (partagé entre sessions) ─────────────────────────────────────
 _audio_cache = None
 _audio_lock  = threading.Lock()
 
@@ -243,198 +216,182 @@ def get_lecture_audio():
             print(f"[law-app] gTTS erreur : {e}")
             return None
 
+# ── État de session ────────────────────────────────────────────────────────────
+def fresh():
+    return json.dumps({
+        "phase":        "idle",
+        "listen_start": None,
+        "question_idx": None,
+    })
+
+def S(s): return json.loads(s)
+def D(d): return json.dumps(d)
+
 # ── Évaluation Qwen3 ──────────────────────────────────────────────────────────
-def evaluate_answer(question: str, answer: str, hint: str) -> tuple[int, str]:
-    """Retourne (score_0_10, feedback_str)."""
+def evaluate_answer(question: str, answer: str, hint: str):
     llm = get_llm()
     if llm is None:
-        # fallback basique si pas de modèle
-        keywords = [w.lower() for w in hint.split(",")]
+        keywords = [w.strip().lower() for w in hint.split(",")]
         ans_low  = answer.lower()
-        hits     = sum(1 for k in keywords if k.strip() in ans_low)
+        hits     = sum(1 for k in keywords if k in ans_low)
         score    = min(10, round((hits / max(len(keywords), 1)) * 10))
-        fb = f"(Évaluation sans IA – mots-clés trouvés : {hits}/{len(keywords)})"
-        return score, fb
-
-    prompt = f"""Tu es un professeur de droit strict mais juste.
-Question posée à l'étudiant :
-{question}
-
-Réponse de l'étudiant :
-{answer}
-
-Éléments attendus dans une bonne réponse :
-{hint}
-
-Évalue la réponse de l'étudiant sur une échelle de 0 à 10.
-Réponds UNIQUEMENT avec un objet JSON valide sur une seule ligne, sans aucun texte avant ou après, au format :
-{{"score": <entier 0-10>, "feedback": "<commentaire bref en français>"}}"""
-
+        return score, f"(Évaluation sans IA – mots-clés trouvés : {hits}/{len(keywords)})"
+
+    prompt = (
+        f"Tu es un professeur de droit strict mais juste.\n"
+        f"Question : {question}\n"
+        f"Réponse de l'étudiant : {answer}\n"
+        f"Éléments attendus : {hint}\n\n"
+        "Évalue la réponse de 0 à 10. Réponds UNIQUEMENT avec un JSON sur une seule ligne, "
+        'sans texte avant ni après : {"score": <entier 0-10>, "feedback": "<commentaire bref en français>"}'
+    )
     try:
-        out   = llm(prompt, max_tokens=200, temperature=0.1, stop=["###", "\n\n"])
-        text  = out["choices"][0]["text"].strip()
-        # extract JSON robustly
-        start = text.find("{")
-        end   = text.rfind("}") + 1
-        data  = json.loads(text[start:end])
-        score = max(0, min(10, int(data.get("score", 0))))
-        fb    = data.get("feedback", "")
-        return score, fb
+        out  = llm(prompt, max_tokens=200, temperature=0.1, stop=["###", "\n\n"])
+        text = out["choices"][0]["text"].strip()
+        data = json.loads(text[text.find("{"):text.rfind("}")+1])
+        return max(0, min(10, int(data["score"]))), data.get("feedback", "")
     except Exception as e:
         print(f"[law-app] Erreur évaluation : {e}")
         return 0, "Erreur lors de l'évaluation. Veuillez réessayer."
 
-# ── Fonctions Gradio ──────────────────────────────────────────────────────────
+# ── Handlers ──────────────────────────────────────────────────────────────────
 
 def start_listening(ss):
     state = S(ss)
     state["phase"]        = "listen"
     state["listen_start"] = time.time()
-    state["question_idx"] = None
     audio = get_lecture_audio()
     msg   = (
         "🎧 **Cours en cours d'écoute…**\n\n"
-        f"Vous devez écouter pendant **15 minutes** avant de pouvoir répondre.\n\n"
-        "Le bouton « Passer au Quiz » sera actif après la durée requise."
+        "Vous devez écouter pendant **15 minutes** complètes avant d'accéder au quiz.\n\n"
+        "Cliquez sur **🔄 Vérifier le temps** pour voir combien il reste."
     )
     return (
         audio,
-        gr.update(visible=True,  value=msg),
-        gr.update(visible=False),   # quiz_col
-        gr.update(visible=False),   # result_col
+        msg,
+        gr.update(visible=True),    # listen_group
+        gr.update(visible=False),   # quiz_group
+        gr.update(visible=False),   # result_group
         gr.update(interactive=False, value="⏳ Écoute en cours…"),
         D(state),
     )
 
 
 def check_timer(ss):
-    """Appelé par un timer JS ou le bouton ; retourne si le quiz peut s'ouvrir."""
-    state    = S(ss)
+    state   = S(ss)
     if state["phase"] != "listen" or state["listen_start"] is None:
-        elapsed  = LISTEN_SECONDS
-    else:
-        elapsed  = time.time() - state["listen_start"]
+        return gr.update(), "⚠️ Lancez d'abord l'écoute.", ss
+    elapsed   = time.time() - state["listen_start"]
     remaining = max(0, LISTEN_SECONDS - elapsed)
-    minutes   = int(remaining // 60)
-    seconds   = int(remaining % 60)
+    m, s      = divmod(int(remaining), 60)
     if remaining <= 0:
         return (
-            gr.update(interactive=True,  value="✅ Accéder au Quiz"),
-            f"✅ Durée d'écoute atteinte ! Cliquez sur **Accéder au Quiz**.",
+            gr.update(interactive=True, value="✅ Accéder au Quiz"),
+            "✅ Durée d'écoute atteinte ! Cliquez sur **Accéder au Quiz**.",
             ss,
         )
     return (
-        gr.update(interactive=False, value=f"⏳ Encore {minutes:02d}:{seconds:02d}"),
-        f"🎧 Veuillez patienter encore **{minutes} min {seconds:02d} s**.",
+        gr.update(interactive=False, value=f"⏳ Encore {m:02d}:{s:02d}"),
+        f"🎧 Patientez encore **{m} min {s:02d} s**.",
         ss,
     )
 
 
 def open_quiz(ss):
-    state = S(ss)
-    elapsed = (time.time() - (state["listen_start"] or 0))
+    state   = S(ss)
+    elapsed = time.time() - (state["listen_start"] or 0)
     if elapsed < LISTEN_SECONDS:
-        remaining = int(LISTEN_SECONDS - elapsed)
-        m, s = divmod(remaining, 60)
+        m, s = divmod(int(LISTEN_SECONDS - elapsed), 60)
         return (
-            gr.update(visible=True),    # listen_col
-            gr.update(visible=False),   # quiz_col
-            gr.update(visible=False),   # result_col
-            f"⚠️ Patientez encore **{m} min {s:02d} s** avant d'accéder au quiz.",
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            f"⚠️ Patientez encore **{m} min {s:02d} s**.",
             "", "", ss,
         )
-    idx   = random.randrange(len(QUESTIONS))
+    idx = random.randrange(len(QUESTIONS))
     state["phase"]        = "quiz"
     state["question_idx"] = idx
-    q_text = QUESTIONS[idx]["q"]
     return (
-        gr.update(visible=False),   # listen_col
-        gr.update(visible=True),    # quiz_col
-        gr.update(visible=False),   # result_col
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(visible=False),
         "",
-        q_text,
+        QUESTIONS[idx]["q"],
         "",
         D(state),
     )
 
 
-def submit_answer(answer: str, ss: str):
+def submit_answer(answer, ss):
     state = S(ss)
     if state["phase"] != "quiz":
-        return gr.update(visible=False), gr.update(visible=True), "", "", ss
+        return gr.update(visible=True), gr.update(visible=False), "", "", ss
 
-    idx   = state["question_idx"]
-    q     = QUESTIONS[idx]
-    score, feedback = evaluate_answer(q["q"], answer, q["hint"])
-    state["attempts"] += 1
+    idx          = state["question_idx"]
+    q            = QUESTIONS[idx]
+    score, fb    = evaluate_answer(q["q"], answer, q["hint"])
 
     if score >= PASS_SCORE:
         state["phase"] = "pass"
-        result_md = (
+        result = (
             f"## 🎉 Félicitations ! Vous avez réussi.\n\n"
             f"**Score : {score}/10**\n\n"
-            f"**Commentaire :** {feedback}\n\n"
-            f"---\n*Vous maîtrisez bien le contenu de ce cours de droit.*"
+            f"**Commentaire :** {fb}\n\n"
+            f"---\n*Vous maîtrisez bien ce cours de droit civil.*"
         )
-        btn_label = "🔄 Recommencer"
+        btn = "🔄 Recommencer"
     else:
         state["phase"] = "fail"
-        result_md = (
+        result = (
             f"## ❌ Score insuffisant : {score}/10\n\n"
-            f"**Commentaire :** {feedback}\n\n"
+            f"**Commentaire :** {fb}\n\n"
             f"---\n"
-            f"Vous devez obtenir au moins **{PASS_SCORE}/10** pour valider ce cours.\n\n"
+            f"Seuil requis : **{PASS_SCORE}/10**.\n\n"
             f"⬇️ Veuillez **réécouter l'intégralité du cours** (15 minutes) "
             f"avant de tenter à nouveau le quiz."
         )
-        btn_label = "🔄 Réécouter le cours"
+        btn = "🔄 Réécouter le cours"
 
     return (
-        gr.update(visible=False),          # quiz_col
-        gr.update(visible=True),           # result_col
-        result_md,
-        btn_label,
+        gr.update(visible=False),
+        gr.update(visible=True),
+        result,
+        btn,
         D(state),
     )
 
 
 def restart(ss):
-    """Relance depuis l'écoute."""
     return start_listening(fresh())
 
 
 # ── Interface ─────────────────────────────────────────────────────────────────
-CSS = """
-footer { display: none !important; }
-#title { text-align: center; }
-#timer_btn { min-width: 220px; }
-"""
+CSS = "footer{display:none!important;} #title{text-align:center;}"
 
-with gr.Blocks(title="Cours de Droit – Formation Juridique", css=CSS) as demo:
+with gr.Blocks(title="Cours de Droit", css=CSS) as demo:
 
     session = gr.State(fresh())
 
     gr.Markdown(
         "# ⚖️ Cours de Droit — Formation Juridique\n"
-        "Écoutez le cours en français · Répondez à une question · Obtenez une note de 0 à 10",
+        "Écoutez le cours en français · Répondez à une question · Obtenez une note sur 10",
         elem_id="title",
     )
 
-    # ── Phase 1 : Écoute ──────────────────────────────────────────────────────
-    with gr.Column(visible=True) as listen_col:
+    # ── Phase écoute ─────────────────────────────────────────────────────────
+    with gr.Group(visible=True) as listen_group:
         gr.Markdown("## 🎧 Étape 1 — Écoute du cours (15 minutes)")
-        listen_msg  = gr.Markdown("Cliquez sur **Démarrer l'écoute** pour commencer.")
-        audio_out   = gr.Audio(label="Cours audio (français)", autoplay=False, interactive=False)
-        timer_info  = gr.Markdown("")
-
+        listen_msg = gr.Markdown("Cliquez sur **Démarrer l'écoute** pour commencer.")
+        audio_out  = gr.Audio(label="Cours audio (français)", autoplay=False, interactive=False)
+        timer_info = gr.Markdown("")
         with gr.Row():
             start_btn = gr.Button("▶️ Démarrer l'écoute", variant="primary")
-            quiz_btn  = gr.Button("✅ Accéder au Quiz", variant="secondary",
-                                   interactive=False, elem_id="timer_btn")
-            check_btn = gr.Button("🔄 Vérifier le temps", variant="secondary")
+            check_btn = gr.Button("🔄 Vérifier le temps",  variant="secondary")
+            quiz_btn  = gr.Button("✅ Accéder au Quiz",    variant="secondary", interactive=False)
 
-    # ── Phase 2 : Quiz ────────────────────────────────────────────────────────
-    with gr.Column(visible=False) as quiz_col:
+    # ── Phase quiz ───────────────────────────────────────────────────────────
+    with gr.Group(visible=False) as quiz_group:
         gr.Markdown("## 📝 Étape 2 — Question d'évaluation")
         question_md = gr.Markdown("")
         answer_box  = gr.Textbox(
@@ -442,41 +399,28 @@ with gr.Blocks(title="Cours de Droit – Formation Juridique", css=CSS) as demo:
             placeholder="Rédigez votre réponse ici…",
             lines=5,
         )
-        submit_btn  = gr.Button("📤 Soumettre la réponse", variant="primary")
+        submit_btn = gr.Button("📤 Soumettre la réponse", variant="primary")
 
-    # ── Phase 3 : Résultat ────────────────────────────────────────────────────
-    with gr.Column(visible=False) as result_col:
+    # ── Phase résultat ───────────────────────────────────────────────────────
+    with gr.Group(visible=False) as result_group:
         gr.Markdown("## 📊 Résultat")
         result_md   = gr.Markdown("")
         restart_btn = gr.Button("🔄 Recommencer", variant="secondary")
 
     # ── Câblage ───────────────────────────────────────────────────────────────
-    LISTEN_OUTS = [audio_out, listen_msg, quiz_col, result_col, quiz_btn, session]
-
-    start_btn.click(
-        start_listening, [session], LISTEN_OUTS
-    )
+    START_OUT = [audio_out, listen_msg, listen_group, quiz_group, result_group, quiz_btn, session]
 
-    check_btn.click(
-        check_timer, [session], [quiz_btn, timer_info, session]
-    )
+    start_btn.click(start_listening, [session], START_OUT)
+    check_btn.click(check_timer,     [session], [quiz_btn, timer_info, session])
 
-    QUIZ_OUTS = [listen_col, quiz_col, result_col, timer_info, question_md, answer_box, session]
-    quiz_btn.click(
-        open_quiz, [session], QUIZ_OUTS
-    )
+    QUIZ_OUT = [listen_group, quiz_group, result_group, timer_info, question_md, answer_box, session]
+    quiz_btn.click(open_quiz, [session], QUIZ_OUT)
 
-    RESULT_OUTS = [quiz_col, result_col, result_md, restart_btn, session]
-    submit_btn.click(
-        submit_answer, [answer_box, session], RESULT_OUTS
-    )
-    answer_box.submit(
-        submit_answer, [answer_box, session], RESULT_OUTS
-    )
+    RESULT_OUT = [quiz_group, result_group, result_md, restart_btn, session]
+    submit_btn.click(submit_answer, [answer_box, session], RESULT_OUT)
+    answer_box.submit(submit_answer, [answer_box, session], RESULT_OUT)
 
-    restart_btn.click(
-        restart, [session], LISTEN_OUTS
-    )
+    restart_btn.click(restart, [session], START_OUT)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)