Politique de modeles multi-fournisseurs + retrait de Fable + durcissements

- app/models/: catalogue 16 modeles (IDs OpenRouter verifies 2026-07-02), client
route directe-ou-OpenRouter, policy auto/best/cheap/manual (pre-classifieur de
difficulte + escalade sur echec harnais, plafond MAX_ESCALADES), prix, et
recommended.json issu du banc reel (51 cellules role x modele x exo) :
generate/audit best=deepseek-v4-pro, mecanique best=mistral-small.
- claude-fable-5 retire volontairement de tout le code (catalog/config/UI/docs).
- UI : selecteur de politique + dropdowns par role (mode manuel), telemetrie
de routage (modele gagnant, echelons, difficulte, revue humaine).
- Durcissements : reponse LLM vide (content:null) -> retry puis erreur propre ;
harnais time-boxe par graine (10s, exec+rendu+scans, abandon apres 3
timeouts) ; escalade BaseException contre les try/except avaleurs ; cout
expose honnete (analyse partagee + echelons perdants inclus).
- Non-regression : pythonise (Exercice_1) et QAT verts a 300 graines.
- Smoke 61/61.

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

README_APP.md

@@ -94,6 +94,42 @@ Résultat par fichier : `exercise`, `analysis`, `notions`, `audit_patches`,
 écraser la source) ; en **batch**, bouton **« Tout (.zip) »** → ZIP de toutes
 les sorties + un `_recapitulatif.md` (verdict harnais / warnings / coût par fichier).
 
