Declinaisons: originalExerciseId systematique + grille miroir + bouton Stop

- :originalExerciseId: toujours present dans l en-tete des declinaisons,
valeur = :id: du QST source (vide si la source n en a pas) — convention
des 33 exemples valides, prouve sur generation reelle (harnais VERT).
- MCQ_SPEC v2 : distracteurs en GRILLE MIROIR (variations symetriques,
bonne reponse jamais devinable par la forme — regle enseignante) ; jamais
d option structurellement unique ni de fraction non simplifiee.
- Filet d aeration deterministe (ligne vide avant chaque bloc question/
sous-bloc — mise en page des exemples valides), idempotent, applique
aussi aux candidats de reparation.
- Bouton Stop (tous modes) : POST /api/jobs/<id>/cancel, annulation
cooperative au prochain point d etape, resultats partiels conserves,
statut cancelled dans l UI.
- Smoke 71/71 (aeration, originalExerciseId, flux d annulation complet).

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

README_APP.md

@@ -4,6 +4,13 @@ App Flask à deux modes :
 - **Pythonisation** d'exercices PyxiScience MyST (valeurs fixes → randomisées) ;
 - **Déclinaisons** (2026-07) : génération de versions **QCM** (MCQ) et/ou
   **QAT** (FGQ, champs libres ordonnés) d'un exercice, randomisées elles aussi.
+  `:originalExerciseId:` systématique (= `:id:` du QST source, vide sinon) ;
+  distracteurs MCQ en **grille miroir** (variations symétriques — la bonne
+  réponse ne se devine jamais par la forme ; règle enseignante 2026-07-02).
+
+Un bouton **⏹ Arrêter** (tous modes) annule le job en cours : arrêt coopératif
+au prochain point d'étape (`POST /api/jobs/<id>/cancel`), résultats partiels
+conservés et téléchargeables.
 
 Pipeline async : analyse LLM + notions + RAG (parallèles, **partagés entre QCM
 et QAT**) → génération par paires → audit LLM → filets déterministes → **porte

app/pipeline/generate.py

