Audit pedagogique des declinaisons (qualite au-dela du harnais mecanique)

Juge LLM (PEDAGOGICAL_AUDIT_PROMPT, gpt-5.4 + repli JSON OpenAI) evalue une
declinaison VERTE : distracteurs coherents/indevinables, enonce qui ne donne
pas la reponse, formulation directe, indice-amorce, format identique ->
verdict OK/A_REVOIR + issues. Si A_REVOIR : reparation ciblee (gardee seulement
si le harnais reste VERT ET que la qualite s ameliore), puis en mode auto
ESCALADE de modele (le meilleur modele selon l exo). Expose : pastille UI,
result[pedagogical], policy_telemetry[pedago_verdict]. Config PEDAGO_*.
Filets deterministes factorises (_apply_deterministic_nets). Smoke 76/76 ;
generation reelle : juge OK, escalade fonctionnelle.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

app/config.py

@@ -23,7 +23,7 @@ TEMPLATES_DIR = PACKAGE_DIR / "web" / "templates"
 # ── Version applicative (exposée par /health pour vérifier un déploiement) ───
 # Bumper à chaque déploiement significatif : permet de répondre « à jour ? »
 # sans se connecter (curl /health → champ "version").
-APP_VERSION = "2026-07-06 — MCQ_SPEC v3 + bouton Stop + suivi robuste + Render"
+APP_VERSION = "2026-07-06 — audit pédagogique + MCQ_SPEC v3 + Stop + Render"
 
 # ── Convention MyST (vérifiée empiriquement : 222/222 exemples plateforme) ───
 # Bloc {python} = 4 backticks ; enveloppe {exercise} = 5 backticks.
@@ -94,6 +94,19 @@ MULTI_SEED_NUM       = 100       # graines de la validation d'invariants (règle
 HARNESS_GATE_SEEDS   = 100       # graines de la porte harnais en fin de pipeline
 HARNESS_REPAIR_MAX   = 2         # boucles de réparation LLM si la porte est rouge
 
+# ── Audit pédagogique des déclinaisons (au-delà du harnais mécanique) ────────
+# Juge LLM de la QUALITÉ (distracteurs cohérents, indevinabilité, consignes)
+# après une sortie VERTE au harnais. Coût : +1 appel LLM/déclinaison (+1 si
+# réparation). Mettre PEDAGO_AUDIT_ENABLED=False pour revenir au harnais seul.
+PEDAGO_AUDIT_ENABLED    = True
+PEDAGO_REPAIR_MAX       = 1      # réparations pédagogiques ciblées (structure préservée)
+PEDAGO_ESCALATE_IN_AUTO = True   # mode auto : escalade de modèle si qualité insuffisante
+# Modèle du JUGE pédagogique (constant, indépendant du modèle de génération qui
+# escalade). Exige un fort raisonnement ET un JSON fiable — deepseek-v4-pro (rôle
+# audit) renvoyait content=null sur ce prompt (2026-07-06). Repli = NOTIONS_MODEL
+# (OpenAI, JSON garanti) si le primaire échoue encore. IDs OpenRouter en chaîne.
+PEDAGO_AUDIT_MODEL      = "openai/gpt-5.4"
+
 # ── Langue cible ─────────────────────────────────────────────────────────────
 DEFAULT_LANG = "fr"              # "fr" | "en" | "both"
 

app/pipeline/audit.py

@@ -20,10 +20,73 @@ from app.config import MAX_AUDIT_ITERATIONS
 from app.knowledge.rules_digest import AUDIT_RULES_ALWAYS, build_rules_digest
 from app.llm.client import process_with_openrouter
 from app.pipeline.postprocess import insert_python_lines, strip_fences
-from app.pipeline.prompts import STEP_AUDIT_PROMPT, SYSTEM_PROMPT
+from app.pipeline.prompts import (
+    PEDAGOGICAL_AUDIT_PROMPT,
+    STEP_AUDIT_PROMPT,
+    SYSTEM_PROMPT,
+)
 
 logger = logging.getLogger(__name__)
 
+_DECL_LABELS_PED = {"qcm": "QCM (MCQ)", "qat": "QAT (FGQ)"}
+
+
+def run_pedagogical_audit(exercise: str, decl_type: str,
+                          model: Optional[str] = None) -> dict:
+    """Juge LLM de la QUALITÉ PÉDAGOGIQUE d'une déclinaison (au-delà du harnais
+    mécanique). Retourne {verdict: OK|A_REVOIR|INCONNU, score, issues:[…], model}.
+    Ne lève JAMAIS (dégrade en verdict INCONNU) — l'audit ne doit pas casser un
+    pipeline dont la sortie est déjà VERTE au harnais.
+
+    Robustesse JSON : essaie le modèle demandé (défaut PEDAGO_AUDIT_MODEL), puis
+    RETOMBE sur NOTIONS_MODEL (OpenAI, JSON fiable) — un juge fort peut renvoyer
+    une complétion vide (vu : deepseek-v4-pro content=null, 2026-07-06)."""
+    from app.config import NOTIONS_MODEL, PEDAGO_AUDIT_MODEL
+
+    label = _DECL_LABELS_PED.get(decl_type, "QCM (MCQ)")
+    prompt = PEDAGOGICAL_AUDIT_PROMPT.format(decl_label=label, exercise=exercise)
+    primary = model or PEDAGO_AUDIT_MODEL
+    last_err = None
+    seen: list = []
+    for cand in (primary, NOTIONS_MODEL):
+        if not cand or cand in seen:
+            continue
+        seen.append(cand)
+        try:
+            raw = process_with_openrouter(
+                prompt=prompt, model=cand, temperature=0.0, max_tokens=2000,
+                system_prompt=SYSTEM_PROMPT,
+            )
+            data = json.loads(strip_fences(raw))
+        except (RuntimeError, ValueError, OSError) as e:   # inclut JSONDecodeError
+            last_err = e
+            logger.warning("Audit pédagogique via %s en échec : %s", cand, e)
+            continue
+        issues = [i for i in (data.get("issues") or []) if isinstance(i, dict)]
+        high = [i for i in issues if str(i.get("gravite", "")).lower().startswith("haut")]
+        verdict = str(data.get("verdict", "")).upper()
+        ok = verdict.startswith("OK") and not high      # OK ⇔ aucune gravité haute
+        return {"verdict": "OK" if ok else "A_REVOIR", "score": data.get("score"),
+                "issues": issues, "model": cand, "error": None}
+    return {"verdict": "INCONNU", "score": None, "issues": [],
+            "model": None, "error": str(last_err)}
+
+
+def pedagogical_badness(ped: Optional[dict]) -> int:
+    """Score de gravité (pour ne garder une réparation que si elle AMÉLIORE)."""
+    if not ped:
+        return 0
+    issues = ped.get("issues") or []
+    high = sum(1 for i in issues if str(i.get("gravite", "")).lower().startswith("haut"))
+    return high * 100 + len(issues)
+
+
+def format_pedagogical_issues(issues: list) -> str:
+    lines = [f"  • [{i.get('gravite', '?')}] {i.get('ou', '')} — "
+             f"{i.get('probleme', '')} → {i.get('correction', '')}"
+             for i in issues]
+    return "\n".join(lines) or "  (aucun détail fourni)"
+
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Filet de sécurité des patches (déplacé tel quel, noms inchangés)

app/pipeline/orchestrator.py

@@ -32,6 +32,9 @@ from app.config import (
     HARNESS_REPAIR_MAX,
     MAX_ESCALADES,
     MULTI_SEED_NUM,
+    PEDAGO_AUDIT_ENABLED,
+    PEDAGO_ESCALATE_IN_AUTO,
+    PEDAGO_REPAIR_MAX,
 )
 from app.knowledge.rules_digest import build_rules_digest
 from app.llm.client import process_with_openrouter
@@ -39,7 +42,12 @@ from app.llm.cost import cost_delta, cost_snapshot
 from app.rag.catalogue import catalogue_for
 from app.pipeline import postprocess as pp
 from app.pipeline.analyze import run_analysis_phase
-from app.pipeline.audit import run_audit
+from app.pipeline.audit import (
+    format_pedagogical_issues,
+    pedagogical_badness,
+    run_audit,
+    run_pedagogical_audit,
+)
 from app.pipeline.fewshots import fewshot_for, fewshot_for_declinaison
 from app.pipeline.generate import (
     assemble_exercise,
@@ -47,7 +55,12 @@ from app.pipeline.generate import (
     generate_pair_blocks,
     split_original_questions,
 )
-from app.pipeline.prompts import REPAIR_PROMPT, SYSTEM_PROMPT, TRANSLATE_CONSTRAINTS_PROMPT
+from app.pipeline.prompts import (
+    PEDAGOGICAL_REPAIR_PROMPT,
+    REPAIR_PROMPT,
+    SYSTEM_PROMPT,
+    TRANSLATE_CONSTRAINTS_PROMPT,
+)
 from app.pipeline.solutions import replace_gen_solutions_with_source
 from app.pipeline.translate import ensure_language
 from app.validation import harness
@@ -101,6 +114,28 @@ def _translate_constraints_to_assertions(code: str, constraints: list[str],
     ]
 
 
+def _apply_deterministic_nets(candidate: str, decl_type: Optional[str]) -> str:
+    """Séquence des filets déterministes appliquée à toute sortie LLM (candidat
+    de génération OU de réparation harnais/pédagogique). Idempotente."""
+    candidate, _ = pp.fix_orphan_python_openers(candidate)
+    candidate = pp.normalize_python_fences(candidate)
+    candidate, _ = pp.drop_empty_python_blocks(candidate)
+    candidate, _ = pp.fix_triple_braces(candidate)
+    candidate, _ = pp.fix_superscript_double_brace(candidate)
+    candidate, _ = pp.unwrap_latex_injections(candidate)
+    candidate, _ = pp.auto_lift_injections(candidate)
+    candidate, _ = pp.rename_underscore_injections(candidate)
+    candidate, _ = pp.fix_dollar_digit(candidate)
+    if decl_type:
+        candidate, _ = pp.fix_mcq_answer_aliases(candidate)
+        candidate, _ = pp.merge_decl_python_blocks(candidate)
+    if decl_type == "qcm":
+        candidate, _ = pp.fix_none_option_last(candidate)
+    candidate, _ = pp.aerate_blocks(candidate)
+    candidate, _ = pp.renumber_question_ids(candidate)
+    return candidate
+
+
 def run_exercise(
     content: str,
     filename: str = "exercise.md",
@@ -412,24 +447,8 @@ def run_exercise(
             audit_warnings.append({"rule": "harnais",
                                    "message": f"Réparation LLM en échec : {e}."})
             break
-        candidate = pp.strip_fences(repaired)
         # Re-passe des filets déterministes sur le candidat réparé.
-        candidate, _ = pp.fix_orphan_python_openers(candidate)
-        candidate = pp.normalize_python_fences(candidate)
-        candidate, _ = pp.drop_empty_python_blocks(candidate)
-        candidate, _ = pp.fix_triple_braces(candidate)
-        candidate, _ = pp.fix_superscript_double_brace(candidate)
-        candidate, _ = pp.unwrap_latex_injections(candidate)
-        candidate, _ = pp.auto_lift_injections(candidate)
-        candidate, _ = pp.rename_underscore_injections(candidate)
-        candidate, _ = pp.fix_dollar_digit(candidate)
-        if decl_type:
-            candidate, _ = pp.fix_mcq_answer_aliases(candidate)
-            candidate, _ = pp.merge_decl_python_blocks(candidate)
-        if decl_type == "qcm":
-            candidate, _ = pp.fix_none_option_last(candidate)
-        candidate, _ = pp.aerate_blocks(candidate)
-        candidate, _ = pp.renumber_question_ids(candidate)
+        candidate = _apply_deterministic_nets(pp.strip_fences(repaired), decl_type)
         candidate_report = harness.validate_text(candidate, seeds=HARNESS_GATE_SEEDS)
 
         def _badness(r: dict) -> int:
@@ -453,6 +472,55 @@ def run_exercise(
                         + harness.format_report(report)[:600]),
         })
 
+    # ── 9. Audit pédagogique (déclinaisons, sortie VERTE) ────────────────────
+    # Au-delà du harnais MÉCANIQUE : un juge LLM évalue la finesse pédagogique et
+    # le respect des consignes (distracteurs cohérents, indevinabilité…), puis
+    # une réparation ciblée qui ne doit JAMAIS casser le harnais.
+    pedagogical = None
+    if decl_type and PEDAGO_AUDIT_ENABLED and report["ok"]:
+        _step("Audit pédagogique (finesse + respect des consignes)…")
+        # Juge sur son modèle dédié (PEDAGO_AUDIT_MODEL) — constant entre échelons,
+        # fort + JSON fiable, indépendant du modèle de génération qui escalade.
+        pedagogical = run_pedagogical_audit(myst_exercise, decl_type)
+        for attempt in range(PEDAGO_REPAIR_MAX):
+            if pedagogical.get("verdict") != "A_REVOIR" or not pedagogical.get("issues"):
+                break
+            _step(f"Réparation pédagogique {attempt + 1}/{PEDAGO_REPAIR_MAX}…")
+            try:
+                repaired = process_with_openrouter(
+                    prompt=PEDAGOGICAL_REPAIR_PROMPT.format(
+                        decl_label="QCM (MCQ)" if decl_type == "qcm" else "QAT (FGQ)",
+                        issues=format_pedagogical_issues(pedagogical["issues"]),
+                        exercise=myst_exercise,
+                    ),
+                    model=m_gen, temperature=0.0, max_tokens=30000,
+                    system_prompt=SYSTEM_PROMPT,
+                )
+            except (RuntimeError, ValueError, OSError) as e:
+                audit_warnings.append({"rule": "pédagogie",
+                                       "message": f"Réparation pédagogique en échec : {e}."})
+                break
+            cand = _apply_deterministic_nets(pp.strip_fences(repaired), decl_type)
+            cand_report = harness.validate_text(cand, seeds=HARNESS_GATE_SEEDS)
+            if not cand_report["ok"]:
+                audit_warnings.append({"rule": "pédagogie",
+                    "message": "Réparation pédagogique rejetée (casserait le harnais) "
+                               "— version précédente conservée."})
+                break
+            new_ped = run_pedagogical_audit(cand, decl_type)
+            if pedagogical_badness(new_ped) < pedagogical_badness(pedagogical):
+                myst_exercise, report, pedagogical = cand, cand_report, new_ped
+                audit_patches.append({"rule": "pédagogie", "location": "(exercice complet)",
+                    "fix": "réparation pédagogique LLM",
+                    "message": "Distracteurs/consignes améliorés suite à l'audit pédagogique.",
+                    "iteration": attempt + 1})
+            else:
+                break                     # n'améliore pas → on garde l'existant
+        if pedagogical.get("verdict") == "A_REVOIR":
+            audit_warnings.append({"rule": "pédagogie",
+                "message": "⚠️ QUALITÉ PÉDAGOGIQUE à revoir : "
+                           + format_pedagogical_issues(pedagogical.get("issues") or [])[:500]})
+
     # ── Résultat ─────────────────────────────────────────────────────────────
     return {
         "exercise": myst_exercise,
@@ -467,6 +535,7 @@ def run_exercise(
             "seeds": report["seeds"],
             "summary": harness.format_report(report),
         },
+        "pedagogical": pedagogical,
         "lang": lang_info,
         "decl_type": decl_type,
         "model_used": m_gen,
@@ -532,17 +601,34 @@ def run_with_policy(
             forced_models={"generate": mp.openrouter_id(key),
                            "audit": m_audit, "mecanique": m_meca},
         )
-        tried.append({"rung": i, "model": key, "ok": result["harness"]["ok"]})
-        if result["harness"]["ok"]:
+        harness_ok = result["harness"]["ok"]
+        ped = result.get("pedagogical") or {}
+        ped_verdict = ped.get("verdict")            # OK / A_REVOIR / INCONNU / None
+        tried.append({"rung": i, "model": key, "ok": harness_ok,
+                      "pedago": ped_verdict})
+        is_last = (i == len(rungs) - 1)
+        # Acceptation d'un échelon : harnais VERT ET (qualité pédagogique OK, ou
+        # on n'escalade pas sur la pédagogie, ou dernier échelon). Sinon on
+        # gravit l'échelon suivant — c'est le « meilleur modèle selon l'exo ».
+        pedago_ok = ped_verdict != "A_REVOIR"
+        escalate_pedago = (policy == "auto" and PEDAGO_ESCALATE_IN_AUTO
+                           and not pedago_ok and not is_last)
+        if harness_ok and not escalate_pedago:
             break
-        logger.info("Échelon %s ROUGE sur %s — escalade.", key, filename)
+        if not harness_ok:
+            logger.info("Échelon %s ROUGE (harnais) sur %s — escalade.", key, filename)
+        else:
+            logger.info("Échelon %s VERT mais qualité pédagogique à revoir sur %s "
+                        "— escalade de modèle.", key, filename)
 
     result["policy_telemetry"] = {
         "mode": policy,
         "difficulty": difficulty,
         "tried": tried,
         "winning_model": key,
-        "needs_review": not result["harness"]["ok"],
+        "pedago_verdict": (result.get("pedagogical") or {}).get("verdict"),
+        "needs_review": (not result["harness"]["ok"]
+                         or (result.get("pedagogical") or {}).get("verdict") == "A_REVOIR"),
     }
     # Coût honnête : inclut l'analyse partagée (si calculée ici) ET les
     # échelons perdants — pas seulement la tentative gagnante.

app/pipeline/prompts.py

@@ -929,3 +929,71 @@ RÈGLES DE CORRECTION :
 Réponds UNIQUEMENT avec l'exercice complet corrigé (de `````{{exercise}} à `````),
 sans préambule ni wrapper markdown.
 """
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AUDIT PÉDAGOGIQUE (2026-07-06) — juge la QUALITÉ (au-delà du harnais mécanique).
+# Le harnais prouve la conformité structurelle ; ce juge évalue la finesse
+# pédagogique et le RESPECT DES CONSIGNES (distracteurs cohérents, indevinabilité,
+# énoncé qui ne donne pas la réponse…). Peut déclencher une réparation ciblée et,
+# en mode auto, une escalade de modèle.
+# ─────────────────────────────────────────────────────────────────────────────
+
+PEDAGOGICAL_AUDIT_PROMPT = """\
+Tu es un RELECTEUR PÉDAGOGIQUE senior de PyxiScience. On te donne une déclinaison
+{decl_label} DÉJÀ VALIDE au harnais (structure/exécution correctes). Juge
+UNIQUEMENT sa QUALITÉ PÉDAGOGIQUE et le respect des consignes — jamais la syntaxe.
+
+CRITÈRES QCM (les plus importants) :
+  1. Distracteurs = ERREURS RÉELLES plausibles d'un élève (signe mal lu sur une
+     entrée, transposée, terme oublié, off-by-one…), JAMAIS des valeurs
+     artificielles ou au hasard, JAMAIS des variantes « une seule chose à la
+     fois » autour de la bonne réponse.
+  2. INDEVINABILITÉ — la bonne réponse ne doit PAS se repérer par la FORME :
+     • pas un bloc identique figé pendant qu'un seul varie (ex. matrice A figée,
+       seul b change) ; • pas d'étiquette qui trahit (« linear », « b=0 ») ;
+     • pas la seule simplifiée / avec radical / la plus longue ou courte ;
+     • pas de parenthèse ou exemple explicatif sur la SEULE bonne réponse ;
+     • distracteurs en grille symétrique (signe×signe, ordre×signe).
+  3. L'ÉNONCÉ ne donne JAMAIS la réponse ; formulation DIRECTE (retirer « montre
+     que », « calcule de deux façons », « trace », « justifie »).
+  4. questionHint = amorce de méthode qui NE révèle PAS la réponse.
+  5. Format IDENTIQUE entre toutes les options (longueur, style LaTeX, notation).
+  6. Fidélité à la source : mêmes notions testées, solution cohérente.
+
+CRITÈRES QAT/FGQ : champs {{input}} pertinents et bien placés ; displayedSolution
+lisible ; énoncé qui ne donne pas la réponse ; consignes de saisie claires.
+
+EXERCICE À JUGER :
+{exercise}
+
+Réponds UNIQUEMENT en JSON (aucune prose autour, aucun bloc markdown) :
+{{"verdict": "OK ou A_REVOIR", "score": 0-100, "issues": [{{"gravite": "haute|moyenne|basse", "ou": "question/option concernée", "probleme": "ce qui cloche", "correction": "quoi faire concrètement"}}]}}
+Règles de verdict : « OK » seulement si AUCUNE issue de gravité haute. Sois
+EXIGEANT mais JUSTE — signale un vrai défaut d'apprentissage, pas une préférence
+de style. Si l'exercice est bon, renvoie verdict « OK » et issues [].
+"""  # noqa: E501
+
+PEDAGOGICAL_REPAIR_PROMPT = """\
+Un relecteur pédagogique a listé des défauts de QUALITÉ sur cette déclinaison
+{decl_label}. La STRUCTURE est déjà correcte (harnais VERT) — NE LA CASSE PAS.
+Corrige UNIQUEMENT les défauts listés, avec le minimum de changements.
+
+DÉFAUTS À CORRIGER :
+{issues}
+
+CONTRAINTES DURES (ne rien casser) :
+  • Ne touche PAS à la structure MyST, aux IDs, aux poids, au format des blocs.
+  • UN SEUL bloc {{python}} (4 backticks) terminé par `globals()` ; les
+    distracteurs restent construits DANS ce bloc (variables camelCase `…Aff`),
+    à DELTA NON NUL garanti (jamais de flip de signe sur une entrée nulle).
+  • Exactement UNE `:isRightAnswer: true`, en slot 1 ; « None » en dernier.
+  • L'énoncé ne révèle JAMAIS la réponse ; garde la solution fidèle à la source.
+  • Injections `{{{{ }}}}` = noms de variables nus camelCase `Aff` uniquement.
+
+EXERCICE ACTUEL :
+{exercise}
+
+Réponds UNIQUEMENT avec l'exercice complet corrigé (de `````{{exercise}} à `````),
+sans préambule ni wrapper markdown.
+"""  # noqa: E501

app/web/templates/index.html

@@ -762,6 +762,20 @@ function setMetaResult(entry) {
   const verdict = h.ok
     ? `<span class="pill pill--ok">✓ Harnais VERT (${h.seeds} graines)</span>`
     : `<span class="pill pill--ko">✗ Harnais ROUGE (${h.seeds} graines)</span>`;
+  // Audit pédagogique (déclinaisons) : qualité au-delà du harnais mécanique.
+  let ped = "";
+  const p = r.pedagogical;
+  if (p && p.verdict) {
+    if (p.verdict === "OK") {
+      const sc = (p.score != null) ? ` (${p.score}/100)` : "";
+      ped = `<span class="pill pill--ok">✓ Qualité pédagogique${sc}</span>`;
+    } else if (p.verdict === "A_REVOIR") {
+      const n = (p.issues || []).length;
+      ped = `<span class="pill pill--ko">⚠ Qualité pédagogique à revoir (${n})</span>`;
+    } else {
+      ped = `<span class="pill pill--info">audit pédagogique indisponible</span>`;
+    }
+  }
   const cost = r.cost ? `<span class="pill pill--info">${r.cost.usd.toFixed(4)} $ · ${r.cost.requests} appels</span>` : "";
   const lang = r.lang ? `<span class="pill pill--info">langue : ${escapeHtml(r.lang.source)} → ${escapeHtml(r.lang.target)} (${escapeHtml(r.lang.action)})</span>` : "";
   const dur = r.duration_s ? `<span class="pill pill--info">${r.duration_s}s</span>` : "";
@@ -782,7 +796,7 @@ function setMetaResult(entry) {
   } else if (r.model_used) {
     pol = `<span class="pill pill--info">modèle : ${escapeHtml(prettyModelName(r.model_used))}</span>`;
   }
-  el.innerHTML = verdict + decl + pol + cost + lang + dur;
+  el.innerHTML = verdict + ped + decl + pol + cost + lang + dur;
 }
 
 /* Sélecteur de fichier (batch) */

audit.py

@@ -0,0 +1,331 @@
+"""
+audit.py
+────────
+Passe d'audit LLM (≤ MAX_AUDIT_ITERATIONS) + filet de sécurité des patches.
+Code déplacé depuis routes/pythonise_routes_v2.py avec deux corrections :
+  • un patch sûr est appliqué à TOUTES les occurrences identiques de
+    `location` (la v1 ne corrigeait que la première — un problème répété
+    subsistait N-1 fois) ;
+  • gestion d'erreurs ciblée (plus d'`except (json.JSONDecodeError, Exception)`).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Callable, Optional
+
+from app.config import MAX_AUDIT_ITERATIONS
+from app.knowledge.rules_digest import AUDIT_RULES_ALWAYS, build_rules_digest
+from app.llm.client import process_with_openrouter
+from app.pipeline.postprocess import insert_python_lines, strip_fences
+from app.pipeline.prompts import (
+    PEDAGOGICAL_AUDIT_PROMPT,
+    STEP_AUDIT_PROMPT,
+    SYSTEM_PROMPT,
+)
+
+logger = logging.getLogger(__name__)
+
+_DECL_LABELS_PED = {"qcm": "QCM (MCQ)", "qat": "QAT (FGQ)"}
+
+
+def run_pedagogical_audit(exercise: str, decl_type: str,
+                          model: Optional[str] = None) -> dict:
+    """Juge LLM de la QUALITÉ PÉDAGOGIQUE d'une déclinaison (au-delà du harnais
+    mécanique). Retourne {verdict: OK|A_REVOIR|INCONNU, score, issues:[…], model}.
+    Ne lève JAMAIS (dégrade en verdict INCONNU) — l'audit ne doit pas casser un
+    pipeline dont la sortie est déjà VERTE au harnais.
+
+    Robustesse JSON : essaie le modèle demandé (défaut PEDAGO_AUDIT_MODEL), puis
+    RETOMBE sur NOTIONS_MODEL (OpenAI, JSON fiable) — un juge fort peut renvoyer
+    une complétion vide (vu : deepseek-v4-pro content=null, 2026-07-06)."""
+    from app.config import NOTIONS_MODEL, PEDAGO_AUDIT_MODEL
+
+    label = _DECL_LABELS_PED.get(decl_type, "QCM (MCQ)")
+    prompt = PEDAGOGICAL_AUDIT_PROMPT.format(decl_label=label, exercise=exercise)
+    primary = model or PEDAGO_AUDIT_MODEL
+    last_err = None
+    seen: list = []
+    for cand in (primary, NOTIONS_MODEL):
+        if not cand or cand in seen:
+            continue
+        seen.append(cand)
+        try:
+            raw = process_with_openrouter(
+                prompt=prompt, model=cand, temperature=0.0, max_tokens=2000,
+                system_prompt=SYSTEM_PROMPT,
+            )
+            data = json.loads(strip_fences(raw))
+        except (RuntimeError, ValueError, OSError) as e:   # inclut JSONDecodeError
+            last_err = e
+            logger.warning("Audit pédagogique via %s en échec : %s", cand, e)
+            continue
+        issues = [i for i in (data.get("issues") or []) if isinstance(i, dict)]
+        high = [i for i in issues if str(i.get("gravite", "")).lower().startswith("haut")]
+        verdict = str(data.get("verdict", "")).upper()
+        ok = verdict.startswith("OK") and not high      # OK ⇔ aucune gravité haute
+        return {"verdict": "OK" if ok else "A_REVOIR", "score": data.get("score"),
+                "issues": issues, "model": cand, "error": None}
+    return {"verdict": "INCONNU", "score": None, "issues": [],
+            "model": None, "error": str(last_err)}
+
+
+def pedagogical_badness(ped: Optional[dict]) -> int:
+    """Score de gravité (pour ne garder une réparation que si elle AMÉLIORE)."""
+    if not ped:
+        return 0
+    issues = ped.get("issues") or []
+    high = sum(1 for i in issues if str(i.get("gravite", "")).lower().startswith("haut"))
+    return high * 100 + len(issues)
+
+
+def format_pedagogical_issues(issues: list) -> str:
+    lines = [f"  • [{i.get('gravite', '?')}] {i.get('ou', '')} — "
+             f"{i.get('probleme', '')} → {i.get('correction', '')}"
+             for i in issues]
+    return "\n".join(lines) or "  (aucun détail fourni)"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Filet de sécurité des patches (déplacé tel quel, noms inchangés)
+# ─────────────────────────────────────────────────────────────────────────────
+
+_KNOWN_FREE_NAMES = frozenset({
+    "True", "False", "None", "and", "or", "not", "in", "is", "if", "else",
+    "elif", "for", "while", "def", "class", "return", "lambda", "yield",
+    "with", "as", "from", "import", "pass", "break", "continue", "try",
+    "except", "finally", "raise", "global", "nonlocal", "assert", "del",
+    "self", "cls",
+    "pi", "e", "oo", "abs", "min", "max", "sum", "range", "len", "int",
+    "float", "str", "bool", "list", "tuple", "dict", "set", "round", "pow",
+    "all", "any", "map", "filter", "zip", "enumerate", "sorted", "reversed",
+    "print", "isinstance", "type", "repr", "hash",
+    "x", "y", "z", "t", "n", "config_standard",
+})
+
+
+def _patch_introduces_unbound_name(
+    myst_exercise: str,
+    location: str,
+    fix: str,
+    python_insert: Optional[str],
+) -> Optional[str]:
+    """Nom INJECTÉ ({{var}}) introduit par `fix` qui ne serait lié nulle part
+    après patch (NameError au rendu). None = sûr sur ce critère.
+    Volontairement limité aux placeholders : les autres mots d'un patch
+    markdown sont de la prose/du LaTeX, pas des variables Python (la v2 du
+    filet flaguait à tort `id`, `f`, `align`… dans des patches purement texte)."""
+    fix_names = set(re.findall(r"\{\{\s*([a-zA-Z_]\w*)\s*\}\}", fix))
+    loc_names = set(re.findall(r"\{\{\s*([a-zA-Z_]\w*)\s*\}\}", location))
+    new_names = (fix_names - loc_names) - _KNOWN_FREE_NAMES
+    if not new_names:
+        return None
+
+    after_patch = myst_exercise.replace(location, fix)
+    if python_insert:
+        after_patch += "\n" + python_insert
+
+    for name in new_names:
+        patterns = (
+            rf"\b{re.escape(name)}\s*=(?!=)",
+            rf"\bdef\s+{re.escape(name)}\b",
+            rf"\bclass\s+{re.escape(name)}\b",
+            rf"\bfor\s+{re.escape(name)}\b",
+            rf"\bas\s+{re.escape(name)}\b",
+            rf"\bimport\s+(?:\w+\s*,\s*)*{re.escape(name)}\b",
+            rf"\bfrom\s+[\w.]+\s+import\s+(?:[^,\n]*,\s*)*{re.escape(name)}\b",
+            rf"\bdef\s+\w+\([^)]*\b{re.escape(name)}\b[^)]*\)",
+        )
+        if not any(re.search(p, after_patch) for p in patterns):
+            return name
+    return None
+
+
+def _is_patch_safe(
+    myst_exercise: str,
+    location: str,
+    fix: str,
+    python_insert: Optional[str] = None,
+) -> tuple[bool, str]:
+    """Validation défensive avant application d'un patch d'audit."""
+    # 1) Alias d'import supprimé mais encore utilisé.
+    alias_re = re.compile(r"\bimport\b[^\n]*?\bas\s+(\w+)")
+    dropped = set(alias_re.findall(location)) - set(alias_re.findall(fix))
+    if dropped:
+        rest = myst_exercise.replace(location, "", 1)
+        for alias in dropped:
+            if re.search(rf"\b{re.escape(alias)}\s*\(", rest):
+                return False, f"Alias `{alias}` est utilisé ailleurs dans le code — patch refusé."
+
+    # 1bis) Import supprimé mais encore référencé.
+    def _extract_imported_names(text: str) -> set[str]:
+        names: set[str] = set()
+        for m in re.finditer(r"^\s*import\s+([\w.]+)(?:\s+as\s+(\w+))?", text, re.MULTILINE):
+            names.add(m.group(2) or m.group(1).split(".")[0])
+        for m in re.finditer(r"^\s*from\s+[\w.]+\s+import\s+(.+?)\s*$", text, re.MULTILINE):
+            for piece in m.group(1).split(","):
+                am = re.match(r"^(\w+)(?:\s+as\s+(\w+))?$", piece.strip())
+                if am:
+                    names.add(am.group(2) or am.group(1))
+        return names
+
+    dropped_imports = _extract_imported_names(location) - _extract_imported_names(fix)
+    if dropped_imports:
+        rest = myst_exercise.replace(location, fix, 1)
+        for name in dropped_imports:
+            if re.search(rf"\b{re.escape(name)}\b(?:\s*[(.])", rest):
+                return False, (f"L'import `{name}` est encore utilisé ailleurs après le patch "
+                               "— refus pour éviter une NameError au runtime.")
+
+    # 2) Suppression de globals().
+    if "globals()" in location and "globals()" not in fix:
+        return False, "Le patch supprimerait `globals()` (requis en fin de bloc python)."
+
+    # 2bis) Règle 6.4 — **config_standard sur un helper PyxiScience (réservé à
+    #       sympy.latex). Liste alignée sur le catalogue curé app/knowledge.
+    _PYXISCIENCE_HELPERS = (
+        "pxsl_format_number", "pxsl_res_num", "pxsl_matrix", "pxsl_pow",
+        "pxsl_latex_coefficient", "pxsl_par", "pxsl_mult", "pxsl_choose_udv", "lc",
+        "pxsl_latex", "pxsl_sign", "pxsl_latex_with_formatting", "pxsl_Rational",
+        "pxsl_sum_matrix", "pxsl_prod_matrix", "pxsl_prod_scalar_matrix",
+        "pxsl_ax", "pxsl_system_lin", "pxsl_double_matrix", "pxsl_lines_op",
+        "pxsl_resol_system", "pxsl_pow_matrix", "pxsl_law", "pxsl_moment",
+        "pxsl_scalar_product", "pxsl_sum_vector", "pxs_explain_IBP",
+    )
+
+    def _splat_pattern(name: str) -> str:
+        return (rf"\b{re.escape(name)}\s*\("
+                r"(?:[^()]|\([^()]*\))*"
+                r"\*\*\s*config_standard"
+                r"(?:[^()]|\([^()]*\))*\)")
+
+    for helper in _PYXISCIENCE_HELPERS:
+        pat = _splat_pattern(helper)
+        if re.search(pat, fix) and not re.search(pat, location):
+            return False, (f"Le patch ajoute `**config_standard` à `{helper}(...)` — "
+                           "ce helper PyxiScience ne l'accepte pas et plante (règle 6.4). "
+                           "Réserve `**config_standard` à `sympy.latex(...)` uniquement.")
+
+    # 3) Variable jamais définie.
+    unbound = _patch_introduces_unbound_name(myst_exercise, location, fix, python_insert)
+    if unbound:
+        return False, (f"Le patch introduit la variable `{unbound}` qui n'est définie nulle part "
+                       "(NameError à l'exécution). Si une définition Python est nécessaire, "
+                       "utilise `python_insert` dans l'audit.")
+    return True, ""
+
+
+def _replace_everywhere(text: str, location: str, fix: str) -> tuple[str, int]:
+    """Remplace TOUTES les occurrences de location (1 seule si fix ⊇ location,
+    pour éviter la ré-expansion infinie)."""
+    if location in fix:
+        return text.replace(location, fix, 1), 1
+    n = text.count(location)
+    return text.replace(location, fix), n
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Boucle d'audit
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run_audit(
+    myst_exercise: str,
+    step1_targets: list[str],
+    model_idx: int,
+    set_step: Optional[Callable[[str], None]] = None,
+    model: Optional[str] = None,
+) -> tuple[str, list[dict], list[dict]]:
+    """Audit LLM en boucle (≤ MAX_AUDIT_ITERATIONS). Retourne
+    (exercice patché, patches appliqués, warnings)."""
+    audit_rule_ids = list(dict.fromkeys(AUDIT_RULES_ALWAYS + step1_targets))
+    audit_digest = build_rules_digest(audit_rule_ids)
+
+    patches: list[dict] = []
+    warnings: list[dict] = []
+
+    for audit_iter in range(MAX_AUDIT_ITERATIONS):
+        if set_step:
+            set_step(f"Audit {audit_iter + 1}/{MAX_AUDIT_ITERATIONS}…")
+        try:
+            audit_raw = process_with_openrouter(
+                prompt=STEP_AUDIT_PROMPT.format(
+                    audit_rules=audit_digest,
+                    exercise=myst_exercise,
+                ),
+                model_idx=model_idx,
+                model=model,
+                temperature=0.0,
+                max_tokens=8192,
+                system_prompt=SYSTEM_PROMPT,
+            )
+        except (RuntimeError, ValueError, OSError) as audit_err:
+            logger.warning("Appel d'audit en échec : %s", audit_err)
+            warnings.append({"rule": "?", "message": f"Audit pass failed: {audit_err}"})
+            break
+
+        try:
+            audit_data = json.loads(strip_fences(audit_raw))
+        except json.JSONDecodeError:
+            warnings.append({
+                "rule": "?",
+                "message": "Audit LLM did not return valid JSON; skipping further iterations.",
+            })
+            break
+
+        if audit_data.get("verdict") == "OK":
+            break
+
+        applied_this_iter = 0
+        for issue in audit_data.get("issues") or []:
+            if not isinstance(issue, dict):
+                continue
+            rule = str(issue.get("rule", "?"))
+            location = issue.get("location") or ""
+            fix = issue.get("fix")
+            python_insert = issue.get("python_insert")
+            can_patch = bool(issue.get("can_patch", True))
+            message = issue.get("message") or ""
+            applied = False
+
+            if (can_patch and isinstance(location, str) and isinstance(fix, str)
+                    and location and location in myst_exercise):
+                safe, reason = _is_patch_safe(myst_exercise, location, fix, python_insert)
+                if safe:
+                    myst_exercise, n_occ = _replace_everywhere(myst_exercise, location, fix)
+                    applied = True
+                    if n_occ > 1:
+                        message += f" ({n_occ} occurrences corrigées)"
+                else:
+                    warnings.append({
+                        "rule": rule,
+                        "location": location,
+                        "message": f"Patch refusé par filet de sécurité : {reason} (suggestion: {message})",
+                    })
+                    continue
+
+            if applied and isinstance(python_insert, str) and python_insert.strip():
+                myst_exercise = insert_python_lines(myst_exercise, [python_insert.strip()])
+
+            if applied:
+                patches.append({
+                    "rule": rule,
+                    "location": location,
+                    "fix": fix,
+                    "python_insert": python_insert or None,
+                    "message": message,
+                    "iteration": audit_iter + 1,
+                })
+                applied_this_iter += 1
+            else:
+                warnings.append({
+                    "rule": rule,
+                    "location": location if isinstance(location, str) else "",
+                    "message": message,
+                })
+
+        if applied_this_iter == 0:
+            break
+
+    return myst_exercise, patches, warnings