+## Politique de modèles & banc d'essai (2026-07)
+
+**4 politiques** (`policy` dans `POST /api/jobs`, sélecteur dans l'UI) :
+`auto` (défaut — pré-classifieur de difficulté, départ sur l'échelle par coût
+croissant, escalade d'un échelon à chaque échec harnais, plafonnée `best`) ·
+`best` (qualité max) · `cheap` (le moins cher qui tient `SEUIL_VERT=0.90`) ·
+`manual` (IDs explicites par rôle : `models {generate, audit, mecanique}`).
+Rôles : `generate` (+réparation), `audit`, `mecanique` (analyse, traduction,
+substitutions). Télémétrie de l'échelon gagnant dans `result.policy_telemetry`.
+**`claude-fable-5` est retiré de toutes les listes (choix volontaire).**
+
+**Clés API** : tout fonctionne avec la seule `OPENROUTER_API_KEY` (route de
+repli universelle). Clés directes optionnelles par fournisseur :
+`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`,
+`DEEPSEEK_API_KEY`, `MOONSHOT_API_KEY`, `ZAI_API_KEY`, `MINIMAX_API_KEY`,
+`MISTRAL_API_KEY` — un modèle sans aucune clé est « non testé », jamais bloquant.
+
+**Banc d'essai** :
+```bash
+python -m bench run                    # rôles/modèles dispo, corpus échantillonné
+python -m bench run --roles generate --models claude-sonnet-5,deepseek-v4-pro
+python -m bench run --exos all --types both --seuil 0.92
+python -m bench run --dry-run          # plomberie mockée (CI, aucune clé)
+python -m bench consolidate            # fusionne les runs partiels/parallèles
+```
+Sorties : `bench/results/<ts>.json|.csv|_rapport.md` + mise à jour de
+`app/models/recommended.json` (protégé par `manual_override: true`).
+Un run filtré `--models` n'écrit jamais recommended.json ; `consolidate`
+fusionne tous les résultats (la cellule la plus récente gagne, restreinte
+à l'échantillon courant du rôle) puis réécrit la recommandation globale.
+Plusieurs bancs peuvent tourner en parallèle (un processus = un compteur
+de coûts isolé) ; ne pas lancer d'autre job LLM dans le même processus.
+Corpus : `bench/corpus/*.md` (ajouter un exercice = y déposer un `.md`).
+Prix : `app/models/prices.json` — **à re-vérifier avant prod, ça change
+chaque semaine**.
+
 ## Sécurité
 
 🚨 **Les clés API dans `.env` étaient en clair dans le zip d'origine** —
@@ -108,8 +144,9 @@ modèle de menace est l'accident LLM, pas un adversaire).
 ## Notes
 
 - Premier lancement : reconstruit le cache FAISS si absent (≈ 30 s).
-- Modèles (IDs vérifiés sur OpenRouter 2026-06-12) : Opus 4.8, **Sonnet 4.6
-  (défaut)**, Fable 5, Haiku 4.5, Gemini 2.5 Pro, GPT-5.2.
+- Modèles (IDs vérifiés sur OpenRouter 2026-07-02) : Opus 4.8, **Sonnet 5
+  (défaut)**, Haiku 4.5, Gemini 2.5 Pro, GPT-5.4 — catalogue complet (16
+  modèles) dans `app/models/catalog.py`. Fable 5 retiré volontairement.
 - L'étape d'analyse suit le modèle choisi par l'utilisateur
   (`ANALYSIS_MODEL_IDX=None` dans config.py pour ce comportement).
 - Mode batch : fichiers traités séquentiellement ; un échec n'arrête pas les

app/config.py

@@ -25,16 +25,16 @@ TEMPLATES_DIR = PACKAGE_DIR / "web" / "templates"
 PYTHON_FENCE_BACKTICKS = 4
 EXERCISE_FENCE_BACKTICKS = 5
 
-# ── Modèles LLM (IDs vérifiés sur l'API OpenRouter le 2026-06-12) ────────────
+# ── 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-4.6",
-    2: "anthropic/claude-fable-5",
-    3: "anthropic/claude-haiku-4.5",
-    4: "google/gemini-2.5-pro",
-    5: "openai/gpt-5.2",
+    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-4.6
+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
@@ -47,16 +47,38 @@ ANALYSIS_MODEL_IDX: int | None = None
 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-06-12.
+# 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-4.6": {"input": 3.0,  "output": 15.0},
-    "anthropic/claude-fable-5":    {"input": 10.0, "output": 50.0},
-    "anthropic/claude-haiku-4.5":  {"input": 1.0,  "output": 5.0},
-    "google/gemini-2.5-pro":       {"input": 1.25, "output": 10.0},
-    "openai/gpt-5.2":              {"input": 1.75, "output": 14.0},
+    "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"

app/llm/client.py

@@ -47,11 +47,13 @@ class LLMClient:
             self._cost_tracker = get_cost_tracker()
         return self._cost_tracker
 
-    def call_llm(self, prompt: str, model_idx: int, temperature: float = 0.0,
+    def call_llm(self, prompt: str, model_idx: int = 0, temperature: float = 0.0,
                  max_tokens: int = 4096, system_prompt: str = SYSTEM_MSG,
-                 reasoning: bool = False) -> str:
-        """Appel LLM standard avec gestion des erreurs et retry."""
-        model = AVAILABLE_MODELS.get(model_idx)
+                 reasoning: bool = False, model: str | None = None) -> str:
+        """Appel LLM standard avec gestion des erreurs et retry.
+        `model` (ID OpenRouter en chaîne, ex. "anthropic/claude-sonnet-5")
+        court-circuite `model_idx` — c'est la voie de la policy par rôle."""
+        model = model or AVAILABLE_MODELS.get(model_idx)
         if model is None:
             raise ValueError(f"model_idx {model_idx} inexistant dans AVAILABLE_MODELS")
 
@@ -132,6 +134,14 @@ class LLMClient:
                     raise RuntimeError(f"API error : {data['error']}")
 
                 content = data["choices"][0]["message"]["content"]
+                # Certains fournisseurs renvoient content:null (réponse vide,
+                # reasoning seul…) : jamais exploitable en aval → retry, puis
+                # RuntimeError propre (gérée par les appelants) au lieu d'un
+                # AttributeError sur .strip().
+                if not isinstance(content, str) or not content.strip():
+                    raise RuntimeError(
+                        f"Réponse vide du modèle {payload['model']} "
+                        f"(content={content!r})")
                 generation_id = data.get("id")
                 return content, generation_id
 
@@ -155,12 +165,15 @@ def get_llm_client() -> LLMClient:
     return _llm_client
 
 
-def process_with_openrouter(prompt: str, model_idx: int, temperature: float = 0.0,
+def process_with_openrouter(prompt: str, model_idx: int = 0, temperature: float = 0.0,
                             max_tokens: int = 4096, image_b64: str = None,
-                            system_prompt: str = SYSTEM_MSG, reasoning: bool = False) -> str:
-    """Point d'entrée unique du pipeline pour tous les appels LLM."""
+                            system_prompt: str = SYSTEM_MSG, reasoning: bool = False,
+                            model: str | None = None) -> str:
+    """Point d'entrée unique du pipeline pour tous les appels LLM.
+    `model` (chaîne) prime sur `model_idx` (legacy)."""
     if image_b64:
         return get_llm_client().call_llm_multimodal(
             image_b64, prompt, model_idx, temperature, max_tokens, system_prompt)
     return get_llm_client().call_llm(
-        prompt, model_idx, temperature, max_tokens, system_prompt, reasoning=reasoning)
+        prompt, model_idx, temperature, max_tokens, system_prompt,
+        reasoning=reasoning, model=model)

app/models/catalog.py

@@ -0,0 +1,96 @@
+"""
+catalog.py — catalogue des modèles candidats par rôle. SANS Fable
+(claude-fable-5 retiré volontairement de toute liste utilisable — §7).
+
+Chaque entrée décrit sa route DIRECTE fournisseur (api_format anthropic|openai,
+base_url, api_key_env) ET sa route de repli OpenRouter (openrouter_id). La
+résolution effective (app/models/client.py) prend la clé directe si présente,
+sinon OPENROUTER_API_KEY — un modèle sans aucune clé est « non testé ».
+
+⚠️ IDs vérifiés sur l'API OpenRouter le 2026-07-02. Écarts vs la spec §3.2 :
+  • gemini-3-1-pro / gemini-3-flash absents → mappés sur gemini-2.5-pro/flash ;
+  • magistral-medium indisponible sur OpenRouter → retiré des candidats audit ;
+  • grok-4-1-fast inexistant → retiré des candidats mécanique.
+"""
+
+ROLES = ("generate", "audit", "mecanique")
+
+_ANTHROPIC = dict(provider="anthropic", api_format="anthropic",
+                  base_url="https://api.anthropic.com/v1",
+                  api_key_env="ANTHROPIC_API_KEY")
+_OPENAI = dict(provider="openai", api_format="openai",
+               base_url="https://api.openai.com/v1",
+               api_key_env="OPENAI_API_KEY")
+_GEMINI = dict(provider="google", api_format="openai",
+               base_url="https://generativelanguage.googleapis.com/v1beta/openai",
+               api_key_env="GEMINI_API_KEY")
+_XAI = dict(provider="x-ai", api_format="openai",
+            base_url="https://api.x.ai/v1", api_key_env="XAI_API_KEY")
+_DEEPSEEK = dict(provider="deepseek", api_format="openai",
+                 base_url="https://api.deepseek.com/v1",
+                 api_key_env="DEEPSEEK_API_KEY")
+_MOONSHOT = dict(provider="moonshot", api_format="anthropic",
+                 base_url="https://api.moonshot.ai/anthropic",
+                 api_key_env="MOONSHOT_API_KEY")
+_ZAI = dict(provider="z-ai", api_format="openai",
+            base_url="https://api.z.ai/api/paas/v4",
+            api_key_env="ZAI_API_KEY")
+_MISTRAL = dict(provider="mistral", api_format="openai",
+                base_url="https://api.mistral.ai/v1",
+                api_key_env="MISTRAL_API_KEY")
+_MINIMAX = dict(provider="minimax", api_format="openai",
+                base_url="https://api.minimax.io/v1",
+                api_key_env="MINIMAX_API_KEY")
+
+
+def _m(key, base, direct_id, openrouter_id, roles, cache=True, batch=True):
+    return key, {**base, "model_id": direct_id, "openrouter_id": openrouter_id,
+                 "roles": tuple(roles), "supports_cache": cache, "supports_batch": batch}
+
+
+CATALOG: dict = dict([
+    # ── GENERATE (frontière + quasi-frontière) ───────────────────────────────
+    _m("claude-sonnet-5", _ANTHROPIC, "claude-sonnet-5",
+       "anthropic/claude-sonnet-5", ("generate",)),
+    _m("claude-opus-4-8", _ANTHROPIC, "claude-opus-4-8",
+       "anthropic/claude-opus-4.8", ("generate", "audit")),
+    _m("gpt-5-4", _OPENAI, "gpt-5.4", "openai/gpt-5.4", ("generate",)),
+    _m("gemini-3-1-pro", _GEMINI, "gemini-2.5-pro",       # mappé (3.1 absent)
+       "google/gemini-2.5-pro", ("generate", "audit")),
+    _m("grok-4-3", _XAI, "grok-4.3", "x-ai/grok-4.3", ("generate", "audit")),
+    _m("kimi-k2-6", _MOONSHOT, "kimi-k2.6",
+       "moonshotai/kimi-k2.6", ("generate", "audit")),
+    _m("glm-5-2", _ZAI, "glm-5.2", "z-ai/glm-5.2", ("generate",)),
+    _m("deepseek-v4-pro", _DEEPSEEK, "deepseek-v4-pro",
+       "deepseek/deepseek-v4-pro", ("generate", "audit")),
+    _m("mistral-large-3", _MISTRAL, "mistral-large-2512",
+       "mistralai/mistral-large-2512", ("generate",)),
+    # ── MECANIQUE (rapide / bon marché) ──────────────────────────────────────
+    _m("claude-haiku-4-5", _ANTHROPIC, "claude-haiku-4-5",
+       "anthropic/claude-haiku-4.5", ("mecanique",)),
+    _m("mistral-small", _MISTRAL, "mistral-small-3.2",
+       "mistralai/mistral-small-3.2-24b-instruct", ("mecanique",), cache=False),
+    _m("deepseek-v4-flash", _DEEPSEEK, "deepseek-v4-flash",
+       "deepseek/deepseek-v4-flash", ("mecanique",)),
+    _m("glm-4-7-flash", _ZAI, "glm-4.7-flash",
+       "z-ai/glm-4.7-flash", ("mecanique",)),
+    _m("gemini-3-flash", _GEMINI, "gemini-2.5-flash",     # mappé (3-flash absent)
+       "google/gemini-2.5-flash", ("mecanique",)),
+    _m("gpt-5-4-nano", _OPENAI, "gpt-5.4-nano",
+       "openai/gpt-5.4-nano", ("mecanique",)),
+    # minimax-m3 : catalogue §3.3, candidat d'appoint générique.
+    _m("minimax-m3", _MINIMAX, "minimax-m3",
+       "minimax/minimax-m3", ("mecanique",), cache=False),
+])
+
+# Candidats par rôle (ordre indicatif ; le banc trie par ses mesures).
+CANDIDATES = {
+    role: [k for k, v in CATALOG.items() if role in v["roles"]]
+    for role in ROLES
+}
+
+
+def model_info(key: str) -> dict:
+    if key not in CATALOG:
+        raise KeyError(f"Modèle inconnu au catalogue : {key!r}")
+    return CATALOG[key]

app/models/client.py

@@ -0,0 +1,135 @@
+"""
+client.py — adaptateur fournisseur unifié (§3.1).
+
+Une seule interface :
+    ModelClient().complete(system, messages, model_key, **opts)
+      -> {"text", "usage_in", "usage_out", "latency_ms", "route"}
+
+Dispatch par entrée de catalogue : {api_format ∈ {anthropic, openai}, base_url,
+api_key_env, model_id, openrouter_id}. Résolution de route :
+  1. clé DIRECTE du fournisseur présente (api_key_env) → endpoint natif ;
+  2. sinon OPENROUTER_API_KEY présente → route OpenRouter (format openai) ;
+  3. sinon MissingKeyError — le banc marque « non testé (clé absente) »,
+     jamais une erreur bloquante.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import random
+import time
+
+import requests
+
+from app.models.catalog import model_info
+
+logger = logging.getLogger(__name__)
+
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+
+
+class MissingKeyError(RuntimeError):
+    """Aucune clé disponible pour ce modèle (direct + OpenRouter absents)."""
+
+
+def resolve_route(model_key: str) -> dict:
+    """Route effective pour un modèle : direct si sa clé est là, sinon
+    OpenRouter. Lève MissingKeyError si aucune clé."""
+    info = model_info(model_key)
+    direct_key = os.getenv(info["api_key_env"], "")
+    if direct_key:
+        return {"kind": "direct", "api_format": info["api_format"],
+                "base_url": info["base_url"], "model": info["model_id"],
+                "key": direct_key}
+    or_key = os.getenv("OPENROUTER_API_KEY", "")
+    if or_key:
+        return {"kind": "openrouter", "api_format": "openai",
+                "base_url": OPENROUTER_URL, "model": info["openrouter_id"],
+                "key": or_key}
+    raise MissingKeyError(
+        f"{model_key}: ni {info['api_key_env']} ni OPENROUTER_API_KEY présente")
+
+
+def is_available(model_key: str) -> bool:
+    try:
+        resolve_route(model_key)
+        return True
+    except (MissingKeyError, KeyError):
+        return False
+
+
+class ModelClient:
+    """Client fin multi-fournisseurs avec retries (backoff + jitter, 429)."""
+
+    def __init__(self, max_retries: int = 3, timeout: int = 180):
+        self.max_retries = max_retries
+        self.timeout = timeout
+
+    def complete(self, system: str, messages: list, model_key: str,
+                 temperature: float = 0.0, max_tokens: int = 4096) -> dict:
+        route = resolve_route(model_key)
+        t0 = time.time()
+        if route["api_format"] == "anthropic" and route["kind"] == "direct":
+            out = self._anthropic(route, system, messages, temperature, max_tokens)
+        else:
+            out = self._openai(route, system, messages, temperature, max_tokens)
+        out["latency_ms"] = int((time.time() - t0) * 1000)
+        out["route"] = route["kind"]
+        return out
+
+    # ── formats ──────────────────────────────────────────────────────────────
+
+    def _anthropic(self, route, system, messages, temperature, max_tokens) -> dict:
+        url = route["base_url"].rstrip("/") + "/messages"
+        headers = {"x-api-key": route["key"],
+                   "anthropic-version": "2023-06-01",
+                   "content-type": "application/json"}
+        payload = {"model": route["model"], "system": system,
+                   "messages": messages, "temperature": temperature,
+                   "max_tokens": max_tokens}
+        data = self._post(url, headers, payload)
+        text = "".join(b.get("text", "") for b in data.get("content", [])
+                       if b.get("type") == "text")
+        usage = data.get("usage", {})
+        return {"text": text,
+                "usage_in": usage.get("input_tokens", 0),
+                "usage_out": usage.get("output_tokens", 0)}
+
+    def _openai(self, route, system, messages, temperature, max_tokens) -> dict:
+        url = (route["base_url"] if route["kind"] == "openrouter"
+               else route["base_url"].rstrip("/") + "/chat/completions")
+        headers = {"Authorization": f"Bearer {route['key']}",
+                   "Content-Type": "application/json"}
+        payload = {"model": route["model"],
+                   "messages": [{"role": "system", "content": system}] + messages,
+                   "temperature": temperature, "max_tokens": max_tokens}
+        data = self._post(url, headers, payload)
+        text = data["choices"][0]["message"]["content"]
+        usage = data.get("usage", {})
+        return {"text": text,
+                "usage_in": usage.get("prompt_tokens", 0),
+                "usage_out": usage.get("completion_tokens", 0)}
+
+    def _post(self, url, headers, payload) -> dict:
+        for attempt in range(self.max_retries):
+            try:
+                resp = requests.post(url, json=payload, headers=headers,
+                                     timeout=self.timeout)
+                if resp.status_code == 429:
+                    wait = 2 * (2 ** attempt) + random.uniform(0, 4)
+                    logger.warning("429 sur %s — retry dans %.1fs", url, wait)
+                    time.sleep(wait)
+                    continue
+                resp.raise_for_status()
+                data = resp.json()
+                if "error" in data:
+                    raise RuntimeError(f"API error: {data['error']}")
+                return data
+            except (requests.RequestException, RuntimeError) as e:
+                if attempt == self.max_retries - 1:
+                    raise
+                wait = 2 * (2 ** attempt) + random.uniform(0, 4)
+                logger.warning("Erreur %s — retry dans %.1fs", e, wait)
+                time.sleep(wait)
+        raise RuntimeError("Échec après retries")

app/models/policy.py

@@ -0,0 +1,155 @@
+"""
+policy.py — politique de sélection de modèle par rôle (§5).
+
+Modes :
+  auto   (défaut) : échelle ordonnée par coût croissant des modèles qui
+                    tiennent SEUIL_VERT, plafonnée par `best`. Départ choisi
+                    par un pré-classifieur de difficulté ; escalade d'un
+                    échelon à chaque échec harnais après réparations.
+  best   : modèle `best` du rôle (qualité max, coût ignoré).
+  cheap  : modèle `cheap` (le moins cher qui tient le seuil).
+  manual : IDs explicites par rôle (config ou requête API).
+
+Alimentation : app/models/recommended.json (écrit par le banc). Fallback si
+absent : routage par défaut ci-dessous — SANS Fable (retiré volontairement).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+
+from app.config import MODEL_AUDIT, MODEL_GENERATE, MODEL_MECANIQUE, RECOMMENDED_PATH
+from app.models.catalog import CATALOG, model_info
+from app.models.client import is_available
+
+logger = logging.getLogger(__name__)
+
+POLICIES = ("auto", "best", "cheap", "manual")
+
+# Fallback §5.2 (si recommended.json absent) — generate = Sonnet 5 avec
+# escalade Opus 4.8 ; audit = Opus 4.8 ; mécanique = Haiku 4.5. Fable exclu.
+DEFAULT_RECOMMENDED = {
+    "generate": {"best": "claude-opus-4-8", "cheap": "claude-sonnet-5",
+                 "ladder": ["claude-sonnet-5", "claude-opus-4-8"]},
+    "audit": {"best": "claude-opus-4-8", "cheap": "claude-opus-4-8",
+              "ladder": ["claude-opus-4-8"]},
+    "mecanique": {"best": "claude-haiku-4-5", "cheap": "claude-haiku-4-5",
+                  "ladder": ["claude-haiku-4-5"]},
+}
+
+
+def load_recommended() -> dict:
+    """recommended.json s'il existe (produit par le banc), sinon fallback."""
+    try:
+        data = json.loads(RECOMMENDED_PATH.read_text(encoding="utf-8"))
+        roles = data.get("roles") or {}
+    except (OSError, json.JSONDecodeError, AttributeError, TypeError):
+        return {k: dict(v) for k, v in DEFAULT_RECOMMENDED.items()}
+    try:
+        merged = {}
+        for role, fb in DEFAULT_RECOMMENDED.items():
+            r = roles.get(role) or {}
+            merged[role] = {
+                "best": r.get("best") or fb["best"],
+                "cheap": r.get("cheap") or fb["cheap"],
+                "ladder": r.get("ladder") or fb["ladder"],
+            }
+        return merged
+    except (OSError, json.JSONDecodeError):
+        return {k: dict(v) for k, v in DEFAULT_RECOMMENDED.items()}
+
+
+def _usable(keys: list) -> list:
+    """Filtre : au catalogue (sans Fable, par construction) ET clé dispo."""
+    out = []
+    for k in keys:
+        if k not in CATALOG:
+            logger.warning("Modèle recommandé hors catalogue (ignoré) : %s", k)
+            continue
+        if not is_available(k):
+            logger.warning("Modèle sans clé disponible (ignoré) : %s", k)
+            continue
+        out.append(k)
+    return out
+
+
+def ladder(role: str) -> list:
+    """Échelle `auto` du rôle, coût croissant. Le plafonnement vit dans la
+    DÉCISION du banc (report.decide) : l'échelle écrite dans recommended.json
+    fait foi telle quelle — elle peut dépasser `best` quand des modèles de
+    qualité ÉGALE existent (redondance légitime : si l'échelon `best` échoue
+    sur UN exercice, un pair de même taux VERT peut réussir)."""
+    rec = load_recommended()[role]
+    keys = _usable(list(dict.fromkeys(rec["ladder"] + [rec["best"]])))
+    if not keys:
+        # Fallback élargi : tout candidat du rôle avec une clé disponible.
+        from app.models.catalog import CANDIDATES
+        keys = _usable(CANDIDATES[role])
+    if not keys:
+        raise RuntimeError(
+            f"Aucun modèle utilisable pour le rôle {role!r} : "
+            "aucune clé API disponible (OPENROUTER_API_KEY ou clé fournisseur).")
+    return keys
+
+
+# ── Pré-classifieur de difficulté (heuristique légère, zéro LLM) ─────────────
+
+_HARD_HINTS = re.compile(
+    r"Matrix|matrice|bmatrix|pmatrix|jacobien|système|systeme|"
+    r"int[ée]gra|\bipp\b|r[ée]currence|dimension", re.IGNORECASE)
+
+
+def classify_difficulty(content: str) -> str:
+    score = 0
+    if content.count(":::::{question}") >= 5:
+        score += 1
+    if len(content) > 6000:
+        score += 1
+    if _HARD_HINTS.search(content):
+        score += 1
+    if content.count("````{python}") + content.count("```{python}") > 1:
+        score += 1
+    return "difficile" if score >= 2 else "simple"
+
+
+def start_rung(role: str, difficulty: str) -> int:
+    """simple → échelon le moins cher ; difficile → échelon plus haut."""
+    steps = ladder(role)
+    if difficulty == "difficile" and len(steps) > 1:
+        return min(len(steps) - 1, len(steps) // 2 if len(steps) > 2 else 1)
+    return 0
+
+
+# ── Résolution par rôle / tentative ──────────────────────────────────────────
+
+def resolve(role: str, policy: str = "auto", manual: dict | None = None,
+            rung: int = 0) -> str:
+    """Clé catalogue du modèle à utiliser pour `role` (échelon `rung` en auto)."""
+    rec = load_recommended()[role]
+    if policy == "manual":
+        manual = manual or {}
+        key = (manual.get(role)
+               or {"generate": MODEL_GENERATE, "audit": MODEL_AUDIT,
+                   "mecanique": MODEL_MECANIQUE}[role])
+        if key in CATALOG and is_available(key):
+            return key
+        logger.warning("Choix manuel %r indisponible pour %s — repli cheap.", key, role)
+        policy = "cheap"
+    if policy == "best":
+        keys = _usable([rec["best"]]) or ladder(role)
+        return keys[-1] if keys else rec["best"]
+    if policy == "cheap":
+        keys = _usable([rec["cheap"]]) or ladder(role)
+        return keys[0] if keys else rec["cheap"]
+    # auto
+    steps = ladder(role)
+    if not steps:
+        return rec["best"]
+    return steps[min(rung, len(steps) - 1)]
+
+
+def openrouter_id(model_key: str) -> str:
+    """Pont vers le client pipeline (route OpenRouter)."""
+    return model_info(model_key)["openrouter_id"]

app/models/prices.json

@@ -0,0 +1,22 @@
+{
+  "_comment": "Tarifs USD / 1M tokens (in / out / cache-hit lecture). À RE-VÉRIFIER AVANT PROD — ils changent chaque semaine. Relevés sur l'API OpenRouter le 2026-07-02. batch_discount s'applique aux variantes batch (−50 %). claude-sonnet-5 : tarif d'intro (standard 3/15 annoncé après le 2026-08-31).",
+  "batch_discount": 0.5,
+  "models": {
+    "claude-opus-4-8":   {"in": 5.0,   "out": 25.0,  "cache_in": 0.5},
+    "claude-sonnet-5":   {"in": 2.0,   "out": 10.0,  "cache_in": 0.2},
+    "claude-haiku-4-5":  {"in": 1.0,   "out": 5.0,   "cache_in": 0.1},
+    "gpt-5-4":           {"in": 2.5,   "out": 15.0,  "cache_in": 0.25},
+    "gpt-5-4-nano":      {"in": 0.2,   "out": 1.25,  "cache_in": 0.02},
+    "gemini-3-1-pro":    {"in": 1.25,  "out": 10.0,  "cache_in": 0.125},
+    "gemini-3-flash":    {"in": 0.3,   "out": 2.5,   "cache_in": 0.03},
+    "grok-4-3":          {"in": 1.25,  "out": 2.5,   "cache_in": 0.2},
+    "kimi-k2-6":         {"in": 0.55,  "out": 3.2,   "cache_in": 0.11},
+    "glm-5-2":           {"in": 0.93,  "out": 3.0,   "cache_in": 0.18},
+    "glm-4-7-flash":     {"in": 0.06,  "out": 0.4,   "cache_in": 0.01},
+    "deepseek-v4-pro":   {"in": 0.435, "out": 0.87,  "cache_in": 0.00363},
+    "deepseek-v4-flash": {"in": 0.089, "out": 0.18,  "cache_in": 0.018},
+    "mistral-large-3":   {"in": 0.5,   "out": 1.5,   "cache_in": 0.05},
+    "mistral-small":     {"in": 0.075, "out": 0.2,   "cache_in": 0.0},
+    "minimax-m3":        {"in": 0.3,   "out": 1.2,   "cache_in": 0.06}
+  }
+}

app/models/recommended.json

@@ -0,0 +1,44 @@
+{
+  "_comment": "Écrit par `python -m bench run`. manual_override=true pour protéger un choix manuel.",
+  "_bench_timestamp": "20260702-165614_consolidated_370220",
+  "manual_override": false,
+  "roles": {
+    "generate": {
+      "best": "deepseek-v4-pro",
+      "cheap": "deepseek-v4-pro",
+      "ladder": [
+        "deepseek-v4-pro",
+        "kimi-k2-6",
+        "glm-5-2",
+        "grok-4-3",
+        "gemini-3-1-pro",
+        "claude-sonnet-5",
+        "claude-opus-4-8"
+      ]
+    },
+    "mecanique": {
+      "best": "mistral-small",
+      "cheap": "mistral-small",
+      "ladder": [
+        "mistral-small",
+        "deepseek-v4-flash",
+        "glm-4-7-flash",
+        "gpt-5-4-nano",
+        "minimax-m3",
+        "gemini-3-flash",
+        "claude-haiku-4-5"
+      ]
+    },
+    "audit": {
+      "best": "deepseek-v4-pro",
+      "cheap": "deepseek-v4-pro",
+      "ladder": [
+        "deepseek-v4-pro",
+        "kimi-k2-6",
+        "grok-4-3",
+        "gemini-3-1-pro",
+        "claude-opus-4-8"
+      ]
+    }
+  }
+}

app/pipeline/analyze.py

@@ -68,13 +68,16 @@ def _parse_analysis(raw: str, content: str) -> dict:
     return analysis
 
 
-def run_analysis_phase(content: str, model_idx: int) -> tuple[dict, str, str, str]:
+def run_analysis_phase(content: str, model_idx: int,
+                       model: str | None = None) -> tuple[dict, str, str, str]:
     """
     Lance EN PARALLÈLE : analyse LLM, notions, RAG fonctions.
 
     Retourne (analysis, notions_ctx, lists_of_notions, functions_ctx).
     Une erreur sur notions/RAG est dégradée en contexte vide (warning loggé) ;
     une erreur sur l'analyse LLM est propagée (le pipeline n'a pas de sens sans).
+    `model` (ID chaîne) prime sur model_idx — sous policy, l'analyse relève du
+    rôle `mecanique` (classification, §2 du prompt banc).
     """
     analysis_model = ANALYSIS_MODEL_IDX if ANALYSIS_MODEL_IDX is not None else model_idx
 
@@ -83,6 +86,7 @@ def run_analysis_phase(content: str, model_idx: int) -> tuple[dict, str, str, st
             process_with_openrouter,
             prompt=STEP1_PROMPT.format(content=content, available_rules_menu=_rules_menu()),
             model_idx=analysis_model,
+            model=model,
             max_tokens=6096,
         )
         f_notions = pool.submit(enrich_exercise_with_notions, content, xlsx_path=NOTIONS_XLSX)

app/pipeline/audit.py

@@ -172,6 +172,7 @@ def run_audit(
     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)."""
@@ -191,6 +192,7 @@ def run_audit(
                     exercise=myst_exercise,
                 ),
                 model_idx=model_idx,
+                model=model,
                 temperature=0.0,
                 max_tokens=8192,
                 system_prompt=SYSTEM_PROMPT,

app/pipeline/generate.py

@@ -244,6 +244,7 @@ def generate_pair_blocks(
     lang: str = "auto",
     set_step: Optional[Callable[[str], None]] = None,
     decl_type: Optional[str] = None,
+    model: Optional[str] = None,
 ) -> list[str]:
     """Boucle de génération par paires (séquentielle). Retourne les blocs.
     `decl_type` (qcm|qat) bascule sur le prompt Déclinaisons — même mécanique
@@ -291,6 +292,7 @@ def generate_pair_blocks(
                 **common,
             ),
             model_idx=model_idx,
+            model=model,
             max_tokens=30000,
             system_prompt=SYSTEM_PROMPT,
             reasoning=USE_REASONING,
@@ -320,6 +322,7 @@ def generate_pair_blocks(
                 **common,
             ),
             model_idx=model_idx,
+            model=model,
             temperature=0.4,
             max_tokens=16384,
             system_prompt=SYSTEM_PROMPT,

app/pipeline/orchestrator.py

@@ -30,6 +30,7 @@ from typing import Callable, Optional
 from app.config import (
     HARNESS_GATE_SEEDS,
     HARNESS_REPAIR_MAX,
+    MAX_ESCALADES,
     MULTI_SEED_NUM,
 )
 from app.knowledge.rules_digest import build_rules_digest
@@ -65,7 +66,8 @@ 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) -> list[dict]:
+                                         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 []
@@ -77,6 +79,7 @@ def _translate_constraints_to_assertions(code: str, constraints: list[str],
                                       if isinstance(c, str) and c.strip()),
             ),
             model_idx=model_idx,
+            model=model,
             temperature=0.0,
             max_tokens=2048,
             system_prompt=SYSTEM_PROMPT,
@@ -107,6 +110,7 @@ def run_exercise(
     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) ;
@@ -122,6 +126,12 @@ def run_exercise(
     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:
@@ -173,6 +183,7 @@ def run_exercise(
         lang=lang,
         set_step=_step,
         decl_type=decl_type,
+        model=m_gen,
     )
 
     # ── 3. Post-traitements déterministes ────────────────────────────────────
@@ -220,12 +231,12 @@ def run_exercise(
     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)
+            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)
+        myst_exercise, step1_targets, model_idx, set_step=_step, model=m_audit)
     audit_patches.extend(llm_patches)
     audit_warnings.extend(llm_warnings)
 