@@ -184,10 +184,11 @@ def build_exercise_metadata(
     lines = [f"{fence}{{exercise}}"]
     for k in _HEADER_FIELDS:
         lines.append(f":{k}: {values[k]}".rstrip())
-        # Déclinaison d'un exercice existant : tracer l'id source juste après :id:
-        # (convention des exemples validés : :originalExerciseId:).
-        if k == "id" and decl_type and src.get("id"):
-            lines.append(f":originalExerciseId: {src['id']}")
+        # Déclinaison : tracer l'id de l'exercice SOURCE juste après :id:
+        # (convention des 33 exemples validés : :originalExerciseId: TOUJOURS
+        # présent — vide si la source n'a pas d'id, à compléter côté plateforme).
+        if k == "id" and decl_type:
+            lines.append(f":originalExerciseId: {src.get('id', '')}".rstrip())
     return "\n".join(lines)
 
 

app/pipeline/orchestrator.py

@@ -380,6 +380,7 @@ def run_exercise(
     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({
@@ -427,6 +428,7 @@ def run_exercise(
             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_report = harness.validate_text(candidate, seeds=HARNESS_GATE_SEEDS)
 

app/pipeline/postprocess.py

@@ -783,3 +783,27 @@ def check_decimals_for_lang(exercise: str, lang: str) -> list[dict]:
     else:
         _scan(body, lang, "corps")
     return warnings
+
+
+# ── Aération (lisibilité — mise en page des exemples validés) ────────────────
+
+_BLOCK_OPENER_RE = re.compile(r"^:{4,5}\{\w")
+
+
+def aerate_blocks(exercise: str) -> tuple[str, int]:
+    """Garantit une ligne vide avant chaque ouverture de bloc
+    `:::::{question}` / `::::{sous-bloc}` — la mise en page des 33 exemples
+    validés (déclinaisons) et du corpus 222. Idempotent. Pas de suivi de
+    fences : `::::{` n'existe qu'en structure MyST, et une ligne vide serait
+    de toute façon inoffensive dans un bloc Python."""
+    out: list[str] = []
+    added = 0
+    for line in exercise.splitlines():
+        if _BLOCK_OPENER_RE.match(line) and out and out[-1].strip():
+            out.append("")
+            added += 1
+        out.append(line)
+    text = "\n".join(out)
+    if exercise.endswith("\n"):
+        text += "\n"
+    return text, added

app/pipeline/prompts.py

@@ -530,6 +530,8 @@ TRANSLATE_FORMAT_BOTH = (
 # 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).
 # ─────────────────────────────────────────────────────────────────────────────
 
 MCQ_SPEC = """\
@@ -607,6 +609,27 @@ DISTRACTEURS — ERREURS TYPES UNIQUEMENT (aucune valeur au hasard) :
   • 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 EN MIROIR — INDEVINABILITÉ (règle enseignante, 2026-07-02) :
+  • Les options forment une GRILLE SYMÉTRIQUE dont la bonne réponse est un
+    élément comme les autres — JAMAIS des variations « une seule chose à la
+    fois » autour de la bonne réponse.
+      ✗ MAUVAIS : 2x+3 (vraie) ; 2x−3 ; 2x−4 ; −2x+3
+        → le motif commun « 2x+3 » se devine (chaque distracteur n'en dévie
+          que d'un seul trait).
+      ✓ BON : 2x+3 ; 2x−3 ; −2x+3 ; −2x−3
+        → grille complète des combinaisons de signes : l'intuition ne peut
+          plus trier, il faut CALCULER.
+  • La bonne réponse ne doit JAMAIS être structurellement unique parmi les
+    options : ni la seule avec un radical/une fraction/un facteur, ni la plus
+    longue ou la plus courte, ni la seule sous forme simplifiée — TOUTES les
+    options au même niveau de simplification (jamais de fraction réductible).
+  • Concilier avec les erreurs types : choisir les erreurs types qui FERMENT
+    la grille (signe × signe, ordre × signe…) plutôt que d'empiler des erreurs
+    indépendantes autour du même gabarit.
+  • Test avant de rendre : masque mentalement la bonne réponse — si sa place
+    se retrouve par simple examen des FORMES (motif majoritaire, symétrie
+    incomplète, singularité), reconstruis la grille.
+
 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,

app/server.py

@@ -47,6 +47,12 @@ VALID_LEVELS = ("", "Elementary", "Intermediate", "Advanced")
 VALID_MODES = ("pythonise", "declinaisons")
 
 
+class JobCancelled(Exception):
+    """Arrêt demandé par l'utilisateur (bouton Stop). L'annulation est
+    COOPÉRATIVE : elle prend effet au prochain point d'étape du pipeline
+    (un appel LLM en vol n'est pas interrompu, mais rien ne s'enchaîne)."""
+
+
 def _set_job(job_id: str, **kwargs):
     with _JOBS_LOCK:
         if job_id in _JOBS:
@@ -79,10 +85,29 @@ def _purge_old_jobs():
     cutoff = time.time() - JOB_TTL
     with _JOBS_LOCK:
         for jid in [jid for jid, j in _JOBS.items()
-                    if j.get("status") in ("done", "error") and (j.get("finished_at") or 0) < cutoff]:
+                    if j.get("status") in ("done", "error", "cancelled")
+                    and (j.get("finished_at") or 0) < cutoff]:
             del _JOBS[jid]
 
 
+def _cancel_requested(job_id: str) -> bool:
+    with _JOBS_LOCK:
+        j = _JOBS.get(job_id)
+        return bool(j and j.get("cancel_requested"))
+
+
+def _summarize(results: list[dict], total: int) -> dict:
+    ok = sum(1 for r in results
+             if r["status"] == "done" and r["result"]["harness"]["ok"])
+    warn = sum(1 for r in results
+               if r["status"] == "done" and not r["result"]["harness"]["ok"])
+    err = sum(1 for r in results if r["status"] == "error")
+    cost = round(sum(r["result"]["cost"]["usd"] for r in results
+                     if r["status"] == "done"), 4)
+    return {"total": total, "verts": ok, "rouges": warn,
+            "erreurs": err, "cost_usd": cost}
+
+
 def _decl_output_name(source_name: str, decl_type: str) -> str:
     """foo.md + qcm → foo_QCM.md (nommage de sortie des déclinaisons)."""
     base = re.sub(r"\.(md|txt)$", "", source_name or "exercice", flags=re.IGNORECASE)
@@ -96,12 +121,47 @@ def _run_job(job_id: str, files: list[dict], level: str, model_idx: int,
     En mode `declinaisons`, chaque source produit 1 résultat PAR type coché
     (analyse partagée entre types et échelons — aucun appel LLM redondant)."""
     results: list[dict] = []
+    try:
+        _run_job_files(job_id, files, level, model_idx, lang, mode,
+                       decl_types, policy, manual_models, results)
+    except JobCancelled:
+        _set_job(
+            job_id,
+            status="cancelled",
+            step_label="Arrêté par l'utilisateur",
+            finished_at=time.time(),
+            results=list(results),
+            summary=_summarize(results, len(files)),
+        )
+        logger.info("Job %s annulé par l'utilisateur (%d/%d fichiers traités).",
+                    job_id, len(results), len(files))
+        _purge_old_jobs()
+        return
+
+    _set_job(
+        job_id,
+        status="done",
+        step_label="Terminé",
+        finished_at=time.time(),
+        summary=_summarize(results, len(files)),
+    )
+    _purge_old_jobs()
+
+
+def _run_job_files(job_id, files, level, model_idx, lang, mode, decl_types,
+                   policy, manual_models, results):
     for i, f in enumerate(files):
+        if _cancel_requested(job_id):
+            raise JobCancelled()
         name = f.get("filename") or f"fichier_{i + 1}.md"
         _set_job(job_id, current_file=name, files_done=i,
                  step_label=f"[{i + 1}/{len(files)}] {name} — démarrage…")
 
         def set_step(label: str, _i=i, _name=name):
+            # Point de contrôle d'annulation : chaque étape du pipeline passe
+            # ici (analyse, génération, audit, harnais, réparation, échelon).
+            if _cancel_requested(job_id):
+                raise JobCancelled()
             _set_job(job_id, step_label=f"[{_i + 1}/{len(files)}] {_name} — {label}")
 
         try:
@@ -140,28 +200,13 @@ def _run_job(job_id: str, files: list[dict], level: str, model_idx: int,
                             result.get("model_used"),
                             len(result["warnings"]), result["duration_s"],
                             result["cost"]["usd"])
+        except JobCancelled:
+            raise                     # remonte au gestionnaire de _run_job
         except Exception as exc:
             logger.exception("Échec du pipeline sur %s", name)
             results.append({"filename": name, "status": "error", "error": str(exc)})
         _set_job(job_id, results=list(results), files_done=i + 1)
 
-    ok = sum(1 for r in results
-             if r["status"] == "done" and r["result"]["harness"]["ok"])
-    warn = sum(1 for r in results
-               if r["status"] == "done" and not r["result"]["harness"]["ok"])
-    err = sum(1 for r in results if r["status"] == "error")
-    total_cost = round(sum(r["result"]["cost"]["usd"] for r in results
-                           if r["status"] == "done"), 4)
-    _set_job(
-        job_id,
-        status="done",
-        step_label="Terminé",
-        finished_at=time.time(),
-        summary={"total": len(files), "verts": ok, "rouges": warn,
-                 "erreurs": err, "cost_usd": total_cost},
-    )
-    _purge_old_jobs()
-
 
 def _auth_ok() -> bool:
     """Basic Auth si APP_PASSWORD est défini ; ouvert sinon (dev local)."""
@@ -326,6 +371,20 @@ def register_routes(app):
             "error": job.get("error"),
         })
 
+    @app.route("/api/jobs/<job_id>/cancel", methods=["POST"])
+    def job_cancel(job_id: str):
+        """Arrêt coopératif : prend effet au prochain point d'étape (un appel
+        LLM en vol se termine, rien ne s'enchaîne). Résultats partiels gardés."""
+        with _JOBS_LOCK:
+            job = _JOBS.get(job_id)
+            if not job:
+                return jsonify({"error": "Job inconnu."}), 404
+            if job["status"] != "running":
+                return jsonify({"status": job["status"],
+                                "error": "Job déjà terminé."}), 409
+            job["cancel_requested"] = True
+        return jsonify({"status": "cancelling"}), 202
+
     @app.route("/api/jobs/<job_id>/download", methods=["GET"])
     def job_download_zip(job_id: str):
         """ZIP de toutes les sorties .md prêtes du job + un récapitulatif."""

app/web/templates/index.html

@@ -406,6 +406,8 @@
 
       <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>
@@ -839,6 +841,9 @@ async function run() {
   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);
@@ -862,7 +867,35 @@ async function run() {
   } catch (e) {
     setProgress("error", "Échec", "—");
     setStatus("error", "Erreur : " + e.message);
-    document.getElementById("run-btn").disabled = false;
+    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;
+}
+
+/* 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);
   }
 }
 
@@ -882,7 +915,7 @@ async function poll() {
       // 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.");
-      document.getElementById("run-btn").disabled = false;
+      jobFinished();
       return;
     }
 
@@ -902,11 +935,19 @@ async function poll() {
       activeResultIdx = 0;
       renderResultFiles();
       showResult(0);
-      document.getElementById("run-btn").disabled = false;
+      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"));
-      document.getElementById("run-btn").disabled = false;
+      jobFinished();
     }
   } catch (e) {
     // Erreur TRANSITOIRE (proxy HF, worker occupé en calcul, réseau) : on
@@ -918,7 +959,7 @@ async function poll() {
         "Suivi interrompu après plusieurs tentatives (" + e.message + "). "
         + "Le traitement continue peut-être côté serveur : recharge la page dans ~1 min "
         + "pour le retrouver, ou relance avec moins de fichiers à la fois.");
-      document.getElementById("run-btn").disabled = false;
+      jobFinished();
       return;
     }
     setStatus("warn", `Reconnexion au suivi… (${pollFailures}/${POLL_MAX_FAILURES})`);
@@ -929,6 +970,8 @@ async function poll() {
 function clearAll() {
   if (pollTimer) clearTimeout(pollTimer);
   currentJobId = null;
+  document.getElementById("stop-btn").hidden = true;
+  document.getElementById("run-btn").disabled = false;
   loadedFiles = []; jobResults = []; activeResultIdx = 0;
   renderFileList();
   document.getElementById("input").value = "";

tests/gen_decl_sample.py

@@ -0,0 +1,26 @@
+"""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}")

tests/smoke.py

@@ -406,6 +406,68 @@ check("API : manual modèle hors rôle → 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