config.py

@@ -0,0 +1,124 @@
+"""
+config.py
+─────────
+Configuration centrale de l'app « Pythonise Exercice v2 ».
+Toutes les constantes réglables vivent ici — une seule source de vérité.
+"""
+
+import os
+from pathlib import Path
+
+# ── Chemins ──────────────────────────────────────────────────────────────────
+PACKAGE_DIR   = Path(__file__).resolve().parent          # …/pythonisation_app/app
+BASE_DIR      = PACKAGE_DIR.parent                       # …/pythonisation_app
+DATA_DIR      = BASE_DIR / "data"
+NOTIONS_XLSX  = DATA_DIR / "notions.xlsx"
+FAISS_CACHE   = DATA_DIR / "faiss_cache" / "sources"
+CORPUS_DIR    = PACKAGE_DIR / "corpus"                   # 5 fichiers de fonctions PyxiScience
+KNOWLEDGE_DIR = PACKAGE_DIR / "knowledge"
+RULES_MD      = KNOWLEDGE_DIR / "pythonisation_rules.md"
+FEWSHOTS_DIR  = KNOWLEDGE_DIR / "fewshots"
+TEMPLATES_DIR = PACKAGE_DIR / "web" / "templates"
+
+# ── Version applicative (exposée par /health pour vérifier un déploiement) ───
+# Bumper à chaque déploiement significatif : permet de répondre « à jour ? »
+# sans se connecter (curl /health → champ "version").
+APP_VERSION = "2026-07-06 — audit pédagogique + MCQ_SPEC v3 + Stop + Render"
+
+# ── Convention MyST (vérifiée empiriquement : 222/222 exemples plateforme) ───
+# Bloc {python} = 4 backticks ; enveloppe {exercise} = 5 backticks.
+PYTHON_FENCE_BACKTICKS = 4
+EXERCISE_FENCE_BACKTICKS = 5
+
+# ── Modèles LLM (IDs vérifiés sur l'API OpenRouter le 2026-07-02) ────────────
+# NOTE : claude-fable-5 retiré volontairement (§7 du prompt banc multi-modèles).
+AVAILABLE_MODELS = {
+    0: "anthropic/claude-opus-4.8",
+    1: "anthropic/claude-sonnet-5",
+    2: "anthropic/claude-haiku-4.5",
+    3: "google/gemini-2.5-pro",
+    4: "openai/gpt-5.4",
+}
+DEFAULT_MODEL_IDX = 1            # claude-sonnet-5
+
+# Modèle de l'étape d'analyse : None = suivre le modèle choisi par l'utilisateur
+# (corrige le model_idx=2 codé en dur de l'ancienne version) ; un int force un
+# modèle dédié pour l'analyse.
+ANALYSIS_MODEL_IDX: int | None = None
+
+# Modèle du juge de notions (appel léger, JSON court). DOIT supporter
+# response_format=json_object côté OpenRouter (modèles OpenAI — les Claude
+# le rejettent et le retriever dégrade en contexte vide).
+NOTIONS_MODEL = "openai/gpt-5-mini"
+
+# Prix $/M tokens (fallback si l'API generation ne renvoie pas le coût réel).
+# Relevés sur openrouter.ai le 2026-07-02. Source détaillée (cache/batch) :
+# app/models/prices.json — à re-vérifier avant prod, ça bouge chaque semaine.
+MODEL_PRICING = {
+    "anthropic/claude-opus-4.8":   {"input": 5.0,   "output": 25.0},
+    "anthropic/claude-sonnet-5":   {"input": 2.0,   "output": 10.0},
+    "anthropic/claude-haiku-4.5":  {"input": 1.0,   "output": 5.0},
+    "google/gemini-2.5-pro":       {"input": 1.25,  "output": 10.0},
+    "google/gemini-2.5-flash":     {"input": 0.3,   "output": 2.5},
+    "openai/gpt-5.4":              {"input": 2.5,   "output": 15.0},
+    "openai/gpt-5.4-nano":         {"input": 0.2,   "output": 1.25},
+    "x-ai/grok-4.3":               {"input": 1.25,  "output": 2.5},
+    "moonshotai/kimi-k2.6":        {"input": 0.55,  "output": 3.2},
+    "z-ai/glm-5.2":                {"input": 0.93,  "output": 3.0},
+    "z-ai/glm-4.7-flash":          {"input": 0.06,  "output": 0.4},
+    "deepseek/deepseek-v4-pro":    {"input": 0.435, "output": 0.87},
+    "deepseek/deepseek-v4-flash":  {"input": 0.089, "output": 0.18},
+    "mistralai/mistral-large-2512": {"input": 0.5,  "output": 1.5},
+    "mistralai/mistral-small-3.2-24b-instruct": {"input": 0.075, "output": 0.2},
+    "minimax/minimax-m3":          {"input": 0.3,   "output": 1.2},
+}
+
+# ── Politique de sélection de modèle (banc multi-modèles, §5) ────────────────
+DEFAULT_POLICY = "auto"          # auto | best | cheap | manual
+SEUIL_VERT = 0.90                # taux VERT minimal pour qu'un modèle « tienne »
+MAX_ESCALADES = 3                # plafond d'échelons gravis en mode auto
+PRICES_PATH = PACKAGE_DIR / "models" / "prices.json"
+RECOMMENDED_PATH = PACKAGE_DIR / "models" / "recommended.json"
+# Choix explicites du mode `manual` (clés du catalogue app/models/catalog.py).
+MODEL_GENERATE = "claude-sonnet-5"
+MODEL_AUDIT = "claude-opus-4-8"
+MODEL_MECANIQUE = "claude-haiku-4-5"
+
+# ── Pipeline ─────────────────────────────────────────────────────────────────
+RAG_TOP_K            = 10        # catalogue RAG (était 3 — trop étroit)
+RAG_EMBEDDING_MODEL  = "openai-3-small"
+MAX_AUDIT_ITERATIONS = 2
+USE_REASONING        = False     # extended thinking sur les appels de génération
+REASONING_CONFIG     = {"max_tokens": 4000}   # utilisé seulement si USE_REASONING
+MULTI_SEED_NUM       = 100       # graines de la validation d'invariants (règle 4.3)
+HARNESS_GATE_SEEDS   = 100       # graines de la porte harnais en fin de pipeline
+HARNESS_REPAIR_MAX   = 2         # boucles de réparation LLM si la porte est rouge
+
+# ── Audit pédagogique des déclinaisons (au-delà du harnais mécanique) ────────
+# Juge LLM de la QUALITÉ (distracteurs cohérents, indevinabilité, consignes)
+# après une sortie VERTE au harnais. Coût : +1 appel LLM/déclinaison (+1 si
+# réparation). Mettre PEDAGO_AUDIT_ENABLED=False pour revenir au harnais seul.
+PEDAGO_AUDIT_ENABLED    = True
+PEDAGO_REPAIR_MAX       = 1      # réparations pédagogiques ciblées (structure préservée)
+PEDAGO_ESCALATE_IN_AUTO = True   # mode auto : escalade de modèle si qualité insuffisante
+# Modèle du JUGE pédagogique (constant, indépendant du modèle de génération qui
+# escalade). Exige un fort raisonnement ET un JSON fiable — deepseek-v4-pro (rôle
+# audit) renvoyait content=null sur ce prompt (2026-07-06). Repli = NOTIONS_MODEL
+# (OpenAI, JSON garanti) si le primaire échoue encore. IDs OpenRouter en chaîne.
+PEDAGO_AUDIT_MODEL      = "openai/gpt-5.4"
+
+# ── Langue cible ─────────────────────────────────────────────────────────────
+DEFAULT_LANG = "fr"              # "fr" | "en" | "both"
+
+# ── Modes (pythonisation / déclinaisons QCM-QAT) ─────────────────────────────
+DEFAULT_MODE = "pythonise"       # "pythonise" | "declinaisons"
+DECLINAISON_TYPES = ("qcm", "qat")
+MCQ_NUM_OPTIONS = 5              # 1 correcte + 3 distracteurs + « None » en dernier
+QAT_FALLBACK_TO_MCQ = True       # question non auto-corrigeable en champ libre → MCQ
+
+# ── Serveur / jobs ───────────────────────────────────────────────────────────
+JOB_TTL = 1800                   # s avant purge d'un job terminé
+# HOST/PORT pilotables par l'environnement (déploiement). En local : 127.0.0.1.
+# En conteneur (Hugging Face Spaces) : HOST=0.0.0.0, PORT=7860 (imposé par HF).
+HOST = os.getenv("HOST", "127.0.0.1")
+PORT = int(os.getenv("PORT", "5000"))

gen_decl_sample.py