@@ -315,7 +326,7 @@ def run_exercise(
     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)
+        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)
@@ -363,7 +374,7 @@ def run_exercise(
 
     # ── 7. Langue cible ──────────────────────────────────────────────────────
     _step("Langue cible…")
-    myst_exercise, lang_warnings, lang_info = ensure_language(myst_exercise, lang, model_idx)
+    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))
@@ -391,6 +402,7 @@ def run_exercise(
                     exercise=myst_exercise,
                 ),
                 model_idx=model_idx,
+                model=m_gen,
                 temperature=0.0,
                 max_tokens=30000,
                 system_prompt=SYSTEM_PROMPT,
@@ -455,11 +467,87 @@ def run_exercise(
         },
         "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},
+        )
+        tried.append({"rung": i, "model": key, "ok": result["harness"]["ok"]})
+        if result["harness"]["ok"]:
+            break
+        logger.info("Échelon %s ROUGE sur %s — escalade.", key, filename)
+
+    result["policy_telemetry"] = {
+        "mode": policy,
+        "difficulty": difficulty,
+        "tried": tried,
+        "winning_model": key,
+        "needs_review": not result["harness"]["ok"],
+    }
+    # 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",
@@ -468,18 +556,25 @@ def run_declinaisons(
     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).
-    L'analyse + notions + RAG sont calculées UNE SEULE fois et partagées entre
-    les types (aucun appel LLM redondant). Retourne [(decl_type, result), …].
-    Un échec sur un type n'empêche pas l'autre (l'appelant gère l'erreur).
+    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)…")
-    shared = run_analysis_phase(content, model_idx)
+    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:
@@ -488,15 +583,25 @@ def run_declinaisons(
         def step_with_type(msg: str, _label=label):
             _step(f"[{_label}] {msg}")
 
-        result = run_exercise(
+        result = run_with_policy(
             content=content,
             filename=filename,
             level=level,
-            model_idx=model_idx,
             lang=lang,
-            set_step=step_with_type,
+            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

app/pipeline/solutions.py

@@ -30,6 +30,7 @@ def _substitute_solution_via_llm(
     source_text: str,
     analysis: dict,
     model_idx: int,
+    model: Optional[str] = None,
 ) -> Optional[str]:
     """Appel LLM ciblé : valeurs littérales de la solution source → {{var}}.
     None en cas d'échec (l'appelant garde alors la solution générée)."""
@@ -53,6 +54,7 @@ def _substitute_solution_via_llm(
                 variables_table=variables_table,
             ),
             model_idx=model_idx,
+            model=model,
             temperature=0.0,
             max_tokens=4096,
             system_prompt=SYSTEM_PROMPT,
@@ -70,6 +72,7 @@ def replace_gen_solutions_with_source(
     source_content: str,
     analysis: dict,
     model_idx: int,
+    model: Optional[str] = None,
 ) -> tuple[str, list[dict]]:
     """Remplace chaque detailedSolution générée par la version source
     substituée (correspondance positionnelle). Retourne (exercice, patches)."""
@@ -88,7 +91,7 @@ def replace_gen_solutions_with_source(
         src = source_solutions[i]
         if not src.strip():
             return match.group(0)
-        substituted = _substitute_solution_via_llm(src, analysis, model_idx)
+        substituted = _substitute_solution_via_llm(src, analysis, model_idx, model=model)
         if not substituted:
             return match.group(0)
 

app/pipeline/translate.py

@@ -48,6 +48,7 @@ def ensure_language(
     exercise: str,
     target: str,
     model_idx: int,
+    model: str | None = None,
 ) -> tuple[str, list[dict], dict]:
     """
     Amène l'exercice dans la langue cible. Retourne
@@ -83,6 +84,7 @@ def ensure_language(
                 format_directive=fmt,
             ),
             model_idx=model_idx,
+            model=model,
             temperature=0.0,
             max_tokens=24000,
         )

app/server.py

@@ -32,9 +32,10 @@ from app.config import (
     DEFAULT_LANG,
     DEFAULT_MODE,
     DEFAULT_MODEL_IDX,
+    DEFAULT_POLICY,
     JOB_TTL,
 )
-from app.pipeline.orchestrator import run_declinaisons, run_exercise
+from app.pipeline.orchestrator import run_declinaisons, run_with_policy
 
 logger = logging.getLogger(__name__)
 
@@ -89,10 +90,11 @@ def _decl_output_name(source_name: str, decl_type: str) -> str:
 
 
 def _run_job(job_id: str, files: list[dict], level: str, model_idx: int,
-             lang: str, mode: str = "pythonise", decl_types: list | None = None):
+             lang: str, mode: str = "pythonise", decl_types: list | None = None,
+             policy: str = "auto", manual_models: dict | None = None):
     """Worker de job : boucle séquentielle sur les fichiers, robuste.
     En mode `declinaisons`, chaque source produit 1 résultat PAR type coché
-    (analyse partagée entre types — aucun appel LLM redondant)."""
+    (analyse partagée entre types et échelons — aucun appel LLM redondant)."""
     results: list[dict] = []
     for i, f in enumerate(files):
         name = f.get("filename") or f"fichier_{i + 1}.md"
@@ -112,25 +114,30 @@ def _run_job(job_id: str, files: list[dict], level: str, model_idx: int,
                     lang=lang,
                     types=decl_types,
                     set_step=set_step,
+                    policy=policy,
+                    manual_models=manual_models,
                 ):
                     out_name = _decl_output_name(name, decl_type)
                     results.append({"filename": out_name, "status": "done", "result": result})
-                    logger.info("Déclinaison %s : harnais %s, %d warnings, %.1fs, %.4f$",
+                    logger.info("Déclinaison %s : harnais %s, modèle %s, %d warnings, %.1fs, %.4f$",
                                 out_name, "VERT" if result["harness"]["ok"] else "ROUGE",
+                                result.get("model_used"),
                                 len(result["warnings"]), result["duration_s"],
                                 result["cost"]["usd"])
             else:
-                result = run_exercise(
+                result = run_with_policy(
                     content=f["content"],
                     filename=name,
                     level=level,
-                    model_idx=model_idx,
                     lang=lang,
+                    policy=policy,
+                    manual_models=manual_models,
                     set_step=set_step,
                 )
                 results.append({"filename": name, "status": "done", "result": result})
-                logger.info("Fichier %s : harnais %s, %d warnings, %.1fs, %.4f$",
+                logger.info("Fichier %s : harnais %s, modèle %s, %d warnings, %.1fs, %.4f$",
                             name, "VERT" if result["harness"]["ok"] else "ROUGE",
+                            result.get("model_used"),
                             len(result["warnings"]), result["duration_s"],
                             result["cost"]["usd"])
         except Exception as exc:
@@ -198,10 +205,16 @@ def register_routes(app):
 
     @app.route("/api/models", methods=["GET"])
     def models():
+        from app.models.catalog import CANDIDATES
+        from app.models.policy import POLICIES, load_recommended
         return jsonify({
             "models": {str(k): v for k, v in AVAILABLE_MODELS.items()},
             "default_idx": DEFAULT_MODEL_IDX,
             "default_lang": DEFAULT_LANG,
+            "policies": list(POLICIES),
+            "default_policy": DEFAULT_POLICY,
+            "catalog": CANDIDATES,          # candidats par rôle (sans Fable)
+            "recommended": load_recommended(),
         })
 
     @app.route("/api/jobs", methods=["POST"])
@@ -254,6 +267,26 @@ def register_routes(app):
             if not decl_types:
                 return jsonify({"error": "En mode 'declinaisons', cocher au moins un type (qcm/qat)."}), 400
 
+        # Politique de sélection de modèle (§5) — Fable absent du catalogue.
+        from app.models.catalog import CATALOG, ROLES
+        from app.models.policy import POLICIES
+        policy = (data.get("policy") or DEFAULT_POLICY).strip()
+        if policy not in POLICIES:
+            return jsonify({"error": f"'policy' invalide : {policy!r} (auto|best|cheap|manual)."}), 400
+        manual_models: dict = {}
+        if policy == "manual":
+            models_obj = data.get("models") or {}
+            if not isinstance(models_obj, dict):
+                return jsonify({"error": "'models' doit être un objet {generate, audit, mecanique}."}), 400
+            for role in ROLES:
+                key = models_obj.get(role)
+                if not key:          # absent OU "" (select vide) → défaut config
+                    continue
+                if key not in CATALOG or role not in CATALOG[key]["roles"]:
+                    return jsonify({"error": f"Modèle {key!r} invalide pour le rôle {role} "
+                                             f"(catalogue : {[k for k, v in CATALOG.items() if role in v['roles']]})."}), 400
+                manual_models[role] = key
+
         job_id = uuid.uuid4().hex
         with _JOBS_LOCK:
             _JOBS[job_id] = {
@@ -271,7 +304,8 @@ def register_routes(app):
 
         threading.Thread(
             target=_run_job,
-            args=(job_id, clean_files, level, model_idx, lang, mode, decl_types),
+            args=(job_id, clean_files, level, model_idx, lang, mode, decl_types,
+                  policy, manual_models),
             daemon=True,
         ).start()
         return jsonify({"job_id": job_id}), 202

app/validation/harness.py

@@ -30,6 +30,10 @@ from contextlib import redirect_stdout
 
 logger = logging.getLogger(__name__)
 
+# Budget par graine (exec + rendu + scans). Un bloc légitime tient en < 1 s ;
+# au-delà c'est un code généré pathologique → seed en échec, pas de blocage.
+SEED_TIMEOUT_S = 10.0
+
 try:
     import matplotlib
     matplotlib.use("Agg")
@@ -374,14 +378,42 @@ def validate_text(text: str, seeds: int = 100) -> dict:
     body_tmpl = strip_python_blocks(text)
     install_pyxiscience_stubs()
     failures: list[str] = []
+    n_timeouts = 0
+
+    from app.validation.sandbox import ExecTimeout, run_with_timeout
 
     for s in range(seeds):
         random.seed(s)
         env: dict = {"rd": random, "random": random}
-        try:
+        out: dict = {}
+
+        def _seed_pass(env=env, out=out):
             with redirect_stdout(io.StringIO()), _warnings.catch_warnings():
                 _warnings.simplefilter("ignore")   # plt.show() sous Agg, etc.
                 exec(code, env)  # noqa: S102 — sandbox stubs + contenu maison
+            # Le rendu et le scan MCQ font des str() sur les valeurs du
+            # namespace : time-boxés AVEC l'exec (un str() sympy sur une
+            # expression géante peut mouliner des heures — banc 2026-07-02).
+            out["rendered"], out["unresolved"] = render_body(body_tmpl, env)
+            if declinaison:
+                out["mcq"] = check_mcq_collisions(text, env)
+
+        try:
+            run_with_timeout(_seed_pass, SEED_TIMEOUT_S)
+        except ExecTimeout:
+            report["n_exec_errors"] += 1
+            n_timeouts += 1
+            if len(failures) < 5:
+                failures.append(
+                    f"seed {s} : timeout ({SEED_TIMEOUT_S:g}s) — exécution ou "
+                    "rendu pathologiquement lents (expression sympy géante ?)")
+            if _HAS_MPL:
+                _plt.close("all")
+            if n_timeouts >= 3:
+                failures.append("≥ 3 timeouts — graines restantes abandonnées "
+                                "(verdict déjà ROUGE)")
+                break
+            continue
         except Exception:
             report["n_exec_errors"] += 1
             if len(failures) < 5:
@@ -393,7 +425,7 @@ def validate_text(text: str, seeds: int = 100) -> dict:
         if _HAS_MPL:
             _plt.close("all")
 
-        rendered, unresolved = render_body(body_tmpl, env)
+        rendered, unresolved = out["rendered"], out["unresolved"]
         if unresolved:
             report["n_unresolved"] += 1
             if len(failures) < 8:

app/validation/sandbox.py

@@ -214,40 +214,55 @@ class ExecTimeout(Exception):
     """Raised when exec exceeds its time budget."""
 
 
-def _timeout_handler(signum, frame):
-    raise ExecTimeout("exec exceeded its time budget")
+class _ExecKill(BaseException):
+    """Escalade du timeout : BaseException pour percer les `except Exception`
+    avaleurs du code généré (seul un `except:` nu peut encore l'attraper)."""
 
 
-def _exec_with_timeout(code: str, namespace: dict, timeout: float) -> None:
+def run_with_timeout(fn, timeout: float):
     """
-    Run `exec(code, namespace)` under a timeout.
+    Run `fn()` under a timeout — utilisé pour l'exec sandboxé ET pour le
+    rendu/scan par graine du harnais (un `str()` sympy sur une expression
+    géante peut mouliner des heures : vu au banc du 2026-07-02).
 
     Two strategies:
-      • Main thread → use `signal.SIGALRM` (cheap, interruptible).
-      • Background thread (Flask worker) → use a daemon thread + `Event.wait`.
+      • Main thread → `signal.SIGALRM` avec re-tir périodique (interval) :
+        1er tir = ExecTimeout ; tirs suivants = _ExecKill (BaseException),
+        car un `try/except Exception` du code généré avale ExecTimeout mais
+        ne peut pas attraper une BaseException. Seul un `except:` nu résiste.
+      • Background thread (Flask worker) → daemon thread + `Event.wait`.
         The daemon thread can't actually be killed in Python; it survives the
         timeout but doesn't block subsequent execs since each call spawns a
         fresh daemon. Acceptable for short math-only workloads.
     """
-    compiled = compile(code, "<sandbox>", "exec")
-
     if threading.current_thread() is threading.main_thread():
-        old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
-        signal.setitimer(signal.ITIMER_REAL, timeout)
+        fired = {"n": 0}
+
+        def _handler(signum, frame):
+            fired["n"] += 1
+            if fired["n"] == 1:
+                raise ExecTimeout("exec exceeded its time budget")
+            raise _ExecKill
+
+        old_handler = signal.signal(signal.SIGALRM, _handler)
+        signal.setitimer(signal.ITIMER_REAL, timeout, 0.5)
         try:
-            exec(compiled, namespace)
+            return fn()
+        except _ExecKill:
+            raise ExecTimeout(
+                f"exec tué après {timeout}s (timeout avalé par le code ?)"
+            ) from None
         finally:
             signal.setitimer(signal.ITIMER_REAL, 0)
             signal.signal(signal.SIGALRM, old_handler)
-        return
 
     # Background-thread variant: run in a daemon child thread.
-    captured: dict[str, Optional[BaseException]] = {"exc": None}
+    captured: dict[str, object] = {"exc": None, "ret": None}
     done = threading.Event()
 
     def _target() -> None:
         try:
-            exec(compiled, namespace)
+            captured["ret"] = fn()
         except BaseException as e:  # noqa: BLE001 — re-raised below
             captured["exc"] = e
         finally:
@@ -258,7 +273,13 @@ def _exec_with_timeout(code: str, namespace: dict, timeout: float) -> None:
     if not done.wait(timeout):
         raise ExecTimeout(f"exec exceeded {timeout}s")
     if captured["exc"] is not None:
-        raise captured["exc"]
+        raise captured["exc"]  # type: ignore[misc]
+    return captured["ret"]
+
+
+def _exec_with_timeout(code: str, namespace: dict, timeout: float) -> None:
+    compiled = compile(code, "<sandbox>", "exec")
+    run_with_timeout(lambda: exec(compiled, namespace), timeout)
 
 
 def exec_python_block(

app/web/templates/index.html

@@ -362,8 +362,24 @@
           </div>
         </div>
         <div>
-          <label class="field-label" for="model-select">Modèle</label>
-          <select id="model-select" aria-label="Modèle LLM"></select>
+          <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>
@@ -474,35 +490,51 @@ async function fetchModels() {
   try {
     const res = await fetch("/api/models");
     if (!res.ok) return;
-    const { models, default_idx, default_lang } = await res.json();
-    const sel = document.getElementById("model-select");
-    sel.innerHTML = "";
-    for (const [idx, slug] of Object.entries(models).sort((a, b) => Number(a[0]) - Number(b[0]))) {
-      const opt = document.createElement("option");
-      opt.value = idx;
-      opt.textContent = prettyModelName(slug);
-      if (Number(idx) === default_idx) opt.selected = true;
-      sel.appendChild(opt);
+    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] = slug.split("/");
+  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) ─── */
+/* ─── 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") {
@@ -723,7 +755,16 @@ function setMetaResult(entry) {
       decl += `<span class="pill pill--info">repli MCQ partiel</span>`;
     }
   }
-  el.innerHTML = verdict + decl + cost + lang + dur;
+  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 + decl + pol + cost + lang + dur;
 }
 
 /* Sélecteur de fichier (batch) */
@@ -767,13 +808,21 @@ async function run() {
   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,
-    model_idx: Number(document.getElementById("model-select").value || 0),
     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,

tests/nonreg_pythonise.py

@@ -0,0 +1,45 @@
+"""Non-régression RÉELLE du mode pythonise sous politique `auto`.
+
+Lance le pipeline complet (LLM réels) sur l'énoncé de référence Exercice_1,
+puis valide la sortie au harnais 300 graines. À lancer ponctuellement après
+un chantier (le smoke hors-ligne reste la vérif de routine).
+
+    PYTHONPATH=. .venv/bin/python tests/nonreg_pythonise.py [chemin_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_with_policy
+from app.validation import harness
+
+SRC = Path(sys.argv[1]) if len(sys.argv) > 1 else \
+    Path(__file__).resolve().parent.parent.parent / "Exemples d'exercices" / "Exercice_1.md"
+
+content = SRC.read_text(encoding="utf-8")
+res = run_with_policy(content, filename=SRC.name, lang="fr", policy="auto",
+                      set_step=lambda s: print(f"  · {s}", flush=True))
+
+out = Path("/tmp/nonreg_pythonise_out.md")
+out.write_text(res["exercise"], encoding="utf-8")
+
+tele = res["policy_telemetry"]
+print(f"\nharnais porte : {'VERT' if res['harness']['ok'] else 'ROUGE'}")
+print(f"policy        : mode={tele['mode']} difficulté={tele['difficulty']} "
+      f"gagnant={tele['winning_model']} échelons={len(tele['tried'])}")
+print(f"coût          : {res['cost']}")
+print(f"sortie        : {out}")
+
+# Contre-validation indépendante, 300 graines (plus dur que la porte à 100).
+rep = harness.validate_text(res["exercise"], seeds=300)
+print(f"harnais 300   : {'VERT' if rep['ok'] else 'ROUGE'}")
+if not rep["ok"]:
+    print("échecs:", rep["first_failures"][:5])
+    sys.exit(1)
+print("NON-RÉGRESSION OK")

tests/nonreg_qat.py

@@ -0,0 +1,38 @@
+"""Non-régression RÉELLE du mode déclinaisons QAT (non couvert par le banc,
+qui exerce le chemin QCM). LLM réels + harnais 300 graines.
+
+    PYTHONPATH=. .venv/bin/python tests/nonreg_qat.py [chemin_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
+from app.validation import harness
+
+SRC = Path(sys.argv[1]) if len(sys.argv) > 1 else \
+    Path(__file__).resolve().parent.parent / "bench" / "corpus" / "trinome_pythonise.md"
+
+content = SRC.read_text(encoding="utf-8")
+out = run_declinaisons(content, filename=SRC.name, lang="fr", types=["qat"],
+                       set_step=lambda s: print(f"  · {s}", flush=True))
+
+(decl_type, res), = out
+tele = res["policy_telemetry"]
+print(f"\nharnais porte : {'VERT' if res['harness']['ok'] else 'ROUGE'}")
+print(f"policy        : gagnant={tele['winning_model']} échelons={len(tele['tried'])}")
+print(f"coût          : {res['cost']}")
+
+# (les contrôles déclinaison sont auto-détectés par validate_text)
+rep = harness.validate_text(res["exercise"], seeds=300)
+print(f"harnais 300   : {'VERT' if rep['ok'] else 'ROUGE'}")
+if not rep["ok"]:
+    print("échecs:", rep["first_failures"][:5])
+    sys.exit(1)
+print("NON-RÉGRESSION QAT OK")

tests/smoke.py

@@ -229,16 +229,21 @@ On trouve ${}{{a}} + {{b}} = {{sumAff}}$.
 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):
+             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 "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 "{}"
 
@@ -324,6 +329,98 @@ 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 "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())
+
+# 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