@@ -0,0 +1,36 @@
+"""Génère une déclinaison réelle et sauvegarde la sortie pour inspection.
+
+    PYTHONPATH=. .venv/bin/python tests/gen_decl_sample.py [qcm|qat] [exo]
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from app import _load_env, _setup_logging
+
+_setup_logging()
+_load_env()
+
+from app.pipeline.orchestrator import run_declinaisons
+
+decl = sys.argv[1] if len(sys.argv) > 1 else "qcm"
+SRC = Path(sys.argv[2]) if len(sys.argv) > 2 else \
+    Path(__file__).resolve().parent.parent / "bench" / "corpus" / "trinome_pythonise.md"
+
+content = SRC.read_text(encoding="utf-8")
+(dt, res), = run_declinaisons(content, filename=SRC.name, lang="fr",
+                              types=[decl])
+out = Path(f"/tmp/decl_{decl}_sample.md")
+out.write_text(res["exercise"], encoding="utf-8")
+print(f"harnais : {'VERT' if res['harness']['ok'] else 'ROUGE'} → {out}")
+ped = res.get("pedagogical")
+if ped:
+    print(f"pédagogique : verdict={ped.get('verdict')} score={ped.get('score')} "
+          f"issues={len(ped.get('issues') or [])}")
+    for it in (ped.get("issues") or [])[:5]:
+        print(f"   - [{it.get('gravite')}] {it.get('ou')} : {it.get('probleme')}")
+tel = res.get("policy_telemetry")
+if tel:
+    print(f"policy : échelons={len(tel.get('tried') or [])} "
+          f"gagnant={tel.get('winning_model')} pédago={tel.get('pedago_verdict')}")

index.html

@@ -0,0 +1,1048 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<title>Pythonise Exercice — v2</title>
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet">
+
+<style>
+  :root {
+    --bg:            #f7f7f8;
+    --panel:         #ffffff;
+    --panel-alt:     #fafafb;
+    --panel-hover:   #f4f4f5;
+    --border:        #e4e4e7;
+    --border-soft:   #eeeef0;
+    --border-strong: #d4d4d8;
+    --text:          #09090b;
+    --text-2:        #27272a;
+    --text-muted:    #71717a;
+    --text-soft:     #a1a1aa;
+    --primary:       #18181b;
+    --primary-hover: #27272a;
+    --primary-fg:    #fafafa;
+    --accent:        #2563eb;
+    --success:       #16a34a;
+    --success-bg:    #f0fdf4;
+    --success-border:#bbf7d0;
+    --error:         #dc2626;
+    --error-bg:      #fef2f2;
+    --error-border:  #fecaca;
+    --warn:          #ca8a04;
+    --warn-bg:       #fefce8;
+    --sans: 'Geist', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, sans-serif;
+    --mono: 'Geist Mono', 'JetBrains Mono', "SF Mono", Menlo, monospace;
+    --radius:        10px;
+    --radius-sm:     6px;
+    --radius-xs:     4px;
+    --shadow-xs:     0 1px 2px rgba(9, 9, 11, 0.04);
+    --shadow-sm:     0 1px 2px rgba(9, 9, 11, 0.04), 0 2px 8px rgba(9, 9, 11, 0.03);
+    --shadow-focus:  0 0 0 3px rgba(37, 99, 235, 0.12);
+  }
+
+  * { box-sizing: border-box; }
+  html, body { margin: 0; padding: 0; }
+  [hidden] { display: none !important; }
+
+  body {
+    background: var(--bg);
+    color: var(--text);
+    font-family: var(--sans);
+    font-size: 14px;
+    line-height: 1.55;
+    -webkit-font-smoothing: antialiased;
+  }
+  .container { max-width: 1320px; margin: 0 auto; padding: 40px 32px 56px; }
+
+  .header {
+    display: flex; align-items: center; justify-content: space-between; gap: 16px;
+    margin-bottom: 28px; padding-bottom: 24px;
+    border-bottom: 1px solid var(--border-soft); flex-wrap: wrap;
+  }
+  .header-left { display: flex; align-items: center; gap: 14px; }
+  .header-mark {
+    width: 36px; height: 36px; border-radius: 8px;
+    background: var(--primary); color: var(--primary-fg);
+    display: flex; align-items: center; justify-content: center;
+    font-family: var(--mono); font-weight: 500; font-size: 13px;
+  }
+  .header-text h1 { margin: 0 0 2px; font-size: 17px; font-weight: 600; }
+  .header-text p { margin: 0; color: var(--text-muted); font-size: 13px; }
+  .header-status {
+    display: inline-flex; align-items: center; gap: 8px; font-size: 12px;
+    color: var(--text-muted); font-weight: 500; padding: 6px 12px;
+    background: var(--panel); border: 1px solid var(--border); border-radius: 999px;
+  }
+  .header-status .dot {
+    width: 6px; height: 6px; border-radius: 50%; background: var(--success);
+    box-shadow: 0 0 0 3px rgba(22, 163, 74, 0.15);
+  }
+
+  .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 24px; }
+  @media (max-width: 960px) { .grid { grid-template-columns: 1fr; } }
+
+  .panel {
+    background: var(--panel); border: 1px solid var(--border);
+    border-radius: var(--radius); box-shadow: var(--shadow-sm);
+    padding: 24px; display: flex; flex-direction: column; min-width: 0;
+  }
+  .panel-title {
+    font-size: 11px; font-weight: 600; color: var(--text-muted);
+    margin: 0 0 16px; letter-spacing: 0.08em; text-transform: uppercase;
+  }
+
+  .field { margin-bottom: 14px; }
+  .field-label {
+    display: block; font-size: 12px; font-weight: 500; color: var(--text-2);
+    margin-bottom: 6px;
+  }
+  textarea, input[type="text"], select {
+    width: 100%; background: var(--panel); border: 1px solid var(--border);
+    border-radius: var(--radius-sm); padding: 10px 12px; font-family: inherit;
+    font-size: 13px; line-height: 1.55; color: var(--text);
+    transition: border-color 0.15s ease, box-shadow 0.15s ease;
+  }
+  textarea {
+    font-family: var(--mono); font-size: 12.5px; line-height: 1.6;
+    height: 320px; resize: vertical; min-height: 160px;
+  }
+  textarea:focus, input[type="text"]:focus, select:focus {
+    outline: none; border-color: var(--accent); box-shadow: var(--shadow-focus);
+  }
+  select {
+    appearance: none; -webkit-appearance: none;
+    background-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12'><path fill='none' stroke='%2371717a' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round' d='M3 5 L6 8 L9 5'/></svg>");
+    background-repeat: no-repeat; background-position: right 10px center;
+    background-size: 12px; padding-right: 32px; cursor: pointer; font-weight: 500;
+  }
+
+  .meta { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 12px 14px; margin: 18px 0 20px; }
+  .meta-full { grid-column: 1 / -1; }
+
+  .actions { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+  .btn {
+    display: inline-flex; align-items: center; gap: 6px; padding: 9px 16px;
+    border-radius: var(--radius-sm); border: 1px solid var(--border);
+    background: var(--panel); color: var(--text); font-family: inherit;
+    font-size: 13px; font-weight: 500; cursor: pointer;
+    transition: all 0.15s ease; box-shadow: var(--shadow-xs);
+  }
+  .btn:hover:not(:disabled) { background: var(--panel-hover); border-color: var(--border-strong); }
+  .btn:disabled { opacity: 0.45; cursor: not-allowed; }
+  .btn--primary { background: var(--primary); border-color: var(--primary); color: var(--primary-fg); }
+  .btn--primary:hover:not(:disabled) { background: var(--primary-hover); }
+  .btn--ghost { background: transparent; border-color: transparent; color: var(--text-muted); box-shadow: none; padding: 7px 12px; }
+  .btn--ghost:hover:not(:disabled) { background: var(--panel-hover); color: var(--text); }
+  .btn--small { padding: 5px 11px; font-size: 12px; }
+
+  /* Batch file list */
+  .filelist { list-style: none; padding: 0; margin: 10px 0 0; }
+  .filelist li {
+    display: flex; align-items: center; gap: 8px;
+    font-family: var(--mono); font-size: 12px; color: var(--text-2);
+    padding: 5px 8px; border: 1px solid var(--border-soft);
+    border-radius: var(--radius-xs); margin-bottom: 4px; background: var(--panel-alt);
+  }
+  .filelist .rm { margin-left: auto; cursor: pointer; color: var(--text-soft); border: none; background: none; font-size: 13px; }
+  .filelist .rm:hover { color: var(--error); }
+
+  .progress { margin-top: 18px; padding-top: 16px; border-top: 1px solid var(--border-soft); }
+  .progress-line { display: flex; align-items: center; gap: 10px; font-size: 13px; color: var(--text-2); }
+  .progress-spinner {
+    width: 12px; height: 12px; border: 1.5px solid var(--border-strong);
+    border-top-color: var(--text); border-radius: 50%;
+    animation: spin 0.7s linear infinite; flex-shrink: 0;
+  }
+  .progress-label { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .progress-step {
+    font-family: var(--mono); font-size: 11px; color: var(--text-muted);
+    padding: 2px 7px; background: var(--bg); border: 1px solid var(--border-soft);
+    border-radius: var(--radius-xs); white-space: nowrap;
+  }
+  .progress-bar { margin-top: 10px; height: 3px; background: var(--border-soft); border-radius: 3px; overflow: hidden; position: relative; }
+  .progress-bar-fill { position: absolute; inset: 0; background: var(--text); transform: translateX(-100%); border-radius: 3px; }
+  .progress.is-running .progress-bar-fill { animation: slide 1.6s cubic-bezier(0.4, 0, 0.2, 1) infinite; }
+  .progress.is-done .progress-bar-fill { transform: translateX(0); background: var(--success); }
+  .progress.is-error .progress-bar-fill { transform: translateX(0); background: var(--error); }
+  .progress.is-idle .progress-spinner, .progress.is-done .progress-spinner, .progress.is-error .progress-spinner { display: none; }
+
+  @keyframes spin { to { transform: rotate(360deg); } }
+  @keyframes slide {
+    0%   { transform: translateX(-100%) scaleX(0.35); }
+    50%  { transform: translateX(0%)    scaleX(0.65); }
+    100% { transform: translateX(100%)  scaleX(0.35); }
+  }
+  @keyframes fadeIn { from { opacity: 0; transform: translateY(4px); } to { opacity: 1; transform: translateY(0); } }
+
+  .status {
+    margin-top: 12px; padding: 10px 14px; border-radius: var(--radius-sm);
+    font-size: 13px; border: 1px solid transparent; animation: fadeIn 0.2s ease-out;
+    display: flex; align-items: center; gap: 8px;
+  }
+  .status::before { content: ''; width: 6px; height: 6px; border-radius: 50%; flex-shrink: 0; }
+  .status.is-error { background: var(--error-bg); border-color: var(--error-border); color: #991b1b; }
+  .status.is-error::before { background: var(--error); }
+  .status.is-done { background: var(--success-bg); border-color: var(--success-border); color: #166534; }
+  .status.is-done::before { background: var(--success); }
+  .status.is-warn { background: var(--warn-bg); border-color: #fde68a; color: #854d0e; }
+  .status.is-warn::before { background: var(--warn); }
+
+  /* Résumé batch + sélecteur de fichier résultat */
+  .result-files { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 12px; }
+  .result-file {
+    display: inline-flex; align-items: center; gap: 6px;
+    font-family: var(--mono); font-size: 11.5px; padding: 4px 10px;
+    border: 1px solid var(--border); border-radius: 999px;
+    background: var(--panel); cursor: pointer; color: var(--text-2);
+  }
+  .result-file.is-active { border-color: var(--text); background: var(--panel-hover); }
+  .verdict-dot { width: 7px; height: 7px; border-radius: 50%; }
+  .verdict-dot.ok  { background: var(--success); }
+  .verdict-dot.ko  { background: var(--error); }
+  .verdict-dot.err { background: var(--warn); }
+
+  .tabs {
+    display: flex; align-items: center; gap: 2px; margin-bottom: 14px;
+    padding: 4px; background: var(--bg); border: 1px solid var(--border-soft);
+    border-radius: var(--radius-sm); flex-wrap: wrap;
+  }
+  .tab {
+    background: transparent; border: none; padding: 6px 12px; font-family: inherit;
+    font-size: 13px; font-weight: 500; color: var(--text-muted); cursor: pointer;
+    border-radius: var(--radius-xs); transition: all 0.15s ease;
+  }
+  .tab.is-active { color: var(--text); background: var(--panel); box-shadow: var(--shadow-xs); }
+  .tab-badge {
+    display: inline-block; margin-left: 5px; padding: 0 6px; min-width: 18px;
+    height: 16px; font-size: 10px; font-family: var(--mono); font-weight: 500;
+    background: var(--text); color: var(--primary-fg); border-radius: 8px;
+    line-height: 16px; text-align: center; vertical-align: 1px;
+  }
+  .tab-spacer { flex: 1; }
+  .tab-panels { flex: 1; min-height: 0; display: flex; flex-direction: column; }
+  .tab-panel { display: none; flex: 1; min-height: 0; flex-direction: column; }
+  .tab-panel.is-active { display: flex; animation: fadeIn 0.18s ease-out; }
+
+  .output {
+    background: var(--panel-alt); border: 1px solid var(--border-soft);
+    border-radius: var(--radius-sm); padding: 16px 18px; margin: 0;
+    font-family: var(--mono); font-size: 12.5px; line-height: 1.65;
+    color: var(--text-2); min-height: 380px; max-height: 620px;
+    overflow: auto; white-space: pre-wrap; word-break: break-word;
+  }
+  .output .empty { color: var(--text-soft); font-family: var(--sans); font-size: 13px; }
+  .output--audit { font-family: var(--sans); font-size: 13px; line-height: 1.6; white-space: normal; color: var(--text); }
+
+  .output::-webkit-scrollbar { width: 10px; height: 10px; }
+  .output::-webkit-scrollbar-thumb { background: var(--border); border-radius: 5px; border: 2px solid var(--panel-alt); }
+
+  .audit-section + .audit-section { margin-top: 24px; }
+  .audit-heading {
+    font-size: 11px; font-weight: 600; color: var(--text-muted);
+    text-transform: uppercase; letter-spacing: 0.08em; margin: 0 0 12px;
+    display: flex; align-items: center; gap: 8px;
+  }
+  .audit-heading .count {
+    color: var(--text-soft); font-weight: 500; font-family: var(--mono);
+    font-size: 10px; padding: 1px 6px; background: var(--bg); border-radius: 999px;
+  }
+  .audit-list { list-style: none; padding: 0; margin: 0; }
+  .audit-patch { padding: 14px 0; border-top: 1px solid var(--border-soft); }
+  .audit-patch:first-child { border-top: none; padding-top: 0; }
+  .audit-rule {
+    display: inline-flex; font-family: var(--mono); font-size: 11px; font-weight: 500;
+    color: var(--text-2); background: var(--bg); border: 1px solid var(--border);
+    padding: 2px 8px; border-radius: var(--radius-xs); margin-bottom: 10px;
+  }
+  .audit-diff { display: grid; grid-template-columns: 1fr; gap: 6px; }
+  .audit-before, .audit-after {
+    font-family: var(--mono); font-size: 12px; padding: 10px 12px; margin: 0;
+    border-radius: var(--radius-xs); white-space: pre-wrap; line-height: 1.55;
+    border-left: 2px solid;
+  }
+  .audit-before { background: var(--error-bg); border-left-color: var(--error); color: #991b1b; text-decoration: line-through; }
+  .audit-after { background: var(--success-bg); border-left-color: var(--success); color: #166534; }
+  .audit-warnings { list-style: none; padding: 0; margin: 0; }
+  .audit-warnings li {
+    padding: 10px 0 10px 18px; border-top: 1px solid var(--border-soft);
+    position: relative; color: var(--text-2); font-size: 13px;
+  }
+  .audit-warnings li:first-child { border-top: none; }
+  .audit-warnings li::before {
+    content: ''; position: absolute; left: 0; top: 17px; width: 5px; height: 5px;
+    border-radius: 50%; background: var(--warn); box-shadow: 0 0 0 3px rgba(202, 138, 4, 0.15);
+  }
+  .audit-warnings .rule-ref {
+    display: inline-block; font-family: var(--mono); font-size: 11px; font-weight: 500;
+    color: var(--text-muted); background: var(--bg); padding: 1px 6px;
+    border-radius: var(--radius-xs); margin-right: 6px;
+  }
+
+  /* Bandeau verdict + coût */
+  .meta-result {
+    display: flex; gap: 8px; flex-wrap: wrap; align-items: center;
+    margin: 0 0 12px;
+  }
+  .pill {
+    display: inline-flex; align-items: center; gap: 6px;
+    font-size: 12px; font-weight: 600; padding: 4px 12px; border-radius: 999px;
+    border: 1px solid;
+  }
+  .pill--ok { color: #166534; background: var(--success-bg); border-color: var(--success-border); }
+  .pill--ko { color: #991b1b; background: var(--error-bg); border-color: var(--error-border); }
+  .pill--info { color: var(--text-2); background: var(--bg); border-color: var(--border); font-weight: 500; font-family: var(--mono); font-size: 11.5px; }
+
+  .token.comment { color: #9ca3af; font-style: italic; }
+  .token.keyword, .token.boolean, .token.important { color: #9333ea; font-weight: 500; }
+  .token.string, .token.attr-value { color: #15803d; }
+  .token.function, .token.class-name { color: #1d4ed8; }
+  .token.number, .token.constant { color: #c2410c; }
+  .token.operator, .token.punctuation { color: #52525b; }
+  .token.title, .token.heading { font-weight: 600; color: var(--text); }
+
+  .footer {
+    margin-top: 40px; padding-top: 20px; border-top: 1px solid var(--border-soft);
+    text-align: center; font-size: 12px; color: var(--text-soft);
+  }
+  .footer code {
+    font-family: var(--mono); font-size: 11px; padding: 1px 6px;
+    background: var(--panel); border: 1px solid var(--border-soft);
+    border-radius: var(--radius-xs); color: var(--text-muted);
+  }
+</style>
+</head>
+<body>
+
+<div class="container">
+
+  <header class="header">
+    <div class="header-left">
+      <div class="header-mark">Py</div>
+      <div class="header-text">
+        <h1>Pythonise Exercice</h1>
+        <p>PyxiScience MyST → version pythonisée · validée au harnais</p>
+      </div>
+    </div>
+    <div class="header-status"><span class="dot"></span> service actif</div>
+  </header>
+
+  <div class="grid">
+
+    <!-- INPUT PANEL -->
+    <section class="panel">
+      <h2 class="panel-title">Source</h2>
+
+      <div class="field">
+        <textarea id="input" placeholder="Collez ici l'énoncé MyST à pythoniser… (ou chargez un/des fichiers .md ci-dessous)"></textarea>
+      </div>
+
+      <ul class="filelist" id="filelist" hidden></ul>
+
+      <div class="meta">
+        <div>
+          <label class="field-label" for="mode-select">Mode</label>
+          <select id="mode-select" onchange="onModeChange()">
+            <option value="pythonise">Pythonisation</option>
+            <option value="declinaisons">Déclinaisons (QCM/QAT)</option>
+          </select>
+        </div>
+        <div id="decl-types" hidden>
+          <label class="field-label">Types de déclinaison</label>
+          <div style="display:flex;gap:14px;padding:9px 2px;font-size:13px;">
+            <label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
+              <input type="checkbox" id="type-qcm" checked onchange="updateRunLabel()"> QCM
+            </label>
+            <label style="display:flex;align-items:center;gap:6px;cursor:pointer;">
+              <input type="checkbox" id="type-qat" onchange="updateRunLabel()"> QAT
+            </label>
+          </div>
+        </div>
+        <div>
+          <label class="field-label" for="policy-select">Politique de modèle</label>
+          <select id="policy-select" onchange="onPolicyChange()">
+            <option value="auto">Auto (l'app décide)</option>
+            <option value="best">Meilleur (qualité max)</option>
+            <option value="cheap">Économique</option>
+            <option value="manual">Manuel</option>
+          </select>
+        </div>
+        <div id="manual-models" class="meta-full" hidden>
+          <label class="field-label">Modèles par rôle (mode Manuel)</label>
+          <div style="display:grid;grid-template-columns:1fr 1fr 1fr;gap:10px;">
+            <div><label class="field-label" for="model-generate">Génération</label>
+              <select id="model-generate"></select></div>
+            <div><label class="field-label" for="model-audit">Audit</label>
+              <select id="model-audit"></select></div>
+            <div><label class="field-label" for="model-mecanique">Mécanique</label>
+              <select id="model-mecanique"></select></div>
+          </div>
+        </div>
+        <div>
+          <label class="field-label" for="lang-select">Langue cible</label>
+          <select id="lang-select">
+            <option value="fr">Français</option>
+            <option value="en">Anglais</option>
+            <option value="both">Les deux (bilingue)</option>
+          </select>
+        </div>
+        <div>
+          <label class="field-label" for="level">Niveau</label>
+          <select id="level">
+            <option value="">—</option>
+            <option value="Elementary">Élémentaire</option>
+            <option value="Intermediate">Intermédiaire</option>
+            <option value="Advanced">Avancé</option>
+          </select>
+        </div>
+        <div class="meta-full">
+          <label class="field-label" for="filename">Nom du fichier <span style="opacity:0.6;font-weight:400">(si saisie manuelle)</span></label>
+          <input type="text" id="filename" value="exercise.md" placeholder="exercise.md">
+        </div>
+      </div>
+
+      <div class="actions">
+        <button class="btn btn--primary" id="run-btn" type="button" onclick="run()">Lancer la pythonisation</button>
+        <button class="btn" id="stop-btn" type="button" onclick="stopJob()" hidden
+                style="border-color:#c0392b;color:#c0392b;">⏹ Arrêter</button>
+        <button class="btn" type="button" onclick="document.getElementById('file-input').click()">Charger des fichiers .md</button>
+        <input type="file" id="file-input" accept=".md,.txt,text/markdown,text/plain" multiple hidden onchange="loadFiles(event)">
+        <button class="btn btn--ghost" type="button" onclick="clearAll()">Effacer</button>
+      </div>
+
+      <div class="progress is-idle" id="progress">
+        <div class="progress-line">
+          <span class="progress-spinner"></span>
+          <span class="progress-label" id="step-label">En attente</span>
+          <span class="progress-step" id="step-counter">—</span>
+        </div>
+        <div class="progress-bar"><span class="progress-bar-fill"></span></div>
+      </div>
+
+      <div id="status" class="status" hidden></div>
+    </section>
+
+    <!-- OUTPUT PANEL -->
+    <section class="panel">
+      <h2 class="panel-title">Résultat</h2>
+
+      <div class="result-files" id="result-files" hidden></div>
+      <div class="meta-result" id="meta-result" hidden></div>
+
+      <nav class="tabs" id="tabs">
+        <button class="tab is-active" type="button" data-tab="exercice">Exercice</button>
+        <button class="tab" type="button" data-tab="audit">Audit<span class="tab-badge" id="audit-badge" hidden>0</span></button>
+        <button class="tab" type="button" data-tab="analysis">Analyse</button>
+        <button class="tab" type="button" data-tab="notions">Notions</button>
+        <span class="tab-spacer"></span>
+        <button class="btn btn--ghost btn--small" id="dl-btn" type="button" onclick="downloadActiveMd()" disabled>Télécharger .md</button>
+        <button class="btn btn--ghost btn--small" id="dlzip-btn" type="button" onclick="downloadZip()" hidden>Tout (.zip)</button>
+        <button class="btn btn--ghost btn--small" id="copy-btn" type="button" onclick="copyActive()" disabled>Copier</button>
+      </nav>
+
+      <div class="tab-panels">
+        <div class="tab-panel is-active" id="panel-exercice">
+          <pre class="output" id="output-exercice"><code class="empty language-markdown">L'exercice pythonisé apparaîtra ici.</code></pre>
+        </div>
+        <div class="tab-panel" id="panel-audit">
+          <div class="output output--audit" id="output-audit"><p class="empty">Aucun audit pour le moment.</p></div>
+        </div>
+        <div class="tab-panel" id="panel-analysis">
+          <pre class="output" id="output-analysis"><code class="empty language-json">{}</code></pre>
+        </div>
+        <div class="tab-panel" id="panel-notions">
+          <pre class="output" id="output-notions"><code class="empty">—</code></pre>
+        </div>
+      </div>
+    </section>
+
+  </div>
+
+  <footer class="footer">
+    <code>v2</code> · Pythonisation PyxiScience · porte harnais déterministe · OpenRouter
+  </footer>
+
+</div>
+
+<script src="https://unpkg.com/prismjs@1.29.0/components/prism-core.min.js"></script>
+<script src="https://unpkg.com/prismjs@1.29.0/components/prism-markup.min.js"></script>
+<script src="https://unpkg.com/prismjs@1.29.0/components/prism-python.min.js"></script>
+<script src="https://unpkg.com/prismjs@1.29.0/components/prism-json.min.js"></script>
+<script src="https://unpkg.com/prismjs@1.29.0/components/prism-markdown.min.js"></script>
+
+<script>
+'use strict';
+
+const POLL_MS = 1000;
+const POLL_SLOW_AFTER = 12;     // au-delà : mode lent (10 s) — on n'abandonne PAS
+const POLL_SLOW_MS = 10000;
+const POLL_GIVEUP_MS = 45 * 60 * 1000;  // plafond absolu de reconnexion (45 min)
+let pollFirstFailureAt = null;
+let currentJobId = null;
+let pollTimer = null;
+let pollFailures = 0;
+let activeTab = "exercice";
+let loadedFiles = [];        // [{filename, content}]
+let jobResults = [];         // résultats par fichier
+let activeResultIdx = 0;
+
+document.addEventListener("DOMContentLoaded", () => {
+  fetchModels(); bindTabs();
+  // Reprise après rechargement : si un job était en cours, on se raccroche
+  // (le serveur le garde JOB_TTL=30 min après sa fin ; 404 → suivi perdu).
+  const saved = localStorage.getItem("pyxi_job_id");
+  if (saved) {
+    currentJobId = saved;
+    document.getElementById("run-btn").disabled = true;
+    const sb = document.getElementById("stop-btn");
+    sb.hidden = false; sb.disabled = false; sb.textContent = "⏹ Arrêter";
+    setProgress("running", "Reprise du suivi du job en cours…", "…");
+    poll();
+  }
+});
+
+async function fetchModels() {
+  try {
+    const res = await fetch("/api/models");
+    if (!res.ok) return;
+    const { default_lang, default_policy, catalog, recommended } = await res.json();
+    // Dropdowns par rôle (mode Manuel), alimentés par le catalogue (sans Fable).
+    const roleDefaults = {
+      generate: recommended?.generate?.cheap,
+      audit: recommended?.audit?.best,
+      mecanique: recommended?.mecanique?.cheap,
+    };
+    for (const role of ["generate", "audit", "mecanique"]) {
+      const sel = document.getElementById(`model-${role}`);
+      if (!sel || !catalog?.[role]) continue;
+      sel.innerHTML = "";
+      for (const key of catalog[role]) {
+        const opt = document.createElement("option");
+        opt.value = key;
+        opt.textContent = prettyModelName(key);
+        if (key === roleDefaults[role]) opt.selected = true;
+        sel.appendChild(opt);
+      }
+    }
+    if (default_policy) document.getElementById("policy-select").value = default_policy;
+    if (default_lang) document.getElementById("lang-select").value = default_lang;
+    onPolicyChange();
+  } catch (e) { console.warn("/api/models:", e); }
+}
+
+function prettyModelName(slug) {
+  const name = slug.includes("/") ? slug.split("/")[1] : slug;
+  return name
+    .replace(/^claude-/, "Claude ").replace(/^gpt-/, "GPT-")
+    .replace(/^gemini-/, "Gemini ").replace(/-/g, " ")
+    .replace(/\b\w/g, c => c.toUpperCase()).replace(/Gpt/g, "GPT");
+}
+
+/* ─── Mode (pythonisation / déclinaisons) + politique de modèle ─── */
+function onModeChange() {
+  const decl = document.getElementById("mode-select").value === "declinaisons";
+  document.getElementById("decl-types").hidden = !decl;
+  updateRunLabel();
+}
+
+function onPolicyChange() {
+  const manual = document.getElementById("policy-select").value === "manual";
+  document.getElementById("manual-models").hidden = !manual;
+}
+
+function updateRunLabel() {
+  const btn = document.getElementById("run-btn");
+  if (document.getElementById("mode-select").value !== "declinaisons") {
+    btn.textContent = "Lancer la pythonisation";
+    return;
+  }
+  const qcm = document.getElementById("type-qcm").checked;
+  const qat = document.getElementById("type-qat").checked;
+  const what = (qcm && qat) ? "QCM + QAT" : qat ? "QAT" : qcm ? "QCM" : "…";
+  btn.textContent = `Générer les déclinaisons ${what}`;
+}
+
+/* ─── Tabs ─── */
+function bindTabs() {
+  document.querySelectorAll("#tabs .tab").forEach(btn => {
+    btn.addEventListener("click", () => switchTab(btn.dataset.tab));
+  });
+}
+function switchTab(name) {
+  activeTab = name;
+  document.querySelectorAll("#tabs .tab").forEach(btn =>
+    btn.classList.toggle("is-active", btn.dataset.tab === name));
+  document.querySelectorAll(".tab-panel").forEach(panel =>
+    panel.classList.toggle("is-active", panel.id === `panel-${name}`));
+  updateCopyState();
+}
+function activeDoneResult() {
+  const e = jobResults[activeResultIdx];
+  return (e && e.status === "done" && e.result) ? e : null;
+}
+
+function updateCopyState() {
+  // Copier (panneau actif)
+  const text = currentPanelText();
+  document.getElementById("copy-btn").disabled =
+    !text || !text.trim() || text.trim() === "—" || text.trim() === "{}";
+  // Télécharger .md (résultat affiché)
+  const r = activeDoneResult();
+  const dl = document.getElementById("dl-btn");
+  if (dl) dl.disabled = !(r && r.result.exercise);
+  // Tout (.zip) — seulement en batch (≥ 2 fichiers prêts)
+  const doneCount = jobResults.filter(x => x.status === "done").length;
+  const zip = document.getElementById("dlzip-btn");
+  if (zip) zip.hidden = !(doneCount >= 2 && currentJobId);
+}
+
+function triggerDownload(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url; a.download = filename;
+  document.body.appendChild(a); a.click(); a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+
+function downloadActiveMd() {
+  const r = activeDoneResult();
+  if (!r || !r.result.exercise) return;
+  const base = (r.filename || "exercice").replace(/\.(md|txt)$/i, "");
+  triggerDownload(
+    new Blob([r.result.exercise], { type: "text/markdown;charset=utf-8" }),
+    base + "_pythonise.md"
+  );
+}
+
+function downloadZip() {
+  if (!currentJobId) return;
+  const a = document.createElement("a");
+  a.href = `/api/jobs/${currentJobId}/download`;
+  a.download = "";   // nom fixé par le serveur (Content-Disposition)
+  document.body.appendChild(a); a.click(); a.remove();
+}
+function currentPanelText() {
+  const map = { exercice: "output-exercice", audit: "output-audit",
+                analysis: "output-analysis", notions: "output-notions" };
+  const el = document.getElementById(map[activeTab]);
+  if (!el) return "";
+  if (activeTab === "audit") return el.innerText || "";
+  const code = el.querySelector("code");
+  return code ? code.textContent : (el.textContent || "");
+}
+
+/* ─── Progress + status ─── */
+function setProgress(state, label, step) {
+  const prog = document.getElementById("progress");
+  prog.classList.remove("is-idle", "is-running", "is-done", "is-error");
+  prog.classList.add(`is-${state}`);
+  if (label !== undefined) document.getElementById("step-label").textContent = label;
+  if (step !== undefined) document.getElementById("step-counter").textContent = step;
+}
+function setStatus(state, text) {
+  const el = document.getElementById("status");
+  el.className = "status" + (state ? ` is-${state}` : "");
+  el.textContent = text;
+  el.hidden = false;
+}
+function hideStatus() { document.getElementById("status").hidden = true; }
+
+/* ─── Fichiers (batch) ─── */
+function loadFiles(event) {
+  const files = Array.from(event.target.files || []);
+  if (!files.length) return;
+  let pending = files.length;
+  files.forEach(file => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      loadedFiles.push({ filename: file.name, content: String(e.target.result || "") });
+      if (--pending === 0) renderFileList();
+    };
+    reader.onerror = () => { if (--pending === 0) renderFileList(); };
+    reader.readAsText(file, "UTF-8");
+  });
+  event.target.value = "";
+}
+function renderFileList() {
+  const ul = document.getElementById("filelist");
+  ul.innerHTML = "";
+  ul.hidden = loadedFiles.length === 0;
+  loadedFiles.forEach((f, i) => {
+    const li = document.createElement("li");
+    li.innerHTML = `📄 ${escapeHtml(f.filename)} <span style="color:var(--text-soft)">(${(f.content.length / 1024).toFixed(1)} ko)</span>
+      <button class="rm" title="Retirer" onclick="removeFile(${i})">✕</button>`;
+    ul.appendChild(li);
+  });
+}
+function removeFile(i) { loadedFiles.splice(i, 1); renderFileList(); }
+
+/* ─── Rendu des sorties ─── */
+function setExerciseOutput(text) {
+  const pre = document.getElementById("output-exercice");
+  pre.innerHTML = "";
+  const code = document.createElement("code");
+  code.className = "language-markdown";
+  if (!text) { code.classList.add("empty"); code.textContent = "L'exercice pythonisé apparaîtra ici."; }
+  else { code.textContent = text; if (window.Prism) Prism.highlightElement(code); }
+  pre.appendChild(code);
+  updateCopyState();
+}
+function setAnalysisOutput(obj) {
+  const pre = document.getElementById("output-analysis");
+  pre.innerHTML = "";
+  const code = document.createElement("code");
+  code.className = "language-json";
+  if (!obj) { code.classList.add("empty"); code.textContent = "{}"; }
+  else { code.textContent = JSON.stringify(obj, null, 2); if (window.Prism) Prism.highlightElement(code); }
+  pre.appendChild(code);
+}
+function setNotionsOutput(text) {
+  const pre = document.getElementById("output-notions");
+  pre.innerHTML = "";
+  const code = document.createElement("code");
+  if (!text || text === "—") { code.classList.add("empty"); code.textContent = "—"; }
+  else { code.textContent = text; }
+  pre.appendChild(code);
+}
+function setAuditOutput(result) {
+  const container = document.getElementById("output-audit");
+  const patches = result.audit_patches || [];
+  const warnings = result.warnings || [];
+  const badge = document.getElementById("audit-badge");
+  if (!patches.length && !warnings.length) {
+    container.innerHTML = `<p class="empty">Aucun patch ni warning — l'audit a validé l'exercice.</p>`;
+    badge.hidden = true;
+    return;
+  }
+  badge.hidden = false;
+  badge.textContent = String(patches.length + warnings.length);
+  let html = "";
+  if (patches.length) {
+    html += `<section class="audit-section"><h3 class="audit-heading">Patches appliqués <span class="count">${patches.length}</span></h3><ul class="audit-list">`;
+    for (const p of patches) {
+      html += `<li class="audit-patch">
+        <span class="audit-rule">règle ${escapeHtml(p.rule || "?")}</span>
+        <div class="audit-diff">
+          <pre class="audit-before"><code>${escapeHtml(p.location || "")}</code></pre>
+          <pre class="audit-after"><code>${escapeHtml(p.fix || "")}</code></pre>
+        </div></li>`;
+    }
+    html += `</ul></section>`;
+  }
+  if (warnings.length) {
+    html += `<section class="audit-section"><h3 class="audit-heading">Warnings <span class="count">${warnings.length}</span></h3><ul class="audit-warnings">`;
+    for (const w of warnings) {
+      let ruleRef = "", txt = w;
+      if (typeof w === "object" && w !== null) {
+        if (w.rule) ruleRef = `<span class="rule-ref">règle ${escapeHtml(w.rule)}</span>`;
+        txt = w.message || JSON.stringify(w);
+      }
+      html += `<li>${ruleRef}${escapeHtml(String(txt))}</li>`;
+    }
+    html += `</ul></section>`;
+  }
+  container.innerHTML = html;
+}
+
+/* Bandeau verdict + coût + langue pour le fichier affiché */
+function setMetaResult(entry) {
+  const el = document.getElementById("meta-result");
+  if (!entry) { el.hidden = true; return; }
+  el.hidden = false;
+  if (entry.status === "error") {
+    el.innerHTML = `<span class="pill pill--ko">✗ Erreur pipeline</span>
+                    <span class="pill pill--info">${escapeHtml(entry.error || "")}</span>`;
+    return;
+  }
+  const r = entry.result;
+  const h = r.harness || {};
+  const verdict = h.ok
+    ? `<span class="pill pill--ok">✓ Harnais VERT (${h.seeds} graines)</span>`
+    : `<span class="pill pill--ko">✗ Harnais ROUGE (${h.seeds} graines)</span>`;
+  // Audit pédagogique (déclinaisons) : qualité au-delà du harnais mécanique.
+  let ped = "";
+  const p = r.pedagogical;
+  if (p && p.verdict) {
+    if (p.verdict === "OK") {
+      const sc = (p.score != null) ? ` (${p.score}/100)` : "";
+      ped = `<span class="pill pill--ok">✓ Qualité pédagogique${sc}</span>`;
+    } else if (p.verdict === "A_REVOIR") {
+      const n = (p.issues || []).length;
+      ped = `<span class="pill pill--ko">⚠ Qualité pédagogique à revoir (${n})</span>`;
+    } else {
+      ped = `<span class="pill pill--info">audit pédagogique indisponible</span>`;
+    }
+  }
+  const cost = r.cost ? `<span class="pill pill--info">${r.cost.usd.toFixed(4)} $ · ${r.cost.requests} appels</span>` : "";
+  const lang = r.lang ? `<span class="pill pill--info">langue : ${escapeHtml(r.lang.source)} → ${escapeHtml(r.lang.target)} (${escapeHtml(r.lang.action)})</span>` : "";
+  const dur = r.duration_s ? `<span class="pill pill--info">${r.duration_s}s</span>` : "";
+  let decl = "";
+  if (r.decl_type) {
+    const label = r.decl_type === "qcm" ? "QCM" : "QAT";
+    decl = `<span class="pill pill--info">déclinaison : ${label}</span>`;
+    if (r.decl_type === "qat" && (r.exercise || "").includes(":questionType: MCQ")) {
+      decl += `<span class="pill pill--info">repli MCQ partiel</span>`;
+    }
+  }
+  let pol = "";
+  const t = r.policy_telemetry;
+  if (t) {
+    const esc = (t.tried || []).length > 1 ? ` (${t.tried.length} échelons)` : "";
+    pol = `<span class="pill pill--info">modèle : ${escapeHtml(prettyModelName(t.winning_model || r.model_used || "?"))}${esc} · ${escapeHtml(t.mode)}/${escapeHtml(t.difficulty)}</span>`;
+    if (t.needs_review) pol += `<span class="pill pill--ko">revue humaine requise</span>`;
+  } else if (r.model_used) {
+    pol = `<span class="pill pill--info">modèle : ${escapeHtml(prettyModelName(r.model_used))}</span>`;
+  }
+  el.innerHTML = verdict + ped + decl + pol + cost + lang + dur;
+}
+
+/* Sélecteur de fichier (batch) */
+function renderResultFiles() {
+  const el = document.getElementById("result-files");
+  if (jobResults.length <= 1) { el.hidden = true; return; }
+  el.hidden = false;
+  el.innerHTML = "";
+  jobResults.forEach((r, i) => {
+    const cls = r.status === "error" ? "err" : (r.result?.harness?.ok ? "ok" : "ko");
+    const span = document.createElement("span");
+    span.className = "result-file" + (i === activeResultIdx ? " is-active" : "");
+    span.innerHTML = `<span class="verdict-dot ${cls}"></span>${escapeHtml(r.filename)}`;
+    span.onclick = () => { activeResultIdx = i; showResult(i); renderResultFiles(); };
+    el.appendChild(span);
+  });
+}
+function showResult(i) {
+  const entry = jobResults[i];
+  if (!entry) return;
+  setMetaResult(entry);
+  if (entry.status === "error") {
+    setExerciseOutput(""); setAnalysisOutput(null); setNotionsOutput(""); setAuditOutput({});
+    return;
+  }
+  const r = entry.result;
+  setExerciseOutput(r.exercise || "");
+  setAnalysisOutput(r.analysis || null);
+  setNotionsOutput(r.notions || "—");
+  setAuditOutput(r);
+}
+
+/* ─── Run + poll ─── */
+async function run() {
+  let files = loadedFiles.slice();
+  const manual = document.getElementById("input").value.trim();
+  if (!files.length && manual) {
+    files = [{ filename: document.getElementById("filename").value.trim() || "exercise.md",
+               content: manual }];
+  }
+  if (!files.length) { setStatus("error", "Saisissez un énoncé ou chargez des fichiers .md."); return; }
+
+  const mode = document.getElementById("mode-select").value;
+  const policyMode = document.getElementById("policy-select").value;
+  const payload = {
+    files,
+    level: document.getElementById("level").value,
+    lang: document.getElementById("lang-select").value,
+    mode,
+    policy: policyMode,
+  };
+  if (policyMode === "manual") {
+    payload.models = {
+      generate: document.getElementById("model-generate").value,
+      audit: document.getElementById("model-audit").value,
+      mecanique: document.getElementById("model-mecanique").value,
+    };
+  }
+  if (mode === "declinaisons") {
+    payload.types = {
+      qcm: document.getElementById("type-qcm").checked,
+      qat: document.getElementById("type-qat").checked,
+    };
+    if (!payload.types.qcm && !payload.types.qat) {
+      setStatus("error", "Mode Déclinaisons : coche au moins un type (QCM ou QAT).");
+      return;
+    }
+  }
+
+  if (pollTimer) { clearTimeout(pollTimer); pollTimer = null; }
+  currentJobId = null;
+  pollFailures = 0;
+  jobResults = []; activeResultIdx = 0;
+  document.getElementById("run-btn").disabled = true;
+  const stopBtn = document.getElementById("stop-btn");
+  stopBtn.hidden = false; stopBtn.disabled = false;
+  stopBtn.textContent = "⏹ Arrêter";
+  hideStatus();
+  setExerciseOutput(""); setAnalysisOutput(null); setNotionsOutput(""); setAuditOutput({});
+  setMetaResult(null);
+  document.getElementById("result-files").hidden = true;
+  document.getElementById("audit-badge").hidden = true;
+  switchTab("exercice");
+  setProgress("running", "Soumission du job…", "0/" + files.length);
+
+  try {
+    const res = await fetch("/api/jobs", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    currentJobId = (await res.json()).job_id;
+    localStorage.setItem("pyxi_job_id", currentJobId);
+    poll();
+  } catch (e) {
+    setProgress("error", "Échec", "—");
+    setStatus("error", "Erreur : " + e.message);
+    jobFinished();
+  }
+}
+
+/* Fin de job (quel que soit l'état terminal) : run réactivé, stop masqué. */
+function jobFinished() {
+  document.getElementById("run-btn").disabled = false;
+  document.getElementById("stop-btn").hidden = true;
+  localStorage.removeItem("pyxi_job_id");
+}
+
+/* Arrêt coopératif : le serveur stoppe au prochain point d'étape (l'appel
+   LLM en cours se termine, rien ne s'enchaîne) ; résultats partiels gardés. */
+async function stopJob() {
+  if (!currentJobId) return;
+  const stopBtn = document.getElementById("stop-btn");
+  stopBtn.disabled = true;
+  stopBtn.textContent = "Arrêt en cours…";
+  try {
+    const res = await fetch(`/api/jobs/${currentJobId}/cancel`, { method: "POST" });
+    if (res.status === 404 || res.status === 409) {
+      // Job déjà terminé/perdu : le prochain poll affichera l'état final.
+      stopBtn.hidden = true;
+      return;
+    }
+    setStatus("warn", "Arrêt demandé — fin de l'étape en cours…");
+  } catch (e) {
+    stopBtn.disabled = false;
+    stopBtn.textContent = "⏹ Arrêter";
+    setStatus("error", "Impossible de demander l'arrêt : " + e.message);
+  }
+}
+
+async function poll() {
+  if (!currentJobId) return;
+  try {
+    const res = await fetch(`/api/jobs/${currentJobId}`, { headers: { "Accept": "application/json" } });
+    // Lire en texte d'abord : sous forte charge, le proxy HF peut renvoyer une
+    // page HTML (502/504) au lieu du JSON → on traite ça comme un hoquet
+    // transitoire et on RÉESSAIE, au lieu de tuer tout le suivi.
+    const raw = await res.text();
+    let data;
+    try { data = JSON.parse(raw); }
+    catch (_) { throw new Error(`réponse non-JSON (HTTP ${res.status})`); }
+
+    if (res.status === 404) {
+      // Job inconnu : le serveur a probablement redémarré (perte du suivi en mémoire).
+      setProgress("error", "Suivi perdu", "—");
+      setStatus("error", "Le serveur a perdu ce job (redémarrage). Le traitement est interrompu — relance.");
+      jobFinished();
+      return;
+    }
+
+    pollFailures = 0;                 // réponse valide → on repart à zéro
+    pollFirstFailureAt = null;
+    jobResults = data.results || [];
+    if (data.status === "running") {
+      setProgress("running", data.step_label || "…", `${data.files_done}/${data.files_total}`);
+      if (jobResults.length && activeResultIdx < jobResults.length) {
+        renderResultFiles(); showResult(Math.min(activeResultIdx, jobResults.length - 1));
+      }
+      pollTimer = setTimeout(poll, POLL_MS);
+    } else if (data.status === "done") {
+      const s = data.summary || {};
+      setProgress(s.rouges || s.erreurs ? "error" : "done", "Terminé", `${data.files_done}/${data.files_total}`);
+      const msg = `Terminé : ${s.verts ?? 0} VERT(S), ${s.rouges ?? 0} ROUGE(S), ${s.erreurs ?? 0} erreur(s) · ${s.cost_usd ?? 0} $`;
+      setStatus(s.rouges || s.erreurs ? "warn" : "done", msg);
+      activeResultIdx = 0;
+      renderResultFiles();
+      showResult(0);
+      jobFinished();
+    } else if (data.status === "cancelled") {
+      const s = data.summary || {};
+      setProgress("error", "Arrêté", `${data.files_done}/${data.files_total}`);
+      setStatus("warn",
+        `Génération arrêtée. Résultats partiels conservés : ${s.verts ?? 0} VERT(S), `
+        + `${s.rouges ?? 0} ROUGE(S), ${s.erreurs ?? 0} erreur(s) · ${s.cost_usd ?? 0} $`);
+      if (jobResults.length) { activeResultIdx = 0; renderResultFiles(); showResult(0); }
+      jobFinished();
+    } else if (data.status === "error") {
+      setProgress("error", "Erreur", "—");
+      setStatus("error", "Erreur : " + (data.error || "inconnue"));
+      jobFinished();
+    }
+  } catch (e) {
+    // Erreur TRANSITOIRE : pendant les phases de calcul (harnais 100 graines),
+    // le serveur mono-process peut être injoignable PLUSIEURS MINUTES — le job
+    // continue. On ne renonce donc JAMAIS avant le plafond absolu : backoff
+    // léger, puis mode lent (10 s) ; le suivi se recale à la 1re réponse.
+    pollFailures++;
+    if (!pollFirstFailureAt) pollFirstFailureAt = Date.now();
+    if (Date.now() - pollFirstFailureAt > POLL_GIVEUP_MS) {
+      setProgress("error", "Connexion interrompue", "—");
+      setStatus("error",
+        "Suivi injoignable depuis 45 min (" + e.message + "). "
+        + "Recharge la page ; si le serveur a redémarré, relance le job.");
+      jobFinished();
+      return;
+    }
+    const slow = pollFailures >= POLL_SLOW_AFTER;
+    setStatus("warn",
+      slow
+        ? "Serveur occupé (phase de calcul) — le traitement CONTINUE côté serveur, "
+          + `reconnexion toutes les 10 s… (${Math.round((Date.now() - pollFirstFailureAt) / 1000)} s)`
+        : `Reconnexion au suivi… (${pollFailures})`);
+    pollTimer = setTimeout(
+      poll, slow ? POLL_SLOW_MS : Math.min(6000, POLL_MS * (1 + pollFailures)));
+  }
+}
+
+function clearAll() {
+  if (pollTimer) clearTimeout(pollTimer);
+  currentJobId = null;
+  localStorage.removeItem("pyxi_job_id");
+  document.getElementById("stop-btn").hidden = true;
+  document.getElementById("run-btn").disabled = false;
+  loadedFiles = []; jobResults = []; activeResultIdx = 0;
+  renderFileList();
+  document.getElementById("input").value = "";
+  setExerciseOutput(""); setAnalysisOutput(null); setNotionsOutput(""); setAuditOutput({});
+  setMetaResult(null);
+  document.getElementById("result-files").hidden = true;
+  document.getElementById("audit-badge").hidden = true;
+  setProgress("idle", "En attente", "—");
+  hideStatus();
+  document.getElementById("run-btn").disabled = false;
+}
+
+function copyActive() {
+  const text = currentPanelText();
+  if (!text) return;
+  navigator.clipboard.writeText(text).then(() => {
+    const btn = document.getElementById("copy-btn");
+    const old = btn.textContent;
+    btn.textContent = "Copié";
+    setTimeout(() => { btn.textContent = old; }, 1400);
+  });
+}
+
+function escapeHtml(s) {
+  return String(s)
+    .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+</script>
+
+</body>
+</html>

orchestrator.py

@@ -0,0 +1,695 @@
+"""
+orchestrator.py
+───────────────
+Chef d'orchestre du pipeline pour UN exercice. (Le job/threading vit dans
+server.py ; le mode batch boucle simplement sur run_exercise.)
+
+Ordre des étapes :
+  1. Analyse + notions + RAG fonctions (PARALLÈLE — indépendants)
+  2. Génération par paires (séquentielle, contexte partagé)
+  3. Post-traitements déterministes (config_standard, assemblage 4-backticks,
+     dédoublonnage)
+  4. Substitution des solutions validées (si présentes dans la source)
+  5. Audit LLM (≤ 2 itérations, patches toutes-occurrences sécurisés)
+  6. Post-traitements déterministes finaux : auto-lift GÉNÉRALISÉ des
+     injections non nues, renommage underscores, auto-correctif $+chiffre,
+     :id: vide, diff solutions, décimales (langue), invariants multi-seed,
+     contrôles matplotlib
+  7. Langue cible (déterministe ou LLM masqué)
+  8. PORTE HARNAIS (HARNESS_GATE_SEEDS graines) + 1 boucle de réparation LLM
+     max ; verdict exposé dans le résultat.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Callable, Optional
+
+from app.config import (
+    HARNESS_GATE_SEEDS,
+    HARNESS_REPAIR_MAX,
+    MAX_ESCALADES,
+    MULTI_SEED_NUM,
+    PEDAGO_AUDIT_ENABLED,
+    PEDAGO_ESCALATE_IN_AUTO,
+    PEDAGO_REPAIR_MAX,
+)
+from app.knowledge.rules_digest import build_rules_digest
+from app.llm.client import process_with_openrouter
+from app.llm.cost import cost_delta, cost_snapshot
+from app.rag.catalogue import catalogue_for
+from app.pipeline import postprocess as pp
+from app.pipeline.analyze import run_analysis_phase
+from app.pipeline.audit import (
+    format_pedagogical_issues,
+    pedagogical_badness,
+    run_audit,
+    run_pedagogical_audit,
+)
+from app.pipeline.fewshots import fewshot_for, fewshot_for_declinaison
+from app.pipeline.generate import (
+    assemble_exercise,
+    build_exercise_metadata,
+    generate_pair_blocks,
+    split_original_questions,
+)
+from app.pipeline.prompts import (
+    PEDAGOGICAL_REPAIR_PROMPT,
+    REPAIR_PROMPT,
+    SYSTEM_PROMPT,
+    TRANSLATE_CONSTRAINTS_PROMPT,
+)
+from app.pipeline.solutions import replace_gen_solutions_with_source
+from app.pipeline.translate import ensure_language
+from app.validation import harness
+from app.validation.sandbox import (
+    dynamic_check_matplotlib,
+    extract_all_python_blocks,
+    extract_main_python_block,
+    multi_seed_validate,
+    static_check_rational_numpy_mix,
+    static_check_unused_random_vars,
+)
+
+logger = logging.getLogger(__name__)
+
+TRUNK_RULES = ["2.1", "3.1", "3.2", "6.1", "6.3", "8.1"]
+
+
+def _translate_constraints_to_assertions(code: str, constraints: list[str],
+                                         model_idx: int,
+                                         model: str | None = None) -> list[dict]:
+    """Mini appel LLM : contrainte FR → expression booléenne Python."""
+    if not constraints or not code.strip():
+        return []
+    try:
+        raw = process_with_openrouter(
+            prompt=TRANSLATE_CONSTRAINTS_PROMPT.format(
+                code=code,
+                constraints="\n".join(f"  • {c}" for c in constraints
+                                      if isinstance(c, str) and c.strip()),
+            ),
+            model_idx=model_idx,
+            model=model,
+            temperature=0.0,
+            max_tokens=2048,
+            system_prompt=SYSTEM_PROMPT,
+        )
+    except (RuntimeError, ValueError, OSError) as e:
+        logger.warning("Traduction des contraintes en échec : %s", e)
+        return []
+    try:
+        data = json.loads(pp.strip_fences(raw))
+    except json.JSONDecodeError:
+        logger.warning("Traduction des contraintes : JSON invalide.")
+        return []
+    if not isinstance(data, list):
+        return []
+    return [
+        {"description": str(d.get("description", "")), "assertion": d.get("assertion")}
+        for d in data
+        if isinstance(d, dict) and d.get("assertion")
+    ]
+
+
+def _apply_deterministic_nets(candidate: str, decl_type: Optional[str]) -> str:
+    """Séquence des filets déterministes appliquée à toute sortie LLM (candidat
+    de génération OU de réparation harnais/pédagogique). Idempotente."""
+    candidate, _ = pp.fix_orphan_python_openers(candidate)
+    candidate = pp.normalize_python_fences(candidate)
+    candidate, _ = pp.drop_empty_python_blocks(candidate)
+    candidate, _ = pp.fix_triple_braces(candidate)
+    candidate, _ = pp.fix_superscript_double_brace(candidate)
+    candidate, _ = pp.unwrap_latex_injections(candidate)
+    candidate, _ = pp.auto_lift_injections(candidate)
+    candidate, _ = pp.rename_underscore_injections(candidate)
+    candidate, _ = pp.fix_dollar_digit(candidate)
+    if decl_type:
+        candidate, _ = pp.fix_mcq_answer_aliases(candidate)
+        candidate, _ = pp.merge_decl_python_blocks(candidate)
+    if decl_type == "qcm":
+        candidate, _ = pp.fix_none_option_last(candidate)
+    candidate, _ = pp.aerate_blocks(candidate)
+    candidate, _ = pp.renumber_question_ids(candidate)
+    return candidate
+
+
+def run_exercise(
+    content: str,
+    filename: str = "exercise.md",
+    level: str = "",
+    model_idx: int = 1,
+    lang: str = "fr",
+    set_step: Optional[Callable[[str], None]] = None,
+    decl_type: Optional[str] = None,
+    shared_phase: Optional[tuple] = None,
+    forced_models: Optional[dict] = None,
+) -> dict:
+    """
+    Traite UN exercice. `decl_type=None` = pythonisation (flux historique) ;
+    `decl_type ∈ {"qcm","qat"}` = mode déclinaisons (même pipeline, prompt et
+    harnais étendus). `shared_phase` = résultat de run_analysis_phase à
+    RÉUTILISER (déclinaisons QCM+QAT d'une même source : une seule analyse).
+
+    Retourne le dict résultat (contrat UI) :
+      exercise, pair_blocks, analysis, functions, notions, audit_patches,
+      warnings, harness {ok, summary, seeds}, lang {source, target, action},
+      cost {usd, eur, requests}, duration_s [, decl_type]
+    """
+    t0 = time.time()
+    cost_before = cost_snapshot()
+    _step = set_step or (lambda label: None)
+    # Modèles par rôle (IDs OpenRouter en chaîne), résolus par la policy ;
+    # None → comportement legacy (model_idx partout).
+    fm = forced_models or {}
+    m_gen = fm.get("generate")
+    m_audit = fm.get("audit")
+    m_meca = fm.get("mecanique")
+
+    # ── 1. Analyse + notions + RAG (parallèle ; partagée en mode QCM+QAT) ────
+    if shared_phase is not None:
+        analysis, notions_ctx, lists_of_notions, functions_ctx = shared_phase
+    else:
+        _step("Analyse + notions + catalogue RAG (en parallèle)…")
+        analysis, notions_ctx, lists_of_notions, functions_ctx = run_analysis_phase(
+            content, model_idx)
+
+    step1_targets = [r for r in (analysis.get("target_rules") or []) if isinstance(r, str)]
+    target_rules = list(dict.fromkeys(TRUNK_RULES + step1_targets))
+    targeted_rules_digest = build_rules_digest(target_rules) or "(aucune règle spécifique ciblée)"
+
+    constraints = [c for c in (analysis.get("property_constraints") or [])
+                   if isinstance(c, str) and c.strip()]
+    property_constraints_text = ("\n".join(f"  • {c}" for c in constraints)
+                                 if constraints
+                                 else "  (aucun invariant explicite — tirages libres)")
+
+    # ── 2. Génération par paires ─────────────────────────────────────────────
+    metadata, enonce, question_segments = split_original_questions(content)
+    exercise_header = build_exercise_metadata(metadata, lists_of_notions, analysis,
+                                              level, decl_type=decl_type)
+
+    # Contexte fonctions = catalogue CURÉ (domaine détecté) + hits RAG FAISS.
+    # Le catalogue curé donne « quel helper pour quel besoin » + couvre les
+    # domaines absents du corpus livré (matrices, proba, IBP).
+    catalogue_ctx = catalogue_for(analysis)
+    functions_combined = "\n\n".join(filter(None, [
+        catalogue_ctx,
+        ("CATALOGUE RAG (hits spécifiques sur le code réel) :\n" + functions_ctx)
+        if functions_ctx else "",
+    ])) or "Aucune fonction spécifique détectée."
+
+    fewshot = (fewshot_for_declinaison(decl_type) if decl_type
+               else fewshot_for(analysis))
+    pair_blocks = generate_pair_blocks(
+        content=content,
+        exercise_header=exercise_header,
+        enonce=enonce,
+        question_segments=question_segments,
+        analysis=analysis,
+        functions_ctx=functions_combined,
+        fewshot=fewshot,
+        targeted_rules_digest=targeted_rules_digest,
+        property_constraints_text=property_constraints_text,
+        level=level,
+        model_idx=model_idx,
+        lang=lang,
+        set_step=_step,
+        decl_type=decl_type,
+        model=m_gen,
+    )
+
+    # ── 3. Post-traitements déterministes ────────────────────────────────────
+    _step("Post-traitements déterministes…")
+    pair_blocks = [pp.inject_config_standard_in_pair_block(b) for b in pair_blocks]
+    myst_exercise = assemble_exercise(exercise_header, pair_blocks)
+
+    audit_patches: list[dict] = []
+    audit_warnings: list[dict] = []
+
+    myst_exercise, orphan_py = pp.fix_orphan_python_openers(myst_exercise)
+    if orphan_py:
+        audit_patches.append({
+            "rule": "3.1", "location": "(orphan python opener)",
+            "fix": f"{orphan_py} opener(s) orphelin(s) supprimé(s)",
+            "message": f"{orphan_py} fence(s) {{python}} orpheline(s) supprimée(s) (opener doublé).",
+            "iteration": 0,
+        })
+    myst_exercise, dup_q = pp.dedupe_question_blocks(myst_exercise)
+    myst_exercise, dup_py = pp.dedupe_python_blocks(myst_exercise)
+    myst_exercise, empty_py = pp.drop_empty_python_blocks(myst_exercise)
+    if empty_py:
+        audit_patches.append({
+            "rule": "3.1", "location": "(empty python blocks)",
+            "fix": f"{empty_py} bloc(s) vide(s) supprimé(s)",
+            "message": f"{empty_py} bloc(s) {{python}} vide(s) (globals() seul) supprimé(s).",
+            "iteration": 0,
+        })
+    if dup_q:
+        audit_patches.append({
+            "rule": "9.4", "location": "(duplicate question blocks)",
+            "fix": f"{dup_q} bloc(s) dédupliqué(s)",
+            "message": f"{dup_q} `:::::{{question}}` redondant(s) supprimé(s).",
+            "iteration": 0,
+        })
+    if dup_py:
+        audit_patches.append({
+            "rule": "3.1", "location": "(duplicate python blocks)",
+            "fix": f"{dup_py} bloc(s) dédupliqué(s)",
+            "message": f"{dup_py} bloc(s) {{python}} redondant(s) supprimé(s).",
+            "iteration": 0,
+        })
+
+    # ── 4. Solutions validées (règle 8.1) ────────────────────────────────────
+    if analysis.get("has_validated_solution_in_input"):
+        _step("Substitution déterministe des solutions validées…")
+        myst_exercise, sol_patches = replace_gen_solutions_with_source(
+            myst_exercise, content, analysis, model_idx, model=m_meca)
+        audit_patches.extend(sol_patches)
+
+    # ── 5. Audit LLM ─────────────────────────────────────────────────────────
+    myst_exercise, llm_patches, llm_warnings = run_audit(
+        myst_exercise, step1_targets, model_idx, set_step=_step, model=m_audit)
+    audit_patches.extend(llm_patches)
+    audit_warnings.extend(llm_warnings)
+
+    # ── 6. Filets déterministes finaux ───────────────────────────────────────
+    _step("Filets déterministes (injections, $, id, décimales)…")
+    myst_exercise, brace_patches = pp.fix_triple_braces(myst_exercise)
+    audit_patches.extend(brace_patches)
+
+    myst_exercise, sup_fixed = pp.fix_superscript_double_brace(myst_exercise)
+    if sup_fixed:
+        audit_patches.append({
+            "rule": "6.1", "location": "^{{\\latex / _{{\\latex",
+            "fix": "^{ {\\latex / _{ {\\latex",
+            "message": f"{sup_fixed} double-accolade de superscript/indice désambiguïsée(s) (espace inséré).",
+            "iteration": 0,
+        })
+
+    myst_exercise, unwrapped = pp.unwrap_latex_injections(myst_exercise)
+    if unwrapped:
+        audit_patches.append({
+            "rule": "6.1", "location": "{{ \\latex … }}",
+            "fix": f"{unwrapped} enveloppe(s) {{{{ }}}} externe(s) retirée(s)",
+            "message": f"{unwrapped} injection(s) enveloppant du LaTeX déballée(s) (l'injection interne est la vraie).",
+            "iteration": 0,
+        })
+
+    myst_exercise, lift_patches = pp.auto_lift_injections(myst_exercise)
+    audit_patches.extend(lift_patches)
+
+    myst_exercise, rename_patches = pp.rename_underscore_injections(myst_exercise)
+    audit_patches.extend(rename_patches)
+
+    myst_exercise, dollar_patches = pp.fix_dollar_digit(myst_exercise)
+    audit_patches.extend(dollar_patches)
+
+    if decl_type:
+        # Filet : alias d'option MCQ mal nommés / :isRightAnswer: manquant
+        # (le repli MCQ en QAT est concerné aussi).
+        myst_exercise, alias_fixed = pp.fix_mcq_answer_aliases(myst_exercise)
+        if alias_fixed:
+            audit_patches.append({
+                "rule": "MCQ", "location": "(mcqOption / :isRightAnswer:)",
+                "fix": f"{alias_fixed} bloc(s) d'option normalisé(s)",
+                "message": "Blocs d'options MCQ normalisés (mcqOption→mcqAnswer, :isRightAnswer: false par défaut).",
+                "iteration": 0,
+            })
+        # Déclinaisons : UN SEUL bloc {python} — fusion des blocs additionnels
+        # sans re-tirage (re-tirage → laissé au harnais + réparation LLM).
+        myst_exercise, merged = pp.merge_decl_python_blocks(myst_exercise)
+        if merged:
+            audit_patches.append({
+                "rule": "3.1", "location": "(blocs python additionnels)",
+                "fix": f"{merged} bloc(s) fusionné(s) dans le bloc principal",
+                "message": "Déclinaison : blocs {python} additionnels fusionnés (un seul bloc, spec).",
+                "iteration": 0,
+            })
+
+    if decl_type == "qcm":
+        # Filet MCQ : l'option « None/Aucune » doit être le dernier mcqAnswer.
+        myst_exercise, none_moved = pp.fix_none_option_last(myst_exercise)
+        if none_moved:
+            audit_patches.append({
+                "rule": "MCQ", "location": "(option None)",
+                "fix": f"{none_moved} option(s) « None » déplacée(s) en dernier",
+                "message": "Option « Aucune de ces réponses / None » repositionnée en dernière position.",
+                "iteration": 0,
+            })
+
+    # Les warnings 6.1 du LLM deviennent du bruit une fois l'auto-lift passé.
+    if not pp.INJECTION_RE.search(myst_exercise) or not any(
+        "(" in tok or "**" in tok for tok in pp.INJECTION_RE.findall(myst_exercise)
+    ):
+        audit_warnings = [w for w in audit_warnings
+                          if not (isinstance(w, dict) and w.get("rule") == "6.1")]
+
+    myst_exercise, id_patched = pp.force_empty_id(myst_exercise)
+    if id_patched and not any(p.get("rule") == "2.1" for p in audit_patches):
+        audit_patches.append({
+            "rule": "2.1", "location": "(metadata header)", "fix": ":id:",
+            "message": "ID vidé par post-process déterministe.", "iteration": 0,
+        })
+
+    audit_warnings.extend(pp.diff_solutions(content, myst_exercise))
+    audit_warnings.extend(pp.check_hardcoded_decimals_in_solutions(myst_exercise))
+
+    # Invariants multi-seed (règle 4.3).
+    main_code = extract_main_python_block(myst_exercise)
+    if constraints and main_code:
+        _step("Validation multi-seed des invariants…")
+        assertions = _translate_constraints_to_assertions(main_code, constraints, model_idx, model=m_meca)
+        if assertions:
+            seed_report = multi_seed_validate(
+                main_code, assertions, num_seeds=MULTI_SEED_NUM, timeout_per_seed=3.0)
+            if seed_report["num_exec_errors"] > 0:
+                audit_warnings.append({
+                    "rule": "4.3",
+                    "message": (f"Bloc Python : {seed_report['num_exec_errors']}/{MULTI_SEED_NUM} "
+                                f"exécutions ont échoué. Première erreur : "
+                                f"{seed_report.get('first_exec_error') or '?'}."),
+                })
+            for a in assertions:
+                summary = seed_report["summary_per_assertion"].get(a["assertion"], {})
+                viol = summary.get("violations", 0) + summary.get("errors", 0)
+                if viol:
+                    audit_warnings.append({
+                        "rule": "4.3",
+                        "message": (f"Invariant « {a['description']} » violé sur "
+                                    f"{viol}/{MULTI_SEED_NUM} seeds. "
+                                    f"Assertion : `{a['assertion']}`."),
+                    })
+
+    # Contrôles matplotlib (règles 11.x).
+    if main_code:
+        all_python_code = "\n".join(extract_all_python_blocks(myst_exercise))
+        audit_warnings.extend(static_check_rational_numpy_mix(all_python_code))
+        if "matplotlib" in all_python_code or analysis.get("needs_matplotlib"):
+            random_var_names = [v.get("nom") for v in (analysis.get("variables") or [])
+                                if isinstance(v, dict) and isinstance(v.get("nom"), str)]
+            unused = static_check_unused_random_vars(
+                all_python_code, random_var_names, markdown_text=myst_exercise)
+            if unused:
+                audit_warnings.append({
+                    "rule": "11.1",
+                    "message": ("Variables aléatoires non utilisées dans le tracé : "
+                                f"{', '.join(unused)}."),
+                })
+            _step("Validation matplotlib (labels in-bounds)…")
+            try:
+                audit_warnings.extend(dynamic_check_matplotlib(all_python_code, timeout=8.0))
+            except Exception as e:
+                audit_warnings.append({
+                    "rule": "11.3",
+                    "message": f"Audit matplotlib impossible : {type(e).__name__}: {e}.",
+                })
+
+    # ── 7. Langue cible ──────────────────────────────────────────────────────
+    _step("Langue cible…")
+    myst_exercise, lang_warnings, lang_info = ensure_language(myst_exercise, lang, model_idx, model=m_meca)
+    audit_warnings.extend(lang_warnings)
+    effective_lang = lang if lang_info["action"] != "aucune" else lang_info["source"]
+    audit_warnings.extend(pp.check_decimals_for_lang(myst_exercise, effective_lang))
+
+    # ── 8. Porte harnais + réparation ────────────────────────────────────────
+    myst_exercise, _aer = pp.aerate_blocks(myst_exercise)   # lisibilité (exemples)
+    myst_exercise, renum = pp.renumber_question_ids(myst_exercise)
+    if renum:
+        audit_patches.append({
+            "rule": "2.x", "location": ":questionId:/:questionIndex:",
+            "fix": "renumérotation 0..N-1",
+            "message": f"{renum} questionId/questionIndex renuméroté(s) (contiguïté plateforme).",
+            "iteration": 0,
+        })
+    _step(f"Porte harnais ({HARNESS_GATE_SEEDS} graines)…")
+    report = harness.validate_text(myst_exercise, seeds=HARNESS_GATE_SEEDS)
+
+    for attempt in range(HARNESS_REPAIR_MAX):
+        if report["ok"]:
+            break
+        _step(f"Harnais ROUGE — réparation LLM {attempt + 1}/{HARNESS_REPAIR_MAX}…")
+        try:
+            repaired = process_with_openrouter(
+                prompt=REPAIR_PROMPT.format(
+                    failures=harness.format_report(report),
+                    exercise=myst_exercise,
+                ),
+                model_idx=model_idx,
+                model=m_gen,
+                temperature=0.0,
+                max_tokens=30000,
+                system_prompt=SYSTEM_PROMPT,
+            )
+        except (RuntimeError, ValueError, OSError) as e:
+            audit_warnings.append({"rule": "harnais",
+                                   "message": f"Réparation LLM en échec : {e}."})
+            break
+        # Re-passe des filets déterministes sur le candidat réparé.
+        candidate = _apply_deterministic_nets(pp.strip_fences(repaired), decl_type)
+        candidate_report = harness.validate_text(candidate, seeds=HARNESS_GATE_SEEDS)
+
+        def _badness(r: dict) -> int:
+            return (len(r["static_errors"]) + r["n_exec_errors"]
+                    + r["n_unresolved"] + r["n_forbidden"]
+                    + r.get("n_mcq_collisions", 0))
+
+        if candidate_report["ok"] or _badness(candidate_report) < _badness(report):
+            myst_exercise, report = candidate, candidate_report
+            audit_patches.append({
+                "rule": "harnais", "location": "(exercice complet)",
+                "fix": "réparation LLM post-harnais",
+                "message": "Sortie réparée suite au verdict rouge du harnais.",
+                "iteration": attempt + 1,
+            })
+
+    if not report["ok"]:
+        audit_warnings.append({
+            "rule": "harnais",
+            "message": ("⚠️ SORTIE NON VERTE AU HARNAIS — à corriger avant soumission. "
+                        + harness.format_report(report)[:600]),
+        })
+
+    # ── 9. Audit pédagogique (déclinaisons, sortie VERTE) ────────────────────
+    # Au-delà du harnais MÉCANIQUE : un juge LLM évalue la finesse pédagogique et
+    # le respect des consignes (distracteurs cohérents, indevinabilité…), puis
+    # une réparation ciblée qui ne doit JAMAIS casser le harnais.
+    pedagogical = None
+    if decl_type and PEDAGO_AUDIT_ENABLED and report["ok"]:
+        _step("Audit pédagogique (finesse + respect des consignes)…")
+        # Juge sur son modèle dédié (PEDAGO_AUDIT_MODEL) — constant entre échelons,
+        # fort + JSON fiable, indépendant du modèle de génération qui escalade.
+        pedagogical = run_pedagogical_audit(myst_exercise, decl_type)
+        for attempt in range(PEDAGO_REPAIR_MAX):
+            if pedagogical.get("verdict") != "A_REVOIR" or not pedagogical.get("issues"):
+                break
+            _step(f"Réparation pédagogique {attempt + 1}/{PEDAGO_REPAIR_MAX}…")
+            try:
+                repaired = process_with_openrouter(
+                    prompt=PEDAGOGICAL_REPAIR_PROMPT.format(
+                        decl_label="QCM (MCQ)" if decl_type == "qcm" else "QAT (FGQ)",
+                        issues=format_pedagogical_issues(pedagogical["issues"]),
+                        exercise=myst_exercise,
+                    ),
+                    model=m_gen, temperature=0.0, max_tokens=30000,
+                    system_prompt=SYSTEM_PROMPT,
+                )
+            except (RuntimeError, ValueError, OSError) as e:
+                audit_warnings.append({"rule": "pédagogie",
+                                       "message": f"Réparation pédagogique en échec : {e}."})
+                break
+            cand = _apply_deterministic_nets(pp.strip_fences(repaired), decl_type)
+            cand_report = harness.validate_text(cand, seeds=HARNESS_GATE_SEEDS)
+            if not cand_report["ok"]:
+                audit_warnings.append({"rule": "pédagogie",
+                    "message": "Réparation pédagogique rejetée (casserait le harnais) "
+                               "— version précédente conservée."})
+                break
+            new_ped = run_pedagogical_audit(cand, decl_type)
+            if pedagogical_badness(new_ped) < pedagogical_badness(pedagogical):
+                myst_exercise, report, pedagogical = cand, cand_report, new_ped
+                audit_patches.append({"rule": "pédagogie", "location": "(exercice complet)",
+                    "fix": "réparation pédagogique LLM",
+                    "message": "Distracteurs/consignes améliorés suite à l'audit pédagogique.",
+                    "iteration": attempt + 1})
+            else:
+                break                     # n'améliore pas → on garde l'existant
+        if pedagogical.get("verdict") == "A_REVOIR":
+            audit_warnings.append({"rule": "pédagogie",
+                "message": "⚠️ QUALITÉ PÉDAGOGIQUE à revoir : "
+                           + format_pedagogical_issues(pedagogical.get("issues") or [])[:500]})
+
+    # ── Résultat ──────────────────────────���──────────────────────────────────
+    return {
+        "exercise": myst_exercise,
+        "pair_blocks": pair_blocks,
+        "analysis": analysis,
+        "functions": functions_ctx,
+        "notions": (notions_ctx + "\n" + lists_of_notions).strip(),
+        "audit_patches": audit_patches,
+        "warnings": audit_warnings,
+        "harness": {
+            "ok": report["ok"],
+            "seeds": report["seeds"],
+            "summary": harness.format_report(report),
+        },
+        "pedagogical": pedagogical,
+        "lang": lang_info,
+        "decl_type": decl_type,
+        "model_used": m_gen,
+        "cost": cost_delta(cost_before),
+        "duration_s": round(time.time() - t0, 1),
+    }
+
+
+def run_with_policy(
+    content: str,
+    filename: str = "exercise.md",
+    level: str = "",
+    lang: str = "fr",
+    policy: str = "auto",
+    manual_models: Optional[dict] = None,
+    decl_type: Optional[str] = None,
+    shared_phase: Optional[tuple] = None,
+    set_step: Optional[Callable[[str], None]] = None,
+) -> dict:
+    """
+    Traite UN exercice sous POLITIQUE de sélection de modèle (§5) :
+      auto  : pré-classifieur de difficulté → départ sur l'échelle `auto` ;
+              génération → harnais → ≤HARNESS_REPAIR_MAX réparations (même
+              modèle) → si toujours ROUGE, ESCALADE d'un échelon et retente
+              (analyse/RAG PARTAGÉS entre tentatives) → si `best` échoue,
+              marque l'exo pour revue humaine.
+      best / cheap / manual : un seul échelon (le modèle du preset).
+    Télémétrie dans result["policy_telemetry"].
+    """
+    from app.models import policy as mp
+
+    _step = set_step or (lambda label: None)
+    manual = manual_models or {}
+    m_audit = mp.openrouter_id(mp.resolve("audit", policy, manual))
+    m_meca = mp.openrouter_id(mp.resolve("mecanique", policy, manual))
+
+    cost_before_all = cost_snapshot()   # coût HONNÊTE : analyse + tous échelons
+    difficulty = mp.classify_difficulty(content)
+    if policy == "auto":
+        steps = mp.ladder("generate")
+        start = mp.start_rung("generate", difficulty)
+        rungs = steps[start:start + MAX_ESCALADES + 1] or steps[-1:]
+    else:
+        rungs = [mp.resolve("generate", policy, manual)]
+    if not rungs:
+        raise RuntimeError("Aucun modèle utilisable pour le rôle generate "
+                           "(clés API absentes) — vérifier OPENROUTER_API_KEY.")
+
+    shared = shared_phase
+    if shared is None:
+        _step("Analyse + notions + catalogue RAG (en parallèle)…")
+        shared = run_analysis_phase(content, 0, model=m_meca)
+
+    tried: list[dict] = []
+    result: dict = {}
+    key = rungs[0]
+    for i, key in enumerate(rungs):
+        _step(f"Échelon {i + 1}/{len(rungs)} — {key}…")
+        result = run_exercise(
+            content=content, filename=filename, level=level,
+            lang=lang, set_step=_step, decl_type=decl_type,
+            shared_phase=shared,
+            forced_models={"generate": mp.openrouter_id(key),
+                           "audit": m_audit, "mecanique": m_meca},
+        )
+        harness_ok = result["harness"]["ok"]
+        ped = result.get("pedagogical") or {}
+        ped_verdict = ped.get("verdict")            # OK / A_REVOIR / INCONNU / None
+        tried.append({"rung": i, "model": key, "ok": harness_ok,
+                      "pedago": ped_verdict})
+        is_last = (i == len(rungs) - 1)
+        # Acceptation d'un échelon : harnais VERT ET (qualité pédagogique OK, ou
+        # on n'escalade pas sur la pédagogie, ou dernier échelon). Sinon on
+        # gravit l'échelon suivant — c'est le « meilleur modèle selon l'exo ».
+        pedago_ok = ped_verdict != "A_REVOIR"
+        escalate_pedago = (policy == "auto" and PEDAGO_ESCALATE_IN_AUTO
+                           and not pedago_ok and not is_last)
+        if harness_ok and not escalate_pedago:
+            break
+        if not harness_ok:
+            logger.info("Échelon %s ROUGE (harnais) sur %s — escalade.", key, filename)
+        else:
+            logger.info("Échelon %s VERT mais qualité pédagogique à revoir sur %s "
+                        "— escalade de modèle.", key, filename)
+
+    result["policy_telemetry"] = {
+        "mode": policy,
+        "difficulty": difficulty,
+        "tried": tried,
+        "winning_model": key,
+        "pedago_verdict": (result.get("pedagogical") or {}).get("verdict"),
+        "needs_review": (not result["harness"]["ok"]
+                         or (result.get("pedagogical") or {}).get("verdict") == "A_REVOIR"),
+    }
+    # Coût honnête : inclut l'analyse partagée (si calculée ici) ET les
+    # échelons perdants — pas seulement la tentative gagnante.
+    result["cost"] = cost_delta(cost_before_all)
+    return result
+
+
+def run_declinaisons(
+    content: str,
+    filename: str = "exercise.md",
+    level: str = "",
+    model_idx: int = 1,
+    lang: str = "fr",
+    types: Optional[list] = None,
+    set_step: Optional[Callable[[str], None]] = None,
+    policy: str = "auto",
+    manual_models: Optional[dict] = None,
+) -> list[tuple[str, dict]]:
+    """
+    Mode `declinaisons` : produit une déclinaison par type coché (qcm/qat),
+    sous politique de sélection de modèle. L'analyse + notions + RAG sont
+    calculées UNE SEULE fois et partagées entre les types ET les échelons
+    (aucun appel LLM redondant). Retourne [(decl_type, result), …].
+    """
+    from app.models import policy as mp
+
+    _step = set_step or (lambda label: None)
+    types = [t for t in (types or []) if t in ("qcm", "qat")] or ["qcm"]
+
+    m_meca = mp.openrouter_id(mp.resolve("mecanique", policy, manual_models))
+    _step("Analyse + notions + catalogue RAG (partagés QCM/QAT)…")
+    cost_before_analysis = cost_snapshot()
+    shared = run_analysis_phase(content, model_idx, model=m_meca)
+    analysis_cost = cost_delta(cost_before_analysis)
+
+    out: list[tuple[str, dict]] = []
+    for decl_type in types:
+        label = "QCM" if decl_type == "qcm" else "QAT"
+
+        def step_with_type(msg: str, _label=label):
+            _step(f"[{_label}] {msg}")
+
+        result = run_with_policy(
+            content=content,
+            filename=filename,
+            level=level,
+            lang=lang,
+            policy=policy,
+            manual_models=manual_models,
+            decl_type=decl_type,
+            shared_phase=shared,
+            set_step=step_with_type,
+        )
+        out.append((decl_type, result))
+    # L'analyse partagée tombe HORS des fenêtres de coût de run_with_policy :
+    # on l'impute au premier type pour que le total du job reste honnête.
+    if out and analysis_cost["requests"]:
+        c = out[0][1].get("cost") or {"usd": 0.0, "eur": 0.0, "requests": 0}
+        out[0][1]["cost"] = {
+            "usd": round(c["usd"] + analysis_cost["usd"], 6),
+            "eur": round(c["eur"] + analysis_cost["eur"], 6),
+            "requests": c["requests"] + analysis_cost["requests"],
+        }
+    return out

prompts.py

@@ -0,0 +1,999 @@
+"""
+prompts.py
+──────────
+Tous les prompts LLM du pipeline.
+
+# v1 → les versions antérieures (STEP1_PROMPT, STEP_PAIR_PROMPT, SYSTEM_PROMPT,
+# STEP_AUDIT_PROMPT) sont archivées VERBATIM dans
+# app/knowledge/prompts_v1_archive.md (extraites de routes/pythonise_routes_v2.py
+# avant la refonte du 2026-06-12).
+#
+# Changements majeurs v1 → v2 (alignement sur les conventions RÉELLES de la
+# plateforme, vérifiées sur les 222 exemples pythonisés livrés + skill
+# pyxiscience-pythonisation) :
+#   • Injections {{ }} = UNIQUEMENT des noms de variables nus, camelCase,
+#     suffixe Aff, sans underscore. La v1 enseignait {{latex(expr)}},
+#     {{lc(a, sign=True)}}, {{pxsl_res_num(...)}} — tous absents des exemples
+#     validés et refusés par le harnais.
+#   • Bloc {python} à 4 backticks (la v1 montrait 3) ; enveloppe exercise à 5.
+#   • Bilingue = rôles inline {fr}`…`{en}`…` UNIQUEMENT (aucun bloc
+#     :::{fr}/:::{en} dans les 222 exemples — la v1 les enseignait).
+#   • Règle du `$` collé à un chiffre (préfixe ${}) — absente de la v1.
+#   • Fraction (module fractions) interdit en sortie de formateur ;
+#     pxsl_format_number SANS kwargs ; décimales localisées FR/EN.
+#   • Few-shot du type détecté injecté ({fewshot}) au lieu de 5 exemples
+#     génériques pavés dans le prompt.
+#   • SYSTEM_PROMPT raccourci (le dump de 180 lignes du source de
+#     pxsl_res_num doublonnait le catalogue RAG).
+"""
+
+# ─────────────────────────────────────────────────────────────────────────────
+# STEP 1 — Analyse (variables + règles à risque + invariants)
+# v1 → app/knowledge/prompts_v1_archive.md §STEP1_PROMPT
+# (v2 : typo needs_matplolib corrigée → needs_matplotlib ; mention du type
+#  pour la sélection de few-shot ; sinon structure conservée)
+# ─────────────────────────────────────────────────────────────────────────────
+STEP1_PROMPT = """\
+Tu es un expert en analyse d'exercices mathématiques & détection des variables Python pour PyxiScience,
+pour passer d'un exercice à valeurs statiques à un exercice à valeurs aléatoires **correctes**.
+
+EXERCICE :
+{content}
+
+─────────────────────────────────────────────────────
+MISSION : analyse cet exercice et identifie **TOUTES** les entités mathématiques
+qui devront être générées aléatoirement en Python.
+
+Couvre TOUS les types possibles : scalaires entiers/réels, fractions, listes,
+vecteurs, matrices, ensembles, polynômes, fonctions, pourcentages, angles, intervalles…
+
+Pour chaque variable :
+  • nom           : nom Python valide court (ex: a, b, n, matA, listeNotes),
+                    partageable entre questions
+  • type_python   : "int"|"float"|"Fraction"|"list"|"matrix"|"set"|"vector"|"other"
+  • description   : rôle dans l'énoncé (1 phrase)
+  • contraintes   : contraintes mathématiques (ex: a ≠ 0, n ∈ [2,10])
+  • plage_python  : expression Python exacte de génération aléatoire
+  • location      : "énoncé"|"inter-question"|"question"|"solution 1"|…|"solution 5"
+  • valeur_exemple: valeur typique
+
+─────────────────────────────────────────────────────
+RÈGLES DE PYTHONISATION (catalogue) — choisis dans "target_rules" celles qui
+sont LE PLUS À RISQUE pour CET exercice (5 à 12 IDs maximum).
+
+{available_rules_menu}
+
+─────────────────────────────────────────────────────
+Réponds UNIQUEMENT en JSON valide :
+{{
+  "exercise_type": "...",
+  "exercise_title": "...",
+  "exercise_summary": "...",
+  "suggested_concepts": ["..."],
+  "nb_questions": 1,
+  "variables": [
+    {{
+      "nom": "...",
+      "type_python": "...",
+      "description": "...",
+      "contraintes": "...",
+      "location": "énoncé|question|solution 1",
+      "plage_python": "...",
+      "valeur_exemple": "..."
+    }}
+  ],
+  "needs_fraction": false,
+  "needs_sympy": false,
+  "needs_numpy": false,
+  "needs_matplotlib": false,
+  "mathematical_structure": "...",
+  "target_rules": ["3.1", "4.1", "6.1"],
+  "property_constraints": [
+    "<invariant mathématique en français — ex: w_n ≥ n pour tout n>"
+  ],
+  "has_validated_solution_in_input": false
+}}
+
+Notes :
+  • "exercise_type" : type court et standard (ex: "équation linéaire",
+    "trinôme/discriminant", "fonction avec figure", "logarithme/exponentielle",
+    "système linéaire", "intégration par parties", "probabilités/binomiale",
+    "suites", "finance/intérêts") — il sert à choisir un exemple canonique.
+  • "target_rules" : uniquement des IDs du catalogue ci-dessus (top 5-12 à risque).
+  • "property_constraints" : invariants à préserver au tirage (règle 4.3). Liste vide si aucun.
+  • "has_validated_solution_in_input" : true SI l'énoncé contient déjà des
+    blocs `::::{{detailedSolution}}` rédigés (règles 8.1–8.3).
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SYSTEM — rôle + sémantique du runtime {{ }}
+# v1 → app/knowledge/prompts_v1_archive.md §SYSTEM_PROMPT
+# ─────────────────────────────────────────────────────────────────────────────
+SYSTEM_PROMPT = """\
+Tu es professeur de mathématiques, expert en Python scientifique (sympy, random,
+math, matplotlib, numpy) et en exercices PyxiScience randomisés (MyST + KaTeX).
+
+Le code Python vit dans UN bloc ````{python} … ```` (4 backticks) terminé par
+`globals()`. Les variables y définies sont injectées dans le MyST via `{{ var }}`.
+
+⚠️ La syntaxe `{{ var }}` est exécutée par un runtime Python maison — PAS du
+Jinja. RÈGLE ABSOLUE : `{{ … }}` contient UNIQUEMENT un nom de variable nu,
+en camelCase, SANS underscore, généralement suffixé `Aff` pour les affichages
+(ex: `{{coefAAff}}`). JAMAIS d'appel de fonction, de calcul, de filtre ni de
+logique dans `{{ }}` — tout est pré-calculé dans le bloc Python.
+
+Deux règles d'or :
+1. Tout ce qui s'affiche est PRÉ-CALCULÉ dans une variable puis injecté tel quel.
+2. On ne code JAMAIS en dur une réponse vraie seulement pour les valeurs de la
+   source : si un paramètre est randomisé, la réponse affichée est RECALCULÉE.
+
+Priorité aux helpers du catalogue PyxiScience (pxsl_latex_coefficient/lc,
+pxsl_res_num, pxsl_format_number, pxsl_matrix, pxs_Interval, pxs_config…) —
+appelés DANS le bloc Python, résultat stocké dans une variable `…Aff`.
+Ne jamais réimplémenter un helper existant.
+
+Exercices applicatifs : contexte ÉCONOMIE/GESTION (finance, comptabilité,
+marketing, microéconomie — registre école de commerce), jamais physique/chimie.
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# STEP 2+ — Génération par paires
+# v1 → app/knowledge/prompts_v1_archive.md §STEP_PAIR_PROMPT
+# ─────────────────────────────────────────────────────────────────────────────
+STEP_PAIR_PROMPT = """\
+Tu pythonises un exercice PyxiScience MyST, niveau {niveau}.
+Transformer l'exercice statique (valeurs fixes) en version randomisée
+(paramètres tirés en Python + injectés dans le MyST), EN respectant à la
+lettre les conventions de la plateforme ci-dessous.
+
+═══════════════════════════════════════════════════════════════════════════
+ CONVENTIONS PLATEFORME (vérifiées sur les exercices livrés — NON NÉGOCIABLES)
+═══════════════════════════════════════════════════════════════════════════
+
+STRUCTURE :
+  • Enveloppe exercice : 5 backticks `````{{exercise}} … ````` (déjà gérée).
+  • UN bloc Python principal : 4 backticks ````{{python}} … ```` terminé par
+    `globals()`. Imports en tête (`import random as rd`, sympy ciblé,
+    `from pyxiscience.Mes_fctions_generalistes_bis import pxs_config,
+    pxsl_latex_coefficient as lc` …) puis `config_standard = pxs_config()`.
+  • Chaque question : `:::::{{question}}` (5 deux-points) avec
+    `:questionType:`, `:questionId:`, `:questionIndex:` (contigus depuis 0) ;
+    sous-blocs `::::{{questionStatement}}`, `::::{{questionHint}}`,
+    `::::{{detailedSolution}}`, `::::{{weightDistribution}}` (4 deux-points).
+  • `:weightDistribution:` : recopier les poids de la source VERBATIM
+    (somme = 100 par question).
+
+INJECTIONS `{{{{ }}}}` — LA règle qui fait tout casser si violée :
+  • UNIQUEMENT un nom de variable NU : `{{{{coefAAff}}}}`, `{{{{resQ1Aff}}}}`.
+    camelCase, SANS underscore, suffixe `Aff` pour tout affichage.
+  • INTERDIT dans `{{{{ }}}}` : appel de fonction (`latex(...)`, `lc(...)`,
+    `pxsl_…(...)`, `obj.print()`), calcul (`a*b`), `round(...)`, `**kwargs`.
+    → TOUT se pré-calcule dans le bloc Python :
+      `eqAff = latex(a*x**2 + b*x + c, **config_standard)` puis `{{{{eqAff}}}}`.
+  • `**config_standard` est réservé à `sympy.latex(...)` DANS le bloc Python.
+    `pxsl_format_number()` n'accepte AUCUN kwarg. `pxsl_res_num(x, dec=…,
+    egal=False)` s'appelle dans le bloc Python, résultat dans une variable Aff.
+  • Espaces contre la triple-accolade : `x^{{ {{{{expAff}}}} }}` ✅,
+    jamais `x^{{{{{{expAff}}}}}}` ❌.
+
+RÈGLE DU `$` COLLÉ À UN CHIFFRE (casse silencieuse) :
+  Un `$` immédiatement suivi d'un chiffre est lu comme un MONTANT en devise et
+  désynchronise tout le `$…$`. Préfixer par un groupe vide : `${{}}3 \\times 2$`,
+  et SURTOUT `${{}}{{{{nAff}}}}$` pour toute injection inline qui rend un nombre.
+  Pour un vrai pourcentage affiché : `\\%` partout (jamais `%` nu dans le texte) ;
+  ne JAMAIS échapper les `%` à l'intérieur du bloc Python (chaînes "%.2f").
+
+TIRAGES — exclure les cas dégénérés (boucle de rejet ou énumération) :
+  • `for _ in range(300): … ; break` ou liste de candidats + `rd.choice(...)`
+    (contraintes croisées → TOUJOURS énumération en compréhension, jamais
+    une boucle qui peut sortir invalide).
+  • Exclure : exposant 0 ou 1 affiché (`^{{0}}`, `^{{1}}`), dénominateur 1
+    (`\\frac{{…}}{{1}}`), `\\sqrt[1]`, `\\sqrt[2]` (→ `\\sqrt`), double signe
+    (`+ -`), division par zéro, Δ de signe inattendu, intervalle vide.
+  • Exactitude : `sympy.Rational(1, 2)`, JAMAIS `1/2` flottant ni `round()`
+    pour une valeur exacte. Le module `fractions.Fraction` PLANTE les
+    formateurs plateforme — ne jamais le passer à un helper pxsl_*.
+  • Coefficients signés : ne JAMAIS concaténer un signe à une valeur ;
+    utiliser `lc(coef, sign=True, ones=True)` (pxsl_latex_coefficient) dans
+    le bloc Python → variable Aff.
+
+DÉCIMALES SELON LA LANGUE : FR = virgule (`0{{,}}18`, `4,12`), milliers `\\,` ;
+EN = point (`0.18`), milliers virgule. {lang_directive}
+
+BILINGUE (si l'exercice l'est) : rôles INLINE uniquement :
+  {{fr}}`Calculer …`{{en}}`Compute …`
+  Jamais de bloc :::{{fr}}/:::{{en}}. Les injections `{{{{var}}}}` se placent
+  HORS des rôles : {{fr}}`Il y a `{{en}}`There are `{{{{nAff}}}}.
+  Symétrie totale FR/EN (même détail, mêmes placeholders). Si un nombre
+  décimal s'affiche, prévoir des variables séparées par langue
+  (`prixAffFr` virgule / `prixAffEn` point) et injecter la bonne dans chaque rôle.
+
+FIDÉLITÉ À LA SOURCE (directive Chabane — INTOUCHABLE) :
+  • Même énoncé, même méthode, même structure de solution, mêmes poids.
+  • Ne JAMAIS AJOUTER de phrase d'énoncé, de transition ou de rappel de règle
+    absent de la source (même « pour aider ») — on pythonise, on n'enrichit pas.
+  • Conserver les commentaires utiles du bloc Python source s'il en a.
+  • Si la source contient des `detailedSolution` validées : INTERDICTION de
+    reformuler la prose — seules les valeurs littérales deviennent `{{{{var}}}}`.
+  • Conserver tels quels : `\\ds`, `\\dfrac`, `\\inftys` (macro maison, ne
+    JAMAIS la « corriger »), `\\begin{{equation*}}` avec `&=` direct,
+    `\\phantom{{-}}\\\\`. Pas de `$$…$$`, pas de `\\[…\\]`, pas de `\\begin{{align}}`.
+  • Géométrie pure : ne pas pythoniser (valeurs statiques conservées).
+
+FIGURES matplotlib (si l'exo en a) : construites dans LE bloc Python unique,
+variables du tirage réellement utilisées dans le tracé, labels DANS la fenêtre,
+pas de mélange Rational+numpy (passer par float()), UN SEUL `plt.show()` final —
+jamais `savefig`, jamais `matplotlib.use(...)`.
+
+═══════════════════════════════════════════════════════════════════════════
+ CATALOGUE PyxiScience (helpers à utiliser DANS le bloc Python)
+═══════════════════════════════════════════════════════════════════════════
+RÈGLE D'OR DU CATALOGUE : avant d'écrire le moindre LaTeX à la main, CHERCHE
+ici un helper qui fait le travail et UTILISE-LE (résultat dans une variable
+`…Aff` injectée nue). Coder à la main ce qu'un helper sait faire = REJET.
+  • Matrices → `pxsl_matrix` (jamais `\\begin{{pmatrix}}` à la main) ; sommes/
+    produits/scalaires détaillés → `pxsl_sum_matrix`/`pxsl_prod_matrix`/
+    `pxsl_prod_scalar_matrix` ; système `Ax=B` → `pxsl_system_lin` ; résolution
+    pas à pas / inversion → `pxsl_resol_system` / `pxs_steps_invert_matrix` ;
+    échelon/RREF → `pxs_compute_ech`/`pxs_compute_ech_reduite`.
+  • Proba (v.a. finie) → `pxs_finiterv`, tableau de loi `pxsl_law`, moment
+    `pxsl_moment`, transformation `pxs_fct_finiterv`.
+  • Intégration par parties → `pxs_explain_IBP` (rédaction complète, injectée
+    via `{{{{ipp}}}}`).
+  • Coefficients signés → `pxsl_latex_coefficient`/`lc` ; puissances →
+    `pxsl_pow` ; résultat numérique → `pxsl_res_num` ; inéquation rédigée →
+    `pxsl_solve_general_inequality`.
+  • Voie par défaut pour une expression : `latex(expr, **config_standard)`.
+    `**config_standard` est réservé à `latex()` — JAMAIS sur un helper `pxsl_*`.
+  • N'appelle PAS un helper marqué « runtime à vérifier » (indi_l_r_symb,
+    pxs_round, Poly_with_random_coef) sans certitude qu'il est chargé.
+
+{functions}
+
+═══════════════════════════════════════════════════════════════════════════
+ EXEMPLE CANONIQUE DU MÊME TYPE (extrait d'un exercice livré et validé —
+ imite sa structure, ses conventions d'affichage et son niveau de détail)
+═══════════════════════════════════════════════════════════════════════════
+{fewshot}
+
+═══════════════════════════════════════════════════════════════════════════
+ CONTEXTE
+═══════════════════════════════════════════════════════════════════════════
+
+EN-TÊTE déjà finalisé (NE PAS reproduire) :
+{content}
+
+VARIABLES DÉTECTÉES :
+{analysis}
+
+BLOCS PRÉCÉDENTS (ne pas redéfinir leurs variables, ne pas les répéter) :
+{previous_blocks}
+
+SECTION À PYTHONISER ({range_label} / {nb_total}) :
+{current_segment}
+
+═══════════════════════════════════════════════════════════════════════════
+ RÈGLES D'ASSEMBLAGE PAR PAIRE
+═══════════════════════════════════════════════════════════════════════════
+
+⚠️ TU PRODUIS UNIQUEMENT LE CONTENU DE CETTE PAIRE — jamais celui des paires
+précédentes (concaténées mécaniquement avant ta sortie).
+
+⚠️ EXACTEMENT {nb_current} bloc(s) `:::::{{question}}` — pas plus, pas moins.
+`questionId`/`questionIndex` CONTINUS depuis la paire précédente.
+
+⚠️ PAIRE 1 UNIQUEMENT : tu produis le bloc ````{{python}}```` principal
+(imports + tirages + calculs + variables Aff + `globals()`) puis l'énoncé
+général réécrit avec injections, AVANT la première question.
+
+⚠️ PAIRES SUIVANTES : ni énoncé, ni questions précédentes, ni ré-imports.
+Si de NOUVELLES variables sont nécessaires (ex. figure d'une partie C), un
+PETIT bloc ````{{python}}```` additionnel SANS imports, terminé par `globals()`.
+
+Format paire 1 :
+
+````{{python}}
+<imports + tirages (cas dégénérés exclus) + calculs sympy exacts
+ + TOUTES les variables d'affichage …Aff ; AUCUN texte pédagogique>
+globals()
+````
+
+<énoncé général avec valeurs → {{{{varAff}}}}>
+
+:::::{{question}}
+:questionType: STQ
+:questionId: N
+:questionIndex: N
+
+::::{{questionStatement}} … ::::
+::::{{questionHint}} … ::::
+::::{{detailedSolution}} … ::::
+::::{{weightDistribution}}
+:logic: …
+:abstraction: …
+:reasoning: …
+:calculation: …
+::::
+:::::
+
+═══════════════════════════════════════════════════════════════════════════
+ RÈGLES CIBLÉES POUR CET EXERCICE (depuis la base de règles)
+═══════════════════════════════════════════════════════════════════════════
+{targeted_rules}
+
+INVARIANTS MATHÉMATIQUES à préserver lors des tirages :
+{property_constraints}
+
+═══════════════════════════════════════════════════════════════════════════
+ CHECKLIST FINALE (vérifie chaque point avant de répondre)
+═══════════════════════════════════════════════════════════════════════════
+  □ Bloc ````{{python}}```` (4 backticks) terminé par `globals()`
+  □ CHAQUE `{{{{ }}}}` = nom de variable NU camelCase sans underscore
+  □ Aucun appel/calcul/`**kwargs` dans `{{{{ }}}}` — tout pré-calculé en `…Aff`
+  □ Aucun `$` collé à un chiffre — `${{}}` devant toute injection inline numérique
+  □ Tirages sans cas dégénéré (^{{1}}, ^{{0}}, frac{{}}{{1}}, sqrt[2], double signe)
+  □ Coefficients signés via lc(...) pré-calculé ; décimales localisées
+  □ weightDistribution = poids source verbatim (somme 100) ; IDs contigus
+  □ Solutions validées : prose INTACTE, valeurs → {{{{var}}}}
+  □ {{fr}}`…`{{en}}`…` symétriques si bilingue ; `\\%` pour les pourcentages
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AUDIT — vérification ciblée + patches textuels
+# v1 → app/knowledge/prompts_v1_archive.md §STEP_AUDIT_PROMPT
+# (v2 : ajout des contrôles injections nues / $+chiffre / fences 4 backticks ;
+#  les patches sont désormais appliqués à TOUTES les occurrences identiques)
+# ─────────────────────────────────────────────────────────────────────────────
+STEP_AUDIT_PROMPT = """\
+Tu es l'auditeur PyxiScience. Tu reçois l'exercice pythonisé final et tu vérifies
+UNIQUEMENT les règles listées ci-dessous (chacune avec son cas FAUTIF/CORRECT),
+plus les 4 invariants plateforme :
+  (a) toute injection `{{{{ }}}}` est un nom de variable NU camelCase sans underscore ;
+  (b) aucun `$` non échappé collé à un chiffre (préfixe `${{}}` requis) ;
+  (c) bloc {{python}} à 4 backticks terminé par `globals()` ;
+  (d) questionId/questionIndex contigus depuis 0, weightDistribution somme 100.
+
+RÈGLES À VÉRIFIER :
+
+{audit_rules}
+
+EXERCICE À AUDITER :
+{exercise}
+
+═══════════════════════════════════════════════════════════════════════════
+ MISSION
+═══════════════════════════════════════════════════════════════════════════
+
+Pour chaque règle violée, renvoie une "issue" :
+  • rule           : ID de la règle (ex: "6.1") ou "(a)"…"(d)"
+  • location       : snippet EXACT (1 ligne, ≤ 200 caractères), copié VERBATIM —
+                     utilisé tel quel par str.replace() côté Python.
+                     Si la même violation apparaît à N endroits IDENTIQUES,
+                     une seule issue suffit (toutes les occurrences seront
+                     remplacées).
+  • fix            : remplacement EXACT.
+  • python_insert  : (OPTIONNEL) ligne(s) Python à insérer avant le `globals()`
+                     du bloc principal (ex: "eqAff = latex(eq, **config_standard)").
+  • can_patch      : true si la correction est sûre, false sinon (warning seul).
+  • message        : phrase explicative en français.
+
+Ne liste PAS les règles respectées ni celles hors liste. Ne « corrige » JAMAIS
+`\\inftys`, `\\ds`, `\\dfrac`, ni la prose d'une solution validée.
+Un exercice MONOLINGUE (tout FR ou tout EN, sans rôles {{fr}}`…`{{en}}`…`) est
+LÉGITIME — ne le signale pas ; n'exige le bilingue que s'il est déjà partiel.
+Les espaces internes `{{{{ var }}}}` sont tolérés (le moteur trim) — ne les
+signale pas.
+
+Réponds UNIQUEMENT en JSON valide, sans markdown :
+{{
+  "verdict": "OK" ou "PATCH_REQUIRED",
+  "issues": [
+    {{
+      "rule": "6.1",
+      "location": "{{{{latex(fDev, **config_standard)}}}}",
+      "fix": "{{{{fDevTex}}}}",
+      "python_insert": "fDevTex = latex(fDev, **config_standard)",
+      "can_patch": true,
+      "message": "Appel avec **kwargs dans {{{{…}}}} — variable pré-calculée."
+    }}
+  ]
+}}
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Traduction de contraintes FR → assertions Python (règle 4.3)
+# (inchangé v1 — déplacé depuis routes/pythonise_routes_v2.py)
+# ─────────────────────────────────────────────────────────────────────────────
+TRANSLATE_CONSTRAINTS_PROMPT = """\
+Tu reçois un bloc de code Python qui tire des variables aléatoires et calcule
+des grandeurs dérivées, et une liste de contraintes mathématiques en français
+à vérifier sur les variables produites.
+
+CODE PYTHON :
+```python
+{code}
+```
+
+CONTRAINTES (français) :
+{constraints}
+
+MISSION :
+Pour chaque contrainte, écris une expression Python booléenne qui, évaluée
+dans le namespace résultant de l'exécution du code, retourne True si la
+contrainte est respectée.
+
+Règles :
+  • Contrainte universelle ("pour tout n") → échantillonner n = 0..10 max et
+    combiner avec `all(...)` (5 à 10 valeurs, pas plus).
+  • Notations math (≤, ≥, ≠) → `<=`, `>=`, `!=`.
+  • Contrainte intestable (variable absente du code) → `"assertion": null`.
+  • AUCUN import supplémentaire — seulement les variables du namespace + builtins.
+
+Réponds UNIQUEMENT en JSON valide :
+[
+  {{"description": "<contrainte originale>", "assertion": "<expression Python>" }},
+  {{"description": "<autre contrainte>",     "assertion": null }}
+]
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Substitution des solutions validées (règle 8.1)
+# (inchangé v1 — déplacé depuis routes/pythonise_routes_v2.py)
+# ─────────────────────────────────────────────────────────────────────────────
+SOLUTION_SUBSTITUTION_PROMPT = """\
+Tu reçois UNE solution mathématique rédigée avec des VALEURS LITTÉRALES (nombres,
+fractions, expressions concrètes), et une liste de VARIABLES PYTHON disponibles
+dans le bloc `{{python}}` de l'exercice pythonisé.
+
+SOLUTION ORIGINALE (source MyST, à préserver mot à mot) :
+─────────────────────────────────
+{original_solution}
+─────────────────────────────────
+
+VARIABLES PYTHON DISPONIBLES (chaque var a une valeur d'exemple ; substitue
+chaque occurrence numérique par le placeholder MyST {{{{var}}}}) :
+{variables_table}
+
+═══════════════════════════════════════════════════════════════════════════
+ MISSION
+═══════════════════════════════════════════════════════════════════════════
+
+Remplace CHAQUE valeur littérale (nombre entier, fraction, expression numérique)
+qui correspond à une variable Python par son placeholder MyST `{{{{nomVar}}}}`.
+
+⚠️ STRICTES INTERDICTIONS :
+  • NE PAS ajouter de mots (Initialisation, Hérédité, Conclusion, Soit, Donc, etc.)
+  • NE PAS ajouter de **gras** ou *italique* si pas dans la source
+  • NE PAS reformuler la moindre phrase ; NE PAS modifier la ponctuation
+  • NE PAS ajouter de paragraphes ou de blocs equation*
+  • Si la source utilise déjà des `{{{{var}}}}`, les PRÉSERVER tels quels.
+
+EXEMPLE :
+  Source     : `On a $f(0) = 3$ et $f(2) = -1$.`
+  Variables  : x0=0, x2=2, fx0=3, fx2=-1
+  Sortie     : `On a $f({{{{x0}}}}) = {{{{fx0}}}}$ et $f({{{{x2}}}}) = {{{{fx2}}}}$.`
+
+Réponds UNIQUEMENT avec le texte modifié, SANS préambule, SANS wrapper markdown,
+SANS guillemets ajoutés. Si tu ne peux pas substituer, recopie la source telle quelle.
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Traduction / bilinguisation (NOUVEAU — chantier langue cible)
+# ─────────────────────────────────────────────────────────────────────────────
+TRANSLATE_PROMPT = """\
+Tu traduis la PROSE d'un exercice PyxiScience MyST, de {source_label} vers {target_label}.
+
+TEXTE (les blocs Python ont été remplacés par des sentinelles <<<PYBLOCK_n>>> — à RECOPIER TELLES QUELLES) :
+─────────────────────────────────
+{body}
+─────────────────────────────────
+
+RÈGLES ABSOLUES :
+  • Traduire UNIQUEMENT la prose (énoncés, indications, solutions, titres).
+  • PRÉSERVER À L'IDENTIQUE : toutes les sentinelles <<<PYBLOCK_n>>>, tous les
+    placeholders `{{{{var}}}}` (mêmes noms, mêmes positions logiques), tout le
+    LaTeX/maths ($…$, \\begin{{equation*}}…), la structure des fences MyST
+    (`````, :::::, ::::), toutes les options `:clé: valeur` (dont
+    :questionId:, :weightDistribution: et leurs valeurs), `\\ds`, `\\dfrac`,
+    `\\inftys`, `\\%`.
+  • {format_directive}
+  • Décimales : virgule en FR (`0{{,}}5`), point en EN (`0.5`) — adapte les
+    décimales LITTÉRALES de la prose à la langue de chaque segment ; ne touche
+    pas aux `{{{{var}}}}`.
+  • Terminologie mathématique scolaire exacte ; même niveau de détail.
+
+Réponds UNIQUEMENT avec le texte transformé, sans préambule ni wrapper.
+"""
+
+TRANSLATE_FORMAT_MONO = (
+    "Sortie MONOLINGUE en {target_label} : remplace chaque texte source par sa "
+    "traduction, sans rôles {{fr}}/{{en}}."
+)
+TRANSLATE_FORMAT_BOTH = (
+    "Sortie BILINGUE : chaque segment de prose devient une paire de rôles inline "
+    "{fr}`texte français`{en}`english text` (JAMAIS de bloc :::{fr}/:::{en}). "
+    "Les injections {{var}} et le LaTeX restent HORS des rôles, partagés par les "
+    "deux langues : {fr}`Il y a `{en}`There are `{{nAff}}."
+)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# DÉCLINAISONS QCM / QAT (NOUVEAU 2026-07 — mode `declinaisons`)
+# Spécification normative fournie par l'équipe (PROMPT_declinaisons_QCM_QAT §4-§6),
+# calibrée sur les 33 exemples validés de knowledge/fewshots/declinaisons/.
+# Divergences wx ↔ conventions strictes (corpus 222) tranchées : format
+# plateforme des wx (mcqAnswer/:solution:/{input}) + conventions strictes de
+# l'app (fences 4, globals(), injections nues camelCase Aff, IDs contigus).
+# v1 → v2 (2026-07-02) : MCQ_SPEC + section « DISTRACTEURS EN MIROIR » (règle
+# enseignante : grille symétrique, bonne réponse jamais devinable par la forme).
+# v2 → v3 (2026-07-06) : intégration du prompt système QCM affiné —
+# distracteurs cohérents (erreur réelle, near-miss même famille, flip jamais sur
+# entrée nulle, swap sûr en symbolique), formulation directe, matrices d'option
+# en \small (anti-scrollbar), éclatement avec solution partitionnée. Écart
+# assumé vs le prompt fourni : questionHint reste REMPLI (35/35 dans les 33
+# exemples validés qui font foi), pas vide.
+# ─────────────────────────────────────────────────────────────────────────────
+
+MCQ_SPEC = """\
+FORMAT QCM (questionType MCQ) — NORMATIF :
+
+:::::{question}
+:questionType: MCQ
+:questionId: N
+:questionIndex: N
+
+::::{questionStatement}
+<énoncé auto-suffisant ; maths et {{ }} HORS des rôles bilingues>
+::::
+
+::::{questionHint}
+<indice de DÉMARRAGE qui ne révèle pas la réponse ; VERBATIM si repris de la source>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+<BONNE réponse — TOUJOURS en slot 1>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 1 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 2 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+<distracteur 3 — erreur type>
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+<solution détaillée ; VERBATIM de la source si elle existe, sinon rédigée>
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::
+
+RÈGLES MCQ DURES :
+  • EXACTEMENT UNE option `:isRightAnswer: true`, EN SLOT 1 (l'affichage est
+    mélangé côté plateforme — ne PAS randomiser l'ordre dans le fichier).
+  • 5 options par défaut (1 correcte + 3 distracteurs + « None » EN DERNIER).
+    Ensembles fermés (vrai/faux, intervalles exhaustifs) : « None » omis
+    autorisé (⇒ 4 options ; jamais moins de 3).
+  • PAS de `:solution:`, PAS de `{input}`, PAS de displayedSolution en MCQ.
+  • Ordre des blocs : questionStatement → questionHint → mcqAnswer×N →
+    detailedSolution → weightDistribution.
+  • L'option « None » et toute option textuelle sont bilingues si la cible l'est.
+
+DISTRACTEURS — ERREURS TYPES UNIQUEMENT (aucune valeur au hasard) :
+  • Algèbre : erreur de signe ; coefficient inversé ; terme oublié ; distribution partielle.
+  • Dérivées : oubli du facteur de la règle de chaîne ; exposant non décrémenté ;
+    primitive au lieu de dérivée ; quotient sans v² ; produit sans la 2e moitié.
+  • Intégrales : oubli du +1 sur l'exposant ; oubli du 1/a ; dérivée au lieu de
+    primitive ; oubli de |x| dans ln.
+  • Matrices : transposée ; colonnes/lignes échangées ; entrée non dérivée ;
+    matrice opposée ; oubli du terme +b.
+  • Compositions affines : oubli de b_f ; ordre inversé (g∘f vs f∘g) ; signe opposé.
+  • Limites : mauvaise forme indéterminée ; mauvais signe d'infini.
+
+DISTRACTEURS COHÉRENTS & INDEVINABLES (règle enseignante, 2026-07-02) —
+un distracteur = une ERREUR RÉELLE que l'élève peut commettre, jamais une
+variante trivialement éliminable :
+
+  INTERDITS (trop faciles à deviner) :
+  • Garder une partie IDENTIQUE dans toutes les options alors qu'un seul bloc
+    change (ex. matrice A identique partout, seul b varie) → l'élève ignore A
+    et devine sur b. Fais VARIER la partie qui teste vraiment (ici A).
+  • ÉTIQUETER la classification qui trahit la réponse (« f is linear, b=0 »
+    quand des constantes sont visibles → écarté sans réfléchir). Ne nomme PAS
+    linear/affine dans les options : demande directement « quels A et b ? » et
+    montre les paires.
+  • Distracteurs ARTIFICIELS (−A tout entier, 2b…) sans erreur pédagogique
+    derrière.
+  • Variations « une seule chose à la fois » autour de la bonne réponse
+    (2x+3 / 2x−3 / 2x−4 / −2x+3) → le motif commun « 2x+3 » se devine.
+
+  À PRIVILÉGIER (erreurs pédagogiques réelles, en grille refermée) :
+  • Signe mal lu sur UNE entrée précise de A ou de b (ex. −4x lu +4x).
+  • Transposée de A (colonnes ↔ lignes) — erreur de lecture classique.
+  • Constante oubliée (b = 0, NON étiquetée « linear »).
+  • Oubli/inversion d'un terme (+b oublié, b soustrait au lieu d'ajouté).
+  • Encadrement/bornes : décalage ±1 (off-by-one).
+  • Combinaisons SYMÉTRIQUES qui referment la grille (signe × signe,
+    ordre × signe) plutôt que des erreurs indépendantes autour d'un gabarit :
+      ✓ 2x+3 / 2x−3 / −2x+3 / −2x−3 (grille de signes : l'intuition ne trie
+        plus, il faut CALCULER).
+  • La bonne réponse n'est JAMAIS structurellement unique : ni la seule avec
+    radical/fraction/facteur, ni la plus longue/courte, ni la seule simplifiée
+    — TOUTES au même niveau de simplification (jamais de fraction réductible).
+  • Test avant de rendre : masque mentalement la bonne réponse — si sa place
+    se retrouve par la seule FORME (motif majoritaire, symétrie incomplète,
+    singularité, bloc figé), reconstruis les distracteurs.
+
+  DISTINCTION GARANTIE SUR TOUTES LES DÉCLINAISONS :
+  • Construis chaque distracteur par une modification à DELTA NON NUL GARANTI,
+    chacun sur une ENTRÉE/POSITION DIFFÉRENTE. Techniques sûres :
+      – Flip de signe d'une entrée : SEULEMENT sur une entrée GARANTIE ≠ 0
+        (flipper un 0 redonne l'original → collision). Tire ces entrées dans un
+        domaine excluant 0, ou choisis une position structurellement non nulle.
+      – Interversion de colonnes/variables (∂x↔∂y) : SÛRE sur entrées
+        SYMBOLIQUES (une colonne dépend de x, l'autre de y → jamais égales) ;
+        DANGEREUSE sur entrées entières (deux colonnes peuvent coïncider) → dans
+        ce cas, préférer 3 flips de signe sur des entrées distinctes non nulles.
+      – Décalage ±1 (bornes entières) ; multiple/omission (b oublié, −b, 2b).
+  • Vérifie en Python : sur ≥300 tirages, `assert` que les options sont deux à
+    deux distinctes (chaînes rendues). Aucune collision tolérée.
+
+ANTI-COLLISION (le piège n°1 des QCM randomisés — un distracteur peut devenir
+ÉGAL à la bonne réponse sur certaines graines) — dans CET ordre :
+  1. DISTINCT PAR CONSTRUCTION (préféré) : distracteurs de type différent,
+     tirages qui garantissent la non-nullité/non-égalité (coefficients >= 2,
+     exposants >= 2, entrées non nulles…). Documente-le en commentaire Python.
+  2. TIRAGE AVEC REJET dans le bloc Python : reboucler tant que les chaînes
+     RENDUES (latex) de toutes les options ne sont pas toutes distinctes.
+  3. Le harnais vérifie l'unicité sur 100 graines — un doublon = REJET.
+  ⚠️ La collision est aussi SÉMANTIQUE : deux options formulées différemment
+  mais mathématiquement ÉQUIVALENTES (« divise x par 2 » ≡ « multiplie x par
+  1/2 » ; « T_{1/a,1/b} » ≡ « division par a et b ») comptent comme un doublon
+  pour l'élève. Vérifie l'équivalence MATHÉMATIQUE de chaque paire d'options
+  sur TOUT l'espace des tirages (ex. b == 1/a possible ? → l'exclure au tirage).
+
+UN SEUL bloc {python} au total : JAMAIS de re-tirage (`rd.`/`random`) hors du
+bloc principal — un second tirage rendrait les valeurs incohérentes entre les
+questions. Les variables des paires suivantes s'ajoutent SANS aléa nouveau.
+
+FORMATAGE : STRICTEMENT IDENTIQUE entre bonne réponse et distracteurs (même
+style LaTeX, mêmes helpers, même nombre de décimales, même notation
+matricielle, MÊME LONGUEUR) — sinon la bonne réponse se devine.
+  • JAMAIS d'exemple/parenthèse explicative sur la SEULE bonne réponse
+    (« … (e.g. A<B donne x) ») : soit tout le monde a l'ajout, soit personne.
+  • JAMAIS d'annotation d'erreur visible dans une option (« (signe oublié) »,
+    « (forgot +b) ») — ça vit UNIQUEMENT dans la solution détaillée.
+
+FORMULATION DIRECTE (QCM) : on demande le RÉSULTAT à cocher. Retire les consignes
+de méthode/rédaction qui n'ont de sens qu'en réponse libre — « calcule de deux
+façons », « vos deux réponses doivent coïncider », « montre que… », « trace /
+esquisse… », « justifie… ». Ex. : « Compute (f∘g)(x) in two ways… should
+agree! » → « Compute (f∘g)(x). »
+
+RENDU DES MATRICES DANS LES OPTIONS (anti-scrollbar) : une `bmatrix` pleine dans
+une case d'option fait apparaître un ascenseur. Si une OPTION contient une
+matrice, réduis-la : `{\\small \\begin{bmatrix}…\\end{bmatrix}}` (échelle si
+besoin : smallmatrix < \\scriptsize < \\footnotesize < \\small ; défaut \\small).
+Garde les `bmatrix` PLEINES dans la detailedSolution (fidélité + place).
+
+ÉCLATEMENT (autorisé) : si UNE question porte sur N cas indépendants (par
+ellipse, par sous-fonction…), tu peux l'éclater en N questions — le contexte
+commun monte dans l'énoncé global, et la detailedSolution source est PARTITIONNÉE
+par cas (**(i)**, **(ii)**…) puis rattachée à chaque question. Contrainte dure :
+la CONCATÉNATION des morceaux doit être IDENTIQUE à la solution source. Par
+défaut (pas de cas multiples), garde le MÊME nombre de questions que la source.
+
+questionHint : indice de DÉMARRAGE qui ne révèle jamais la réponse (cf. exemples
+validés — tous en fournissent un) ; VERBATIM si la source en a un ; vide
+seulement si aucun indice pertinent.
+
+L'ÉNONCÉ NE DONNE JAMAIS LA RÉPONSE (l'énoncé définit, la question interroge).
+"""  # noqa: E501 — texte normatif verbatim (valeur injectée telle quelle, accolades SIMPLES)
+
+FGQ_SPEC = """\
+FORMAT QAT (questionType FGQ — question à champ(s) libre(s) ordonné(s)) — NORMATIF :
+
+:::::{question}
+:questionType: FGQ
+:questionId: N
+:questionIndex: N
+:solution: [["ord","${{v1Aff}}$","${{v2Aff}}$"],["0","0"]]
+
+::::{questionStatement}
+<énoncé auto-suffisant>
+
+<LIGNE VIDE obligatoire avant le premier {input}>
+$x_1 =$ {input}`||110` $\\qquad x_2 =$ {input}`||110`
+::::
+
+::::{questionHint}
+<indice — vide ou verbatim source>
+::::
+
+::::{displayedSolution}
+$x_1 = {{v1Aff}}$, $\\quad x_2 = {{v2Aff}}$
+::::
+
+::::{detailedSolution}
+<solution détaillée>
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 20
+:calculation: 45
+::::
+:::::
+
+RÈGLES FGQ DURES :
+  • `:solution:` DIRECTEMENT dans le champ (jamais construite dans une variable
+    Python), juste après `:questionIndex:`. Format [["ord","<v1>",…],["0",…]].
+  • ARITÉ STRICTE : nb de {input} == nb de valeurs dans "ord" == nb de
+    tolérances. Tolérance TOUJOURS "0" (exacte).
+  • Un `{{varAff}}` par valeur dynamique dans `:solution:` (variable NUE).
+  • ORDRE : les valeurs de "ord" suivent l'ordre d'apparition des {input}
+    dans l'énoncé. Plusieurs solutions (racines…) → ÉNONCER l'ordre (« de la
+    plus petite à la plus grande ») et le respecter dans "ord" ET dans
+    displayedSolution.
+  • Chaque {input} est INTRODUIT PAR UN LABEL ($x =$ {input}`||110`),
+    jamais nu, jamais collé à la prose ; LIGNE VIDE avant le premier {input}.
+  • Ordre des blocs : questionStatement → questionHint → displayedSolution →
+    detailedSolution → weightDistribution.
+  • Valeurs EXACTES (fractions, \\ln, \\sqrt, +\\infty…) — JAMAIS de décimales
+    approchées dans `:solution:`.
+  • REPLI MCQ : si une question n'est PAS auto-corrigeable en champ libre
+    (réponse avec fonction abstraite, vrai/faux, matrice à dimension VARIABLE),
+    produis cette question en MCQ (format ci-contre) — une sortie QAT peut être
+    mixte FGQ + MCQ. Ne force JAMAIS un champ libre ingérable.
+
+MATRICES EN QAT (PIÈGE plateforme) :
+  • `pxsl_matrix` est INTERDIT dans un champ `:solution:` (le rendu
+    \\left[\\begin{array}… ne matche pas le widget). Si champ unique matrice :
+    variable calculée avec latex(M, mat_delim='', mat_str='pmatrix') (FR)
+    ou mat_str='bmatrix' (EN), injectée nue.
+  • Dimension variable ⇒ repli MCQ pour cette question.
+
+L'ÉNONCÉ NE DONNE JAMAIS LA RÉPONSE (l'énoncé définit, la question interroge).
+"""  # noqa: E501 — texte normatif verbatim (valeur injectée telle quelle, accolades SIMPLES)
+
+# Prompt de génération d'une déclinaison (QCM ou QAT) — même mécanique par
+# paires que la pythonisation ; le champ {decl_spec} reçoit MCQ_SPEC ou FGQ_SPEC.
+STEP_DECLINAISON_PROMPT = """\
+Tu déclines un exercice PyxiScience MyST en version {decl_label}, niveau {niveau}.
+L'exercice source (statique OU déjà pythonisé) est fourni ; tu produis la
+déclinaison RANDOMISÉE (bloc Python terminé par `globals()` + injections),
+au format plateforme EXACT ci-dessous.
+
+═══════════════════════════════════════════════════════════════════════════
+ CONVENTIONS PLATEFORME (identiques à la pythonisation — NON NÉGOCIABLES)
+═══════════════════════════════════════════════════════════════════════════
+  • Bloc Python : 4 backticks ````{{python}} … ```` terminé par `globals()`.
+  • Injections `{{{{ }}}}` : UNIQUEMENT des noms de variables NUS camelCase
+    suffixe `Aff` — JAMAIS d'appel de fonction, de calcul, d'underscore, ni
+    d'accès dict. Tout se pré-calcule dans le bloc Python.
+  • `{{{{ }}}}` et les maths TOUJOURS HORS des rôles {{fr}}`…`{{en}}`…` (un
+    placeholder dans un rôle ne s'évalue PAS — texte cassé).
+  • Règle du `$` collé à un chiffre : préfixe `${{}}`. Décimales localisées
+    (virgule FR / point EN). `latex(expr, **config_standard)`.
+  • `:questionId:`/`:questionIndex:` contigus dès 0.
+  • Interdits : \\py{{}}, \\qcm, \\qat, \\qcl, \\right/\\wrong (légacy),
+    \\begin{{align*}}, \\displaystyle, \\[ \\], $$.
+
+FIDÉLITÉ À LA SOURCE :
+  • 1 question source → 1 question déclinée. NE JAMAIS inventer de
+    sous-questions ni enrichir l'énoncé.
+  • L'énoncé ne doit JAMAIS donner la réponse (l'énoncé définit, la question
+    interroge).
+  • detailedSolution : VERBATIM de la source si elle existe (seules les valeurs
+    littérales deviennent des {{{{varAff}}}}), sinon rédigée sobrement.
+  • Source DÉJÀ PYTHONISÉE : recopie son bloc Python À L'IDENTIQUE (octet pour
+    octet), puis ajoute `# === Ajouts déclinaison {decl_label} ===` suivi des
+    NOUVELLES variables (distracteurs/solutions), AVANT le `globals()` final.
+  • weightDistribution : repris de la question source si présent, sinon le
+    barème par défaut du format ci-dessous (somme = 100 TOUJOURS).
+
+═══════════════════════════════════════════════════════════════════════════
+ SPÉCIFICATION DU FORMAT {decl_label}
+═══════════════════════════════════════════════════════════════════════════
+{decl_spec}
+
+═══════════════════════════════════════════════════════════════════════════
+ EXEMPLE CANONIQUE COMPLET (structure et conventions à imiter)
+═══════════════════════════════════════════════════════════════════════════
+{fewshot}
+
+═══════════════════════════════════════════════════════════════════════════
+ CATALOGUE PyxiScience (helpers à utiliser DANS le bloc Python)
+═══════════════════════════════════════════════════════════════════════════
+{functions}
+
+═══════════════════════════════════════════════════════════════════════════
+ CONTEXTE
+═══════════════════════════════════════════════════════════════════════════
+
+EN-TÊTE déjà finalisé (NE PAS reproduire) :
+{content}
+
+VARIABLES DÉTECTÉES :
+{analysis}
+
+BLOCS PRÉCÉDENTS (ne pas redéfinir leurs variables, ne pas les répéter) :
+{previous_blocks}
+
+SECTION À DÉCLINER ({range_label} / {nb_total}) :
+{current_segment}
+
+{lang_directive}
+
+═══════════════════════════════════════════════════════════════════════════
+ RÈGLES D'ASSEMBLAGE PAR PAIRE
+═══════════════════════════════════════════════════════════════════════════
+⚠️ TU PRODUIS UNIQUEMENT LE CONTENU DE CETTE PAIRE (les paires précédentes
+sont concaténées mécaniquement avant ta sortie).
+⚠️ EXACTEMENT {nb_current} bloc(s) `:::::{{question}}` — questionId/questionIndex
+CONTINUS depuis la paire précédente.
+⚠️ PAIRE 1 UNIQUEMENT : le bloc ````{{python}}```` (source recopiée si déjà
+pythonisée + ajouts déclinaison + `globals()`) puis l'énoncé général VERBATIM,
+AVANT la première question.
+⚠️ PAIRES SUIVANTES : ni énoncé, ni ré-imports ; petit bloc ````{{python}}````
+additionnel possible pour les nouvelles variables seulement.
+
+═══════════════════════════════════════════════════════════════════════════
+ CHECKLIST FINALE
+═══════════════════════════════════════════════════════════════════════════
+  □ Bloc ````{{python}}```` (4 backticks) terminé par `globals()`
+  □ CHAQUE `{{{{ }}}}` = variable NUE camelCase (Aff) — aucun appel/underscore
+  □ Aucun `{{{{ }}}}` NI maths à l'intérieur d'un rôle {{fr}}`…`/{{en}}`…`
+  □ MCQ : 1 seule bonne réponse (slot 1), « None » en dernier, options toutes
+    distinctes SUR TOUTES LES GRAINES, formatage identique
+  □ FGQ : arité #input == #valeurs == #tolérances ("0"), :solution: littérale,
+    ordre énoncé/"ord"/displayedSolution cohérents, labels devant chaque {{input}}
+  □ 1 question source → 1 question ; solutions source VERBATIM ; poids repris
+  □ IDs contigus dès 0 ; aucun motif interdit ; `\\%` pour les pourcentages
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Réparation post-harnais (NOUVEAU — 1 itération max)
+# ─────────────────────────────────────────────────────────────────────────────
+REPAIR_PROMPT = """\
+Le harnais de validation PyxiScience a REJETÉ l'exercice pythonisé ci-dessous.
+Corrige-le en changeant LE MINIMUM (ne réécris pas l'exercice, ne reformule
+aucune prose, ne change pas la structure ni les poids).
+
+ÉCHECS DU HARNAIS :
+{failures}
+
+EXERCICE ACTUEL :
+{exercise}
+
+RÈGLES DE CORRECTION :
+  • Exception à l'exécution → corrige le bloc Python (tirage dégénéré, import
+    manquant, division par zéro…) par la modification la plus locale possible.
+  • Variable non résolue `{{{{x}}}}` → définis-la dans le bloc Python (avant
+    `globals()`) ou corrige le nom injecté.
+  • Motif interdit `$`+chiffre → préfixe `${{}}`.
+  • **Double signe `+ -`** (cas le plus fréquent) : un `+` littéral du texte
+    est suivi d'une injection qui rend une valeur NÉGATIVE (ex.
+    `… + {{{{dfAff}}}}` avec dfAff = "- 4 \\sin(4x)"). Correctif : supprimer le
+    `+` littéral ET pré-calculer la chaîne SIGNÉE dans le bloc Python
+    (`dfSignAff = latex(df, **config_standard)` rend déjà le signe ; ou
+    construire `"+ …"`/`"- …"` selon le signe) puis injecter
+    `… {{{{dfSignAff}}}}` sans opérateur devant.
+  • **`\\frac{{…}}{{1}}` / `^{{1}}` / `^{{0}}` / `\\sqrt[2]`** : presque toujours un
+    TIRAGE DÉGÉNÉRÉ — exclure la valeur fautive à la source
+    (ex. `b = rd.randint(2, 5)` au lieu de `randint(1, 5)`, ou boucle de rejet
+    `if b == 1: continue`). Ne PAS rafistoler le texte : corriger le tirage.
+    **EXCEPTION — texte pédagogique FIXE** qui enseigne précisément la règle de
+    l'exposant (`$b^{{0}} = 1$`, `$b^{{1}} = b$`) : réécrire SANS accolades
+    (`$b^0 = 1$`, `$b^1 = b$`) — rendu LaTeX identique pour un exposant à un
+    seul caractère, et conforme au corpus validé.
+  • Injection non nue → pré-calculer en variable camelCase `…Aff`.
+  • Le bloc {{python}} reste à 4 backticks et se termine par `globals()`.
+  • Ne touche NI à `\\inftys`/`\\ds`/`\\dfrac`, NI à la prose des solutions.
+  • **QCM — collision d'options** (deux options rendues identiques sur une
+    graine) : contraindre le TIRAGE (rejet `while` sur les chaînes rendues) ou
+    changer la CONSTRUCTION du distracteur — jamais rafistoler le texte.
+  • **QCM — plusieurs/zéro `:isRightAnswer: true`** : exactement une, en slot 1.
+  • **FGQ — arité** : le nb de {{{{input}}}} doit égaler le nb de valeurs de
+    `"ord"` et le nb de tolérances ("0") dans `:solution:`.
+  • **`{{{{ }}}}` dans un rôle {{fr}}`…`/{{en}}`…`** : sortir l'injection du
+    rôle (elle ne s'évalue pas dedans) — découper le rôle autour.
+
+Réponds UNIQUEMENT avec l'exercice complet corrigé (de `````{{exercise}} à `````),
+sans préambule ni wrapper markdown.
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AUDIT PÉDAGOGIQUE (2026-07-06) — juge la QUALITÉ (au-delà du harnais mécanique).
+# Le harnais prouve la conformité structurelle ; ce juge évalue la finesse
+# pédagogique et le RESPECT DES CONSIGNES (distracteurs cohérents, indevinabilité,
+# énoncé qui ne donne pas la réponse…). Peut déclencher une réparation ciblée et,
+# en mode auto, une escalade de modèle.
+# ─────────────────────────────────────────────────────────────────────────────
+
+PEDAGOGICAL_AUDIT_PROMPT = """\
+Tu es un RELECTEUR PÉDAGOGIQUE senior de PyxiScience. On te donne une déclinaison
+{decl_label} DÉJÀ VALIDE au harnais (structure/exécution correctes). Juge
+UNIQUEMENT sa QUALITÉ PÉDAGOGIQUE et le respect des consignes — jamais la syntaxe.
+
+CRITÈRES QCM (les plus importants) :
+  1. Distracteurs = ERREURS RÉELLES plausibles d'un élève (signe mal lu sur une
+     entrée, transposée, terme oublié, off-by-one…), JAMAIS des valeurs
+     artificielles ou au hasard, JAMAIS des variantes « une seule chose à la
+     fois » autour de la bonne réponse.
+  2. INDEVINABILITÉ — la bonne réponse ne doit PAS se repérer par la FORME :
+     • pas un bloc identique figé pendant qu'un seul varie (ex. matrice A figée,
+       seul b change) ; • pas d'étiquette qui trahit (« linear », « b=0 ») ;
+     • pas la seule simplifiée / avec radical / la plus longue ou courte ;
+     • pas de parenthèse ou exemple explicatif sur la SEULE bonne réponse ;
+     • distracteurs en grille symétrique (signe×signe, ordre×signe).
+  3. L'ÉNONCÉ ne donne JAMAIS la réponse ; formulation DIRECTE (retirer « montre
+     que », « calcule de deux façons », « trace », « justifie »).
+  4. questionHint = amorce de méthode qui NE révèle PAS la réponse.
+  5. Format IDENTIQUE entre toutes les options (longueur, style LaTeX, notation).
+  6. Fidélité à la source : mêmes notions testées, solution cohérente.
+
+CRITÈRES QAT/FGQ : champs {{input}} pertinents et bien placés ; displayedSolution
+lisible ; énoncé qui ne donne pas la réponse ; consignes de saisie claires.
+
+EXERCICE À JUGER :
+{exercise}
+
+Réponds UNIQUEMENT en JSON (aucune prose autour, aucun bloc markdown) :
+{{"verdict": "OK ou A_REVOIR", "score": 0-100, "issues": [{{"gravite": "haute|moyenne|basse", "ou": "question/option concernée", "probleme": "ce qui cloche", "correction": "quoi faire concrètement"}}]}}
+Règles de verdict : « OK » seulement si AUCUNE issue de gravité haute. Sois
+EXIGEANT mais JUSTE — signale un vrai défaut d'apprentissage, pas une préférence
+de style. Si l'exercice est bon, renvoie verdict « OK » et issues [].
+"""  # noqa: E501
+
+PEDAGOGICAL_REPAIR_PROMPT = """\
+Un relecteur pédagogique a listé des défauts de QUALITÉ sur cette déclinaison
+{decl_label}. La STRUCTURE est déjà correcte (harnais VERT) — NE LA CASSE PAS.
+Corrige UNIQUEMENT les défauts listés, avec le minimum de changements.
+
+DÉFAUTS À CORRIGER :
+{issues}
+
+CONTRAINTES DURES (ne rien casser) :
+  • Ne touche PAS à la structure MyST, aux IDs, aux poids, au format des blocs.
+  • UN SEUL bloc {{python}} (4 backticks) terminé par `globals()` ; les
+    distracteurs restent construits DANS ce bloc (variables camelCase `…Aff`),
+    à DELTA NON NUL garanti (jamais de flip de signe sur une entrée nulle).
+  • Exactement UNE `:isRightAnswer: true`, en slot 1 ; « None » en dernier.
+  • L'énoncé ne révèle JAMAIS la réponse ; garde la solution fidèle à la source.
+  • Injections `{{{{ }}}}` = noms de variables nus camelCase `Aff` uniquement.
+
+EXERCICE ACTUEL :
+{exercise}
+
+Réponds UNIQUEMENT avec l'exercice complet corrigé (de `````{{exercise}} à `````),
+sans préambule ni wrapper markdown.
+"""  # noqa: E501

smoke.py

@@ -0,0 +1,581 @@
+"""
+Smoke tests minimaux — AUCUN appel réseau (LLM mocké), exécution :
+
+    .venv/bin/python tests/smoke.py
+
+Couvre : import/create_app, /health, 1 run de pipeline complet (mock LLM)
+avec porte harnais VERTE, et les filets déterministes clés.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+PASS = []
+
+
+def check(name, cond):
+    PASS.append((name, bool(cond)))
+    print(("✓" if cond else "✗"), name)
+
+
+# ── 1. Import + /health ──────────────────────────────────────────────────────
+from app import create_app  # noqa: E402
+
+flask_app = create_app()
+client = flask_app.test_client()
+health = client.get("/health").get_json()
+check("create_app + /health", health and health["status"] == "ok")
+models = client.get("/api/models").get_json()
+check("/api/models expose le roster", len(models["models"]) >= 5)
+
+# ── 2. Filets déterministes ──────────────────────────────────────────────────
+from app.pipeline import postprocess as pp  # noqa: E402
+
+t, _ = pp.fix_dollar_digit("Prix : $3$ et ${{nAff}}$.")
+check("fix_dollar_digit", "${}3$" in t and "${}{{nAff}}$" in t)
+check("detect_languages both", pp.detect_languages("{fr}`Calculer`{en}`Compute` $x$") == "both")
+check("strip_language fr", pp.strip_language("{fr}`Bonjour `{en}`Hello `", "fr").strip() == "Bonjour")
+
+# ── 3. Pipeline complet avec LLM mocké ───────────────────────────────────────
+SMOKE_SOURCE = """`````{exercise}
+:title: Somme de deux entiers
+:level: Elementary
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: STQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Calculer $3 + 4$.
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{detailedSolution}
+On trouve $7$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::
+`````"""
+
+MOCK_ANALYSIS = json.dumps({
+    "exercise_type": "équation linéaire",
+    "exercise_title": "Somme de deux entiers",
+    "nb_questions": 1,
+    "variables": [{"nom": "a", "type_python": "int", "description": "1er terme",
+                   "contraintes": "2..9", "plage_python": "rd.randint(2, 9)",
+                   "location": "énoncé", "valeur_exemple": "3"}],
+    "needs_fraction": False, "needs_sympy": False, "needs_numpy": False,
+    "needs_matplolib": False,   # typo v1 volontaire : doit être normalisée
+    "target_rules": [], "property_constraints": [],
+    "has_validated_solution_in_input": False,
+})
+
+MOCK_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: STQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Calculer ${}{{a}} + {{b}}$.
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::"""
+
+
+MOCK_MCQ_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+d1Aff = str(a + b + 1)      # erreur type : +1
+d2Aff = str(a + b - 1)      # erreur type : -1
+d3Aff = str(a * b + 100)    # produit décalé — toujours > somme+1 (distinct)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: MCQ
+:questionId: 0
+:questionIndex: 0
+
+::::{questionStatement}
+Combien vaut ${}{{a}} + {{b}}$ ?
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: true
+${}{{sumAff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d1Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d2Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+${}{{d3Aff}}$
+::::
+
+::::{mcqAnswer}
+:isRightAnswer: false
+{fr}`Aucune de ces réponses n'est correcte`{en}`None of these answers are correct`
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 25
+:abstraction: 25
+:reasoning: 25
+:calculation: 25
+::::
+:::::"""
+
+MOCK_FGQ_PAIR = """````{python}
+import random as rd
+a = rd.randint(2, 9)
+b = rd.randint(2, 9)
+sumAff = str(a + b)
+globals()
+````
+
+On additionne deux entiers.
+
+:::::{question}
+:questionType: FGQ
+:questionId: 0
+:questionIndex: 0
+:solution: [["ord","${{sumAff}}$"],["0"]]
+
+::::{questionStatement}
+Calculer ${}{{a}} + {{b}}$.
+
+$s =$ {input}`||110`
+::::
+
+::::{questionHint}
+Poser l'addition.
+::::
+
+::::{displayedSolution}
+$s = {{sumAff}}$
+::::
+
+::::{detailedSolution}
+On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
+::::
+
+::::{weightDistribution}
+:logic: 15
+:abstraction: 20
+:reasoning: 20
+:calculation: 45
+::::
+:::::"""
+
+ANALYSIS_CALLS = {"n": 0}
+
+
+GEN_MODELS_SEEN = []          # IDs de modèle vus par les appels de génération
+
+
+def mock_llm(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
+             image_b64=None, system_prompt="", reasoning=False, model=None):
+    if "expert en analyse d'exercices" in prompt:
+        ANALYSIS_CALLS["n"] += 1
+        return MOCK_ANALYSIS
+    if "auditeur PyxiScience" in prompt:
+        return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:            # audit pédagogique
+        PEDAGO_CALLS["n"] += 1
+        return json.dumps({"verdict": "OK", "score": 95, "issues": []})
+    if "Tu déclines un exercice" in prompt:
+        GEN_MODELS_SEEN.append(model)
+        return MOCK_MCQ_PAIR if "QCM (MCQ)" in prompt else MOCK_FGQ_PAIR
+    if "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt:
+        GEN_MODELS_SEEN.append(model)
+        return MOCK_PAIR
+    return "{}"
+
+
+PEDAGO_CALLS = {"n": 0}
+
+
+import app.pipeline.analyze as analyze  # noqa: E402
+import app.pipeline.audit as audit  # noqa: E402
+import app.pipeline.generate as generate  # noqa: E402
+import app.pipeline.orchestrator as orchestrator  # noqa: E402
+
+analyze.process_with_openrouter = mock_llm
+audit.process_with_openrouter = mock_llm
+generate.process_with_openrouter = mock_llm
+orchestrator.process_with_openrouter = mock_llm
+analyze.enrich_exercise_with_notions = lambda *a, **k: ("(notions mockées)", "NOTION_TEST")
+analyze.retrieve_functions_context = lambda **k: {"catalogue": "(catalogue mocké)"}
+
+result = orchestrator.run_exercise(
+    content=SMOKE_SOURCE, filename="smoke.md", level="", model_idx=0, lang="fr")
+
+check("pipeline : exercice produit", bool(result["exercise"].strip()))
+check("pipeline : fence 4 backticks", "````{python}" in result["exercise"])
+check("pipeline : se termine par `````", result["exercise"].rstrip().endswith("`````"))
+check("pipeline : globals() présent", "globals()" in result["exercise"])
+check("pipeline : typo needs_matplolib normalisée",
+      "needs_matplolib" not in result["analysis"] and result["analysis"]["needs_matplotlib"] is False)
+check("pipeline : harnais VERT", result["harness"]["ok"])
+check("pipeline : coût exposé", "usd" in result["cost"])
+check("pipeline : langue exposée", result["lang"]["target"] == "fr")
+
+# En-tête {exercise} complet et bien formé
+ex = result["exercise"]
+check("header : enveloppe `````{exercise} en tête", ex.lstrip().startswith("`````{exercise}"))
+for field in (":id:", ":title:", ":modules:", ":recommendedExecutionTime:",
+              ":level:", ":chap:", ":involvedConcepts:", ":originalSource:", ":visibility:"):
+    check(f"header : champ {field} présent", field in ex.split("````{python}")[0])
+check("header : level mappé (level='' → Elementary)", ":level: Elementary" in ex)
+check("header : visibility All", ":visibility: All" in ex)
+check("header : concepts = notions", "NOTION_TEST" in ex)
+check("header : une seule enveloppe {exercise}", ex.count("`````{exercise}") == 1)
+
+# ── 3bis. Mode déclinaisons (QCM + QAT, LLM mocké, analyse partagée) ─────────
+ANALYSIS_CALLS["n"] = 0
+PEDAGO_CALLS["n"] = 0
+decl_results = orchestrator.run_declinaisons(
+    content=SMOKE_SOURCE, filename="smoke.md", level="", model_idx=0,
+    lang="fr", types=["qcm", "qat"])
+check("déclinaisons : 2 sorties (QCM + QAT)", len(decl_results) == 2)
+check("déclinaisons : analyse partagée (1 seul appel)", ANALYSIS_CALLS["n"] == 1)
+check("audit pédagogique : appelé (QCM + QAT)", PEDAGO_CALLS["n"] >= 2)
+
+qcm = dict(decl_results)["qcm"]
+qat = dict(decl_results)["qat"]
+check("QCM : harnais VERT", qcm["harness"]["ok"])
+check("QCM : 5 options, 1 seule bonne", qcm["exercise"].count("{mcqAnswer}") == 5
+      and qcm["exercise"].count(":isRightAnswer: true") == 1)
+check("QCM : « None » en dernière option",
+      "Aucune de ces réponses" in qcm["exercise"].split(":isRightAnswer: false")[-1])
+check("QCM : titre suffixé - MCQ", " - MCQ" in qcm["exercise"].split("````{python}")[0])
+check("QAT : harnais VERT", qat["harness"]["ok"])
+check("QAT : :solution: + {input} présents",
+      ':solution: [["ord"' in qat["exercise"] and "{input}`" in qat["exercise"])
+check("QAT : displayedSolution présent", "{displayedSolution}" in qat["exercise"])
+check("déclinaisons : decl_type exposé", qcm["decl_type"] == "qcm" and qat["decl_type"] == "qat")
+check("audit pédagogique : verdict exposé (QCM)",
+      isinstance(qcm.get("pedagogical"), dict) and qcm["pedagogical"]["verdict"] == "OK")
+
+# Audit pédagogique ROUGE → escalade en mode auto (harnais VERT mais qualité A_REVOIR).
+_ped_calls = {"n": 0}
+
+
+def mock_llm_pedago_escalade(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
+                             image_b64=None, system_prompt="", reasoning=False, model=None):
+    if "expert en analyse d'exercices" in prompt:
+        return MOCK_ANALYSIS
+    if "auditeur PyxiScience" in prompt:
+        return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:
+        _ped_calls["n"] += 1
+        # Échelon 1 : audit + post-réparation restent A_REVOIR (2 appels) → la
+        # réparation n'améliore pas, donc ESCALADE. Échelon 2+ : qualité OK.
+        if _ped_calls["n"] <= 2:
+            return json.dumps({"verdict": "A_REVOIR", "score": 40, "issues": [
+                {"gravite": "haute", "ou": "Q0", "probleme": "distracteur devinable",
+                 "correction": "grille miroir"}]})
+        return json.dumps({"verdict": "OK", "score": 92, "issues": []})
+    if "défauts de QUALITÉ" in prompt:            # réparation pédagogique → sortie VERTE mais non améliorée
+        return MOCK_MCQ_PAIR
+    if "Tu déclines un exercice" in prompt or "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt:
+        return MOCK_MCQ_PAIR
+    return "{}"
+
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm_pedago_escalade
+_sols_p = __import__("app.pipeline.solutions", fromlist=["x"])
+_tr_p = __import__("app.pipeline.translate", fromlist=["x"])
+_sols_p.process_with_openrouter = mock_llm_pedago_escalade
+_tr_p.process_with_openrouter = mock_llm_pedago_escalade
+
+res_ped = orchestrator.run_with_policy(
+    content=SMOKE_SOURCE, filename="ped.md", lang="fr", policy="auto", decl_type="qcm")
+tel_ped = res_ped["policy_telemetry"]
+check("escalade pédagogique : ≥2 échelons tentés", len(tel_ped["tried"]) >= 2)
+check("escalade pédagogique : 1er échelon qualité A_REVOIR",
+      tel_ped["tried"][0]["pedago"] == "A_REVOIR")
+check("escalade pédagogique : gagnant qualité OK",
+      tel_ped["pedago_verdict"] == "OK" and not tel_ped["needs_review"])
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm
+_sols_p.process_with_openrouter = mock_llm
+_tr_p.process_with_openrouter = mock_llm
+
+# Harnais étendu : un MCQ avec collision d'options doit être ROUGE.
+from app.validation import harness as _harness  # noqa: E402
+
+_collision = qcm["exercise"].replace("{{d1Aff}}", "{{sumAff}}")   # distracteur == bonne réponse
+_rep = _harness.validate_text(_collision, seeds=10)
+check("harnais étendu : collision d'options MCQ détectée (ROUGE)",
+      not _rep["ok"] and _rep["n_mcq_collisions"] > 0)
+_two_true = qcm["exercise"].replace(":isRightAnswer: false", ":isRightAnswer: true", 1)
+_rep2 = _harness.validate_text(_two_true, seeds=5)
+check("harnais étendu : 2 bonnes réponses détectées (statique)",
+      not _rep2["ok"] and any("isRightAnswer" in e for e in _rep2["static_errors"]))
+_bad_arity = qat["exercise"].replace('[["ord","${{sumAff}}$"],["0"]]',
+                                     '[["ord","${{sumAff}}$","$2$"],["0","0"]]')
+_rep3 = _harness.validate_text(_bad_arity, seeds=5)
+check("harnais étendu : arité FGQ incohérente détectée",
+      not _rep3["ok"] and any("arité" in e for e in _rep3["static_errors"]))
+
+# Validation API du mode (sans lancer de job).
+r_bad_mode = client.post("/api/jobs", json={"content": "x", "mode": "zzz"})
+check("API : mode invalide → 400", r_bad_mode.status_code == 400)
+r_no_types = client.post("/api/jobs", json={"content": "x", "mode": "declinaisons", "types": {}})
+check("API : declinaisons sans type → 400", r_no_types.status_code == 400)
+
+# ── 3ter. Politiques de modèle + escalade + retrait de Fable ────────────────
+from app.models.catalog import CATALOG, CANDIDATES  # noqa: E402
+from app.models import policy as _mp  # noqa: E402
+
+check("Fable absent du catalogue",
+      not any("fable" in k.lower() for k in CATALOG)
+      and not any("fable" in v["openrouter_id"].lower() for v in CATALOG.values()))
+from app.config import AVAILABLE_MODELS as _AM  # noqa: E402
+check("Fable absent d'AVAILABLE_MODELS",
+      not any("fable" in v.lower() for v in _AM.values()))
+check("Fable absent du fallback policy",
+      not any("fable" in str(_mp.DEFAULT_RECOMMENDED).lower() for _ in [0]))
+
+# best / cheap / manual suivent recommended.json (source VIVANTE : le banc la
+# réécrit — on vérifie la cohérence de la résolution, pas des noms figés).
+_rec_gen = _mp.load_recommended()["generate"]
+check("policy best suit recommended.json",
+      _mp.resolve("generate", "best") == _rec_gen["best"])
+check("policy cheap suit recommended.json",
+      _mp.resolve("generate", "cheap") == _rec_gen["cheap"])
+check("policy manual respecté",
+      _mp.resolve("generate", "manual", {"generate": "deepseek-v4-pro"}) == "deepseek-v4-pro")
+check("difficulté : matrices → difficile",
+      _mp.classify_difficulty("Matrix systeme " * 100 + ":::::{question}" * 6) == "difficile")
+
+# Escalade : 1er échelon forcé ROUGE (options en collision) → échelon 2 VERT.
+MOCK_MCQ_RED = MOCK_MCQ_PAIR.replace("{{d1Aff}}", "{{sumAff}}")
+_calls = {"n": 0}
+
+
+def mock_llm_escalade(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
+                      image_b64=None, system_prompt="", reasoning=False, model=None):
+    if "expert en analyse d'exercices" in prompt:
+        return MOCK_ANALYSIS
+    if "auditeur PyxiScience" in prompt:
+        return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:   # qualité OK → escalade pilotée par le harnais seul
+        return json.dumps({"verdict": "OK", "score": 95, "issues": []})
+    if "harnais" in prompt and "REJETÉ" in prompt:
+        return MOCK_MCQ_RED          # la réparation échoue aussi sur l'échelon 1
+    if "Tu déclines un exercice" in prompt or "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt:
+        _calls["n"] += 1
+        # 1re GÉNÉRATION (échelon 1) rouge ; la suivante (échelon 2) verte.
+        return MOCK_MCQ_RED if _calls["n"] <= 1 else MOCK_MCQ_PAIR
+    return "{}"
+
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm_escalade
+import app.pipeline.solutions as _sols  # noqa: E402
+import app.pipeline.translate as _tr  # noqa: E402
+_sols.process_with_openrouter = mock_llm_escalade
+_tr.process_with_openrouter = mock_llm_escalade
+
+res_esc = orchestrator.run_with_policy(
+    content=SMOKE_SOURCE, filename="esc.md", lang="fr",
+    policy="auto", decl_type="qcm")
+tel = res_esc["policy_telemetry"]
+check("escalade : ≥2 échelons tentés", len(tel["tried"]) >= 2)
+check("escalade : échelon 1 ROUGE puis gagnant VERT",
+      tel["tried"][0]["ok"] is False and tel["tried"][-1]["ok"] is True)
+check("escalade : échelon gagnant journalisé",
+      tel["winning_model"] == tel["tried"][-1]["model"] and not tel["needs_review"])
+
+# Restaure les mocks standards pour la suite.
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm
+_sols.process_with_openrouter = mock_llm
+_tr.process_with_openrouter = mock_llm
+
+# API : policy invalide → 400 ; manual avec modèle hors rôle → 400.
+check("API : policy invalide → 400",
+      client.post("/api/jobs", json={"content": "x", "policy": "zzz"}).status_code == 400)
+check("API : manual modèle hors rôle → 400",
+      client.post("/api/jobs", json={"content": "x", "policy": "manual",
+                                     "models": {"generate": "glm-4-7-flash"}}).status_code == 400)
+check("/api/models expose catalogue par rôle sans Fable",
+      "fable" not in json.dumps(client.get("/api/models").get_json()).lower())
+
+# ── 3quater. Aération, originalExerciseId, annulation (bouton Stop) ─────────
+from app.pipeline.postprocess import aerate_blocks  # noqa: E402
+
+_compact = (":::::{question}\n:questionType: MCQ\n::::{questionStatement}\n"
+            "texte\n::::\n::::{mcqAnswer}\n:isRightAnswer: true\nx\n::::")
+_aered, _n_aer = aerate_blocks(_compact)
+check("aération : lignes vides avant chaque bloc",
+      _n_aer == 2 and "\n\n::::{questionStatement}" in _aered
+      and "\n\n::::{mcqAnswer}" in _aered)
+check("aération : idempotente", aerate_blocks(_aered)[1] == 0)
+
+from app.pipeline.generate import build_exercise_metadata  # noqa: E402
+
+check("déclinaison : originalExerciseId = id du QST source",
+      ":originalExerciseId: abc-123" in build_exercise_metadata(
+          ":id: abc-123\n:title: T", "", {}, "", decl_type="qcm"))
+check("déclinaison : originalExerciseId présent même sans id source",
+      "\n:originalExerciseId:" in build_exercise_metadata(
+          ":title: T", "", {}, "", decl_type="qcm"))
+check("pythonise : pas d'originalExerciseId",
+      "originalExerciseId" not in build_exercise_metadata(
+          ":title: T", "", {}, "", decl_type=None))
+
+# Annulation : job 3 fichiers avec mock LENT, cancel immédiat → cancelled.
+check("annulation : job inconnu → 404",
+      client.post("/api/jobs/zzz/cancel").status_code == 404)
+
+import time as _time  # noqa: E402
+
+
+def mock_llm_slow(*a, **k):
+    _time.sleep(0.15)
+    return mock_llm(*a, **k)
+
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm_slow
+_sols.process_with_openrouter = mock_llm_slow
+_tr.process_with_openrouter = mock_llm_slow
+
+_rc_start = client.post("/api/jobs", json={
+    "files": [{"filename": f"c{i}.md", "content": SMOKE_SOURCE} for i in range(3)]})
+_jid_c = _rc_start.get_json()["job_id"]
+check("annulation : cancel accepté (202)",
+      client.post(f"/api/jobs/{_jid_c}/cancel").status_code == 202)
+_st_c = None
+for _ in range(400):
+    _st_c = client.get(f"/api/jobs/{_jid_c}").get_json()
+    if _st_c["status"] != "running":
+        break
+    _time.sleep(0.05)
+check("annulation : statut final cancelled", _st_c["status"] == "cancelled")
+check("annulation : arrêt anticipé (résultats partiels conservés)",
+      _st_c["files_done"] < 3 and isinstance(_st_c["results"], list))
+check("annulation : re-cancel d'un job terminé → 409",
+      client.post(f"/api/jobs/{_jid_c}/cancel").status_code == 409)
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm
+_sols.process_with_openrouter = mock_llm
+_tr.process_with_openrouter = mock_llm
+
+# Banc : --dry-run (plomberie complète hors ligne).
+import subprocess  # noqa: E402
+
+bench_proc = subprocess.run(
+    [sys.executable, "-m", "bench", "run", "--dry-run",
+     "--roles", "generate", "--models", "claude-sonnet-5,claude-opus-4-8",
+     "--seeds", "5"],
+    capture_output=True, text=True, timeout=600,
+    cwd=str(Path(__file__).resolve().parent.parent),
+)
+check("bench --dry-run : exit 0", bench_proc.returncode == 0)
+check("bench --dry-run : reco produite", "best=" in bench_proc.stdout)
+check("bench --dry-run : recommended.json non modifié",
+      "NON modifié" in bench_proc.stdout)
+
+# ── 4. Téléchargement ZIP (endpoint, sans LLM) ───────────────────────────────
+import io as _io  # noqa: E402
+import zipfile as _zipfile  # noqa: E402
+
+import app.server as _server  # noqa: E402
+
+_fake = {
+    "status": "done", "step_label": "Terminé", "current_file": "b.md",
+    "files_total": 2, "files_done": 2, "error": None, "summary": {},
+    "results": [
+        {"filename": "a.md", "status": "done",
+         "result": {"exercise": result["exercise"], "warnings": [],
+                    "harness": {"ok": True, "seeds": 100}, "cost": {"usd": 0.01}}},
+        {"filename": "a.md", "status": "done",   # collision de nom volontaire
+         "result": {"exercise": "````{python}\nglobals()\n````\n`````", "warnings": [{}],
+                    "harness": {"ok": False, "seeds": 100}, "cost": {"usd": 0.02}}},
+        {"filename": "c.md", "status": "error", "error": "boom"},
+    ],
+}
+with _server._JOBS_LOCK:
+    _server._JOBS["smoketest"] = _fake
+resp = client.get("/api/jobs/smoketest/download")
+check("ZIP : 200 + mimetype zip", resp.status_code == 200 and "zip" in resp.mimetype)
+zf = _zipfile.ZipFile(_io.BytesIO(resp.data))
+names = zf.namelist()
+check("ZIP : 2 .md (collision dédupliquée) + récap",
+      "a_pythonise.md" in names and "a_pythonise_2.md" in names
+      and "_recapitulatif.md" in names)
+check("ZIP : 404 si job inconnu", client.get("/api/jobs/zzz/download").status_code == 404)
+
+# ── Bilan ────────────────────────────────────────────────────────────────────
+failed = [n for n, ok in PASS if not ok]
+print(f"\n{len(PASS) - len(failed)}/{len(PASS)} smoke tests verts")
+if failed:
+    print("ÉCHECS :", failed)
+    sys.exit(1)
+print("✅ SMOKE OK")

tests/gen_decl_sample.py

@@ -24,3 +24,13 @@ content = SRC.read_text(encoding="utf-8")
 out = Path(f"/tmp/decl_{decl}_sample.md")
 out.write_text(res["exercise"], encoding="utf-8")
 print(f"harnais : {'VERT' if res['harness']['ok'] else 'ROUGE'} → {out}")
+ped = res.get("pedagogical")
+if ped:
+    print(f"pédagogique : verdict={ped.get('verdict')} score={ped.get('score')} "
+          f"issues={len(ped.get('issues') or [])}")
+    for it in (ped.get("issues") or [])[:5]:
+        print(f"   - [{it.get('gravite')}] {it.get('ou')} : {it.get('probleme')}")
+tel = res.get("policy_telemetry")
+if tel:
+    print(f"policy : échelons={len(tel.get('tried') or [])} "
+          f"gagnant={tel.get('winning_model')} pédago={tel.get('pedago_verdict')}")

tests/smoke.py

@@ -239,6 +239,9 @@ def mock_llm(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
         return MOCK_ANALYSIS
     if "auditeur PyxiScience" in prompt:
         return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:            # audit pédagogique
+        PEDAGO_CALLS["n"] += 1
+        return json.dumps({"verdict": "OK", "score": 95, "issues": []})
     if "Tu déclines un exercice" in prompt:
         GEN_MODELS_SEEN.append(model)
         return MOCK_MCQ_PAIR if "QCM (MCQ)" in prompt else MOCK_FGQ_PAIR
@@ -248,6 +251,9 @@ def mock_llm(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
     return "{}"
 
 
+PEDAGO_CALLS = {"n": 0}
+
+
 import app.pipeline.analyze as analyze  # noqa: E402
 import app.pipeline.audit as audit  # noqa: E402
 import app.pipeline.generate as generate  # noqa: E402
@@ -286,11 +292,13 @@ check("header : une seule enveloppe {exercise}", ex.count("`````{exercise}") ==
 
 # ── 3bis. Mode déclinaisons (QCM + QAT, LLM mocké, analyse partagée) ─────────
 ANALYSIS_CALLS["n"] = 0
+PEDAGO_CALLS["n"] = 0
 decl_results = orchestrator.run_declinaisons(
     content=SMOKE_SOURCE, filename="smoke.md", level="", model_idx=0,
     lang="fr", types=["qcm", "qat"])
 check("déclinaisons : 2 sorties (QCM + QAT)", len(decl_results) == 2)
 check("déclinaisons : analyse partagée (1 seul appel)", ANALYSIS_CALLS["n"] == 1)
+check("audit pédagogique : appelé (QCM + QAT)", PEDAGO_CALLS["n"] >= 2)
 
 qcm = dict(decl_results)["qcm"]
 qat = dict(decl_results)["qat"]
@@ -305,6 +313,55 @@ check("QAT : :solution: + {input} présents",
       ':solution: [["ord"' in qat["exercise"] and "{input}`" in qat["exercise"])
 check("QAT : displayedSolution présent", "{displayedSolution}" in qat["exercise"])
 check("déclinaisons : decl_type exposé", qcm["decl_type"] == "qcm" and qat["decl_type"] == "qat")
+check("audit pédagogique : verdict exposé (QCM)",
+      isinstance(qcm.get("pedagogical"), dict) and qcm["pedagogical"]["verdict"] == "OK")
+
+# Audit pédagogique ROUGE → escalade en mode auto (harnais VERT mais qualité A_REVOIR).
+_ped_calls = {"n": 0}
+
+
+def mock_llm_pedago_escalade(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
+                             image_b64=None, system_prompt="", reasoning=False, model=None):
+    if "expert en analyse d'exercices" in prompt:
+        return MOCK_ANALYSIS
+    if "auditeur PyxiScience" in prompt:
+        return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:
+        _ped_calls["n"] += 1
+        # Échelon 1 : audit + post-réparation restent A_REVOIR (2 appels) → la
+        # réparation n'améliore pas, donc ESCALADE. Échelon 2+ : qualité OK.
+        if _ped_calls["n"] <= 2:
+            return json.dumps({"verdict": "A_REVOIR", "score": 40, "issues": [
+                {"gravite": "haute", "ou": "Q0", "probleme": "distracteur devinable",
+                 "correction": "grille miroir"}]})
+        return json.dumps({"verdict": "OK", "score": 92, "issues": []})
+    if "défauts de QUALITÉ" in prompt:            # réparation pédagogique → sortie VERTE mais non améliorée
+        return MOCK_MCQ_PAIR
+    if "Tu déclines un exercice" in prompt or "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt:
+        return MOCK_MCQ_PAIR
+    return "{}"
+
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm_pedago_escalade
+_sols_p = __import__("app.pipeline.solutions", fromlist=["x"])
+_tr_p = __import__("app.pipeline.translate", fromlist=["x"])
+_sols_p.process_with_openrouter = mock_llm_pedago_escalade
+_tr_p.process_with_openrouter = mock_llm_pedago_escalade
+
+res_ped = orchestrator.run_with_policy(
+    content=SMOKE_SOURCE, filename="ped.md", lang="fr", policy="auto", decl_type="qcm")
+tel_ped = res_ped["policy_telemetry"]
+check("escalade pédagogique : ≥2 échelons tentés", len(tel_ped["tried"]) >= 2)
+check("escalade pédagogique : 1er échelon qualité A_REVOIR",
+      tel_ped["tried"][0]["pedago"] == "A_REVOIR")
+check("escalade pédagogique : gagnant qualité OK",
+      tel_ped["pedago_verdict"] == "OK" and not tel_ped["needs_review"])
+
+for _m in (analyze, audit, generate, orchestrator):
+    _m.process_with_openrouter = mock_llm
+_sols_p.process_with_openrouter = mock_llm
+_tr_p.process_with_openrouter = mock_llm
 
 # Harnais étendu : un MCQ avec collision d'options doit être ROUGE.
 from app.validation import harness as _harness  # noqa: E402
@@ -365,6 +422,8 @@ def mock_llm_escalade(prompt, model_idx=0, temperature=0.0, max_tokens=4096,
         return MOCK_ANALYSIS
     if "auditeur PyxiScience" in prompt:
         return json.dumps({"verdict": "OK", "issues": []})
+    if "RELECTEUR PÉDAGOGIQUE" in prompt:   # qualité OK → escalade pilotée par le harnais seul
+        return json.dumps({"verdict": "OK", "score": 95, "issues": []})
     if "harnais" in prompt and "REJETÉ" in prompt:
         return MOCK_MCQ_RED          # la réparation échoue aussi sur l'échelon 1
     if "Tu déclines un exercice" in prompt or "RÈGLES D'ASSEMBLAGE PAR PAIRE" in prompt: