feat(correction): réancrer la synthèse sur le SRT corrigé, sans passe supplémentaire

La synthèse livrée dans le Word était rédigée sur `summary/quick_transcript.txt` —
la transcription RAPIDE, produite AVANT la correction — et n'était jamais
réalignée sur le SRT qu'on livre à côté. Un ré-résumé autonome coûterait ≈ 1× la
durée de l'audio (0,94× mesuré sur 122 runs, 345 s sur un extrait de 5 min).

La passe de correction est la seule qui réunit déjà tout : elle relit
l'intégralité du SRT par sous-agents, et elle reçoit déjà `job_context.yaml`,
donc les participants validés et l'animateur. Le réancrage n'y coûte que la
rédaction — **mesuré : 281 s contre 271,5 s, soit +9,5 s (+3,5 %)**.

Garde-fous, parce que le SRT reste l'artefact critique de cette phase :
- **ordonné, pas parallèle** : la consigne dit « ENSUITE SEULEMENT », une fois
  `transcription_corrigee.srt` terminé — un agent à qui on demande deux choses
  de front fait moins bien les deux ;
- **best-effort** : pas de fichier rendu ⇒ la synthèse existante est conservée et
  la correction reste un succès ;
- **le prompt EXIGE, le code VÉRIFIE** (même doctrine que la parité de segments
  du SRT) : longueur dans la bande 0,90–1,10, aucune ligne de SRT dans le
  fichier, sinon le texte est écarté avec la raison au journal ;
- **l'humain est souverain** : si la synthèse de l'étape 4 diffère du
  préremplissage, elle a été éditée — on ne la réécrit pas, et on ne demande même
  pas le travail à la LLM (coût nul, risque nul).

Vérifié en réel, E2E web complet sur un extrait de réunion :
- la synthèse réancrée passe la garde (1377 → 1377 caractères) et est persistée ;
- preuve de propagation : un sigle validé au lexique sous une autre graphie est
  appliqué au SRT par la correction **et suit dans la synthèse livrée** — ce qui
  était impossible tant qu'elle restait figée sur la transcription rapide.

Règle répliquée à l'identique dans configs/prompts/{en,de,es,it}.

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

Author: Martossien

configs/prompts/correction_prompt.txt

@@ -287,6 +287,39 @@ sera rejeté.)
 
 ---
 
+## 8bis. Réancrage de la synthèse — SEULEMENT si `synthese_a_reancrer.md` est fourni
+
+Fichier absent (cas fréquent) ⇒ **ignorer entièrement cette section**.
+
+La synthèse livrée à l'utilisateur a été rédigée sur une transcription RAPIDE, produite
+AVANT ta correction. Tu viens de relire l'intégralité du SRT : tu es le seul à pouvoir la
+réancrer sur le texte réellement livré, et cela ne doit rien coûter d'autre que la
+rédaction.
+
+**Uniquement après** que `transcription_corrigee.srt` est terminé et vérifié :
+
+1. Lire `synthese_a_reancrer.md`.
+2. Corriger **ce que le SRT corrigé contredit** : noms, chiffres, dates, termes, une
+   affirmation qui reposait sur une erreur de transcription.
+3. Si `job_context.yaml` marque un participant `is_animator: true`, c'est un **fait
+   validé par l'humain** : sers-t'en comme **fil de structure** (ordre du jour,
+   transitions, points mis en décision, gestion du temps) et attribue-lui l'animation.
+   Il n'a **aucune autorité de contenu supplémentaire** : les faits de chaque locuteur
+   pèsent à égalité, l'autorité sur un sujet revient à celui qui le porte, et un temps de
+   parole élevé ne gonfle pas sa place dans la synthèse.
+4. Écrire `summary_reancree.md` — la synthèse rédigée SEULE, aucun autre bloc, aucune
+   ligne de SRT.
+
+**Contraintes, aussi strictes que pour le SRT** : tu ne re-résumes pas. Même longueur
+(ratio 0.90–1.10 avec la synthèse fournie), même structure, **aucun point supprimé**,
+rien d'ajouté qui ne soit dans le SRT corrigé. Le système vérifie ce ratio et rejette le
+fichier sinon.
+
+**En cas de doute, n'écris pas le fichier** : la synthèse existante sera conservée. Une
+absence ne coûte rien, une dérive coûte un compte rendu.
+
+---
+
 ## 9. Déroulé d'exécution
 
 1. Lister le répertoire de travail avec Bash.

configs/prompts/de/correction_prompt.txt

@@ -292,6 +292,40 @@ zurückgewiesen.)
 
 ---
 
+## 8bis. Neuverankerung der Zusammenfassung — NUR wenn `synthese_a_reancrer.md` vorliegt
+
+Datei nicht vorhanden (der Normalfall) ⇒ **diesen Abschnitt vollständig überspringen**.
+
+Die an die Nutzenden gelieferte Zusammenfassung wurde auf einer SCHNELLEN Transkription
+verfasst, die VOR deiner Korrektur entstand. Du hast soeben das gesamte SRT erneut
+gelesen: nur du kannst sie auf den tatsächlich gelieferten Text neu verankern, und das
+darf nichts kosten außer dem Schreiben.
+
+**Erst nachdem** `transcription_corrigee.srt` fertig und geprüft ist:
+
+1. `synthese_a_reancrer.md` lesen.
+2. Korrigiere, **was das korrigierte SRT widerlegt**: Namen, Zahlen, Daten, Begriffe,
+   jede Aussage, die auf einem Transkriptionsfehler beruhte.
+3. Markiert `job_context.yaml` eine Person mit `is_animator: true`, ist das eine
+   **vom Menschen bestätigte** Tatsache: nutze sie als **roten Faden der Struktur**
+   (Tagesordnung, Übergänge, zur Entscheidung gestellte Punkte, Zeitmanagement) und
+   schreibe ihr die Moderation korrekt zu. Sie hat **keine zusätzliche inhaltliche
+   Autorität**: die Fakten aller Sprechenden wiegen gleich, die Autorität zu einem Thema
+   liegt bei der Person, die es vertritt, und eine hohe Redezeit vergrößert ihren Platz
+   in der Zusammenfassung nicht.
+4. `summary_reancree.md` schreiben — NUR die verfasste Zusammenfassung, kein weiterer
+   Block, keine SRT-Zeilen.
+
+**Auflagen, so streng wie beim SRT**: Du fasst nicht neu zusammen. Gleiche Länge
+(Verhältnis 0,90–1,10 zur gelieferten Zusammenfassung), gleiche Struktur, **kein Punkt
+entfernt**, nichts hinzugefügt, was nicht im korrigierten SRT steht. Das System prüft
+dieses Verhältnis und weist die Datei andernfalls zurück.
+
+**Im Zweifel die Datei nicht schreiben**: die bestehende Zusammenfassung bleibt erhalten.
+Ein Fehlen kostet nichts, eine Abweichung kostet ein Protokoll.
+
+---
+
 ## 9. Ausführungsablauf
 
 1. Das Arbeitsverzeichnis mit Bash auflisten.

configs/prompts/en/correction_prompt.txt

@@ -268,6 +268,37 @@ segment count and this ratio: a non-conforming file will be rejected.)
 
 ---
 
+## 8bis. Re-anchoring the summary — ONLY if `synthese_a_reancrer.md` is provided
+
+File absent (the common case) ⇒ **skip this section entirely**.
+
+The summary delivered to the user was written on a FAST transcription produced BEFORE
+your correction. You have just re-read the whole SRT: you are the only one who can
+re-anchor it on the text actually delivered, and it must cost nothing beyond the writing.
+
+**Only after** `transcription_corrigee.srt` is finished and verified:
+
+1. Read `synthese_a_reancrer.md`.
+2. Fix **whatever the corrected SRT contradicts**: names, figures, dates, terms, any
+   statement that rested on a transcription error.
+3. If `job_context.yaml` marks a participant with `is_animator: true`, this is a fact
+   **validated by a human**: use it as a **structural thread** (agenda, transitions,
+   items put to a decision, time management) and attribute the facilitation correctly.
+   It carries **no additional authority over content**: every speaker's facts weigh
+   equally, authority on a topic belongs to whoever carries it, and a high speaking time
+   does not inflate their place in the summary.
+4. Write `summary_reancree.md` — the written summary ONLY, no other block, no SRT lines.
+
+**Constraints, as strict as for the SRT**: you do not re-summarise. Same length (ratio
+0.90–1.10 against the provided summary), same structure, **no item removed**, nothing
+added that is not in the corrected SRT. The system checks that ratio and rejects the
+file otherwise.
+
+**When in doubt, do not write the file**: the existing summary will be kept. An absence
+costs nothing, a drift costs a report.
+
+---
+
 ## 9. Execution flow
 
 1. List the working directory with Bash.

configs/prompts/es/correction_prompt.txt

@@ -298,6 +298,38 @@ conforme será rechazado.)
 
 ---
 
+## 8bis. Reanclaje del resumen — SOLO si se proporciona `synthese_a_reancrer.md`
+
+Archivo ausente (el caso habitual) ⇒ **omitir por completo esta sección**.
+
+El resumen entregado al usuario se redactó sobre una transcripción RÁPIDA, producida
+ANTES de tu corrección. Acabas de releer todo el SRT: eres el único que puede reanclarlo
+en el texto realmente entregado, y no debe costar nada más que la redacción.
+
+**Solo después** de que `transcription_corrigee.srt` esté terminado y verificado:
+
+1. Leer `synthese_a_reancrer.md`.
+2. Corregir **lo que el SRT corregido contradiga**: nombres, cifras, fechas, términos,
+   cualquier afirmación que se apoyara en un error de transcripción.
+3. Si `job_context.yaml` marca a un participante con `is_animator: true`, es un hecho
+   **validado por el humano**: úsalo como **hilo de estructura** (orden del día,
+   transiciones, puntos sometidos a decisión, gestión del tiempo) y atribúyele la
+   animación. No tiene **ninguna autoridad adicional sobre el fondo**: los hechos de cada
+   locutor pesan por igual, la autoridad sobre un tema corresponde a quien lo lleva, y un
+   tiempo de palabra elevado no aumenta su lugar en el resumen.
+4. Escribir `summary_reancree.md` — SOLO el resumen redactado, ningún otro bloque,
+   ninguna línea de SRT.
+
+**Restricciones, tan estrictas como para el SRT**: no vuelves a resumir. Misma longitud
+(ratio 0,90–1,10 respecto al resumen proporcionado), misma estructura, **ningún punto
+suprimido**, nada añadido que no esté en el SRT corregido. El sistema verifica ese ratio
+y rechaza el archivo en caso contrario.
+
+**En caso de duda, no escribas el archivo**: se conservará el resumen existente. Una
+ausencia no cuesta nada, una deriva cuesta un acta.
+
+---
+
 ## 9. Desarrollo de la ejecución
 
 1. Listar el directorio de trabajo con Bash.

configs/prompts/it/correction_prompt.txt

@@ -290,6 +290,39 @@ file non conforme sarà respinto.)
 
 ---
 
+## 8bis. Riancoraggio della sintesi — SOLO se `synthese_a_reancrer.md` è fornito
+
+File assente (il caso abituale) ⇒ **ignorare del tutto questa sezione**.
+
+La sintesi consegnata all'utente è stata redatta su una trascrizione RAPIDA, prodotta
+PRIMA della tua correzione. Hai appena riletto l'intero SRT: sei l'unico a poterla
+riancorare al testo effettivamente consegnato, e non deve costare nulla oltre la
+redazione.
+
+**Solo dopo** che `transcription_corrigee.srt` è terminato e verificato:
+
+1. Leggere `synthese_a_reancrer.md`.
+2. Correggere **ciò che l'SRT corretto contraddice**: nomi, cifre, date, termini, ogni
+   affermazione che poggiava su un errore di trascrizione.
+3. Se `job_context.yaml` contrassegna un partecipante con `is_animator: true`, è un fatto
+   **convalidato dall'essere umano**: usalo come **filo della struttura** (ordine del
+   giorno, transizioni, punti messi in decisione, gestione del tempo) e attribuiscigli
+   correttamente l'animazione. Non ha **alcuna autorità aggiuntiva sul merito**: i fatti
+   di ogni locutore pesano allo stesso modo, l'autorità su un argomento spetta a chi lo
+   porta, e un tempo di parola elevato non gonfia il suo posto nella sintesi.
+4. Scrivere `summary_reancree.md` — SOLO la sintesi redatta, nessun altro blocco, nessuna
+   riga di SRT.
+
+**Vincoli, severi quanto per l'SRT**: non riassumi di nuovo. Stessa lunghezza (rapporto
+0,90–1,10 rispetto alla sintesi fornita), stessa struttura, **nessun punto soppresso**,
+nulla di aggiunto che non sia nell'SRT corretto. Il sistema verifica tale rapporto e
+altrimenti rifiuta il file.
+
+**Nel dubbio, non scrivere il file**: la sintesi esistente sarà conservata. Un'assenza
+non costa nulla, una deriva costa un verbale.
+
+---
+
 ## 9. Svolgimento dell'esecuzione
 
 1. Elencare la directory di lavoro con Bash.

docs/DATA_MODEL.md

@@ -771,6 +771,8 @@ Assemblé par `JobContextBuilder.build()` à partir de `meeting_context.json`, `
 
 Chaque participant y porte `is_animator: true` **seulement** si la case « ★ Animateur » a été cochée à l'étape 5 (clé absente sinon : une réunion sans animateur laisse le contexte strictement identique). C'est la seule information du contexte qui soit un choix humain explicite plutôt qu'une déduction ; le prompt de résumé s'en sert comme fil de structure, jamais comme autorité de contenu.
 
+La phase de correction s'en sert aussi pour **réancrer la synthèse** : elle relit déjà l'intégralité du SRT, elle reçoit déjà le contexte validé (dont l'animateur), et la synthèse livrée avait été rédigée sur la transcription RAPIDE d'avant correction. Le texte réancré remplace `meeting_context["summary"]` **seulement** s'il est resté identique au préremplissage de l'étape 4 (l'édition humaine est souveraine) et s'il tient dans la bande de longueur 0,90–1,10 — sinon la synthèse existante est conservée.
+
 Ce fichier est construit après le mapping des locuteurs puis reconstruit après la sauvegarde du lexique afin d'inclure `session_lexicon.json`. Il n'existe pas encore au moment du résumé ; le résumé LLM reçoit donc un fichier dédié `summary/diarization_context.md` pour les données pyannote disponibles à cette étape.
 
 ### audio_scene.json

quality_baseline.json

@@ -231,7 +231,7 @@
   "transcria.workflow.gpu_phase": 8,
   "transcria.workflow.multi_stt_review": 1,
   "transcria.workflow.phases": 9,
-  "transcria.workflow.phases.correction": 7,
+  "transcria.workflow.phases.correction": 8,
   "transcria.workflow.phases.diarization": 7,
   "transcria.workflow.phases.export": 4,
   "transcria.workflow.phases.final_review": 6,

tests/test_animator.py

@@ -22,6 +22,7 @@
 from transcria.jobs.filesystem import JobFilesystem
 from transcria.jobs.models import Job, JobState
 from transcria.web.pages_routes import _apply_animator_suggestion
+from transcria.workflow.phases.correction import reanchored_summary_error, summary_to_reanchor
 from transcria.workflow.animator_hint import animator_from_roles, suggest_animator
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -181,3 +182,70 @@ def test_le_bouton_ne_coche_pas_d_office(self):
         assert "s.get('animator_suggested')" in template
         assert "{% if s.get('animator_suggested') %} checked" not in template
         assert "W.applyAnimatorSuggestion" in js
+
+
+class TestReancrageSynthese:
+    """Lot 1bis — la synthèse est réancrée sur le SRT corrigé PAR LA PASSE QUI LE RELIT.
+
+    Constat qui motive le lot : la synthèse livrée est rédigée sur `quick_transcript.txt`,
+    la transcription RAPIDE d'avant correction — jamais sur le SRT qu'on livre à côté. La
+    passe de correction est la seule qui relit tout le SRT ET reçoit déjà le contexte
+    validé (animateur compris) : le réancrage n'y coûte que la génération, contre une
+    passe complète (≈ 1× la durée de l'audio) pour un ré-résumé autonome.
+    """
+
+    _HEADINGS = ["## Synthèse", "## Summary"]
+
+    def test_la_synthese_non_editee_part_au_reancrage(self):
+        ctx = {"summary_llm": "# Résumé\n\n## Synthèse\nDeux points discutés.\n\n## Termes\n(aucun)",
+               "summary": "Deux points discutés."}
+
+        assert summary_to_reanchor(ctx, self._HEADINGS) == "Deux points discutés."
+
+    def test_une_synthese_EDITEE_par_l_humain_n_est_jamais_reecrite(self):
+        """Et on ne la demande même pas à la LLM : coût nul, risque nul."""
+        ctx = {"summary_llm": "## Synthèse\nDeux points discutés.",
+               "summary": "Deux points discutés, dont le budget que j'ai ajouté."}
+
+        assert summary_to_reanchor(ctx, self._HEADINGS) == ""
+
+    def test_sans_synthese_il_n_y_a_rien_a_reancrer(self):
+        assert summary_to_reanchor({}, self._HEADINGS) == ""
+        assert summary_to_reanchor({"summary_llm": ""}, self._HEADINGS) == ""
+
+    def test_la_garde_rejette_une_synthese_qui_fond(self):
+        """Même doctrine que le SRT : le prompt EXIGE, le code VÉRIFIE. C'est la dérive
+        observée quand on laisse un modèle « réécrire » librement."""
+        precedente = "x" * 1000
+
+        assert reanchored_summary_error(precedente, "x" * 400) is not None
+        assert reanchored_summary_error(precedente, "x" * 1500) is not None
+        assert reanchored_summary_error(precedente, "x" * 950) is None
+
+    def test_la_garde_rejette_un_fichier_qui_n_est_pas_une_synthese(self):
+        """Vécu ailleurs : l'agent recrache des lignes de SRT dans le mauvais fichier."""
+        srt = "1\n00:00:01,000 --> 00:00:04,000\nBonjour."
+
+        assert "SRT" in (reanchored_summary_error("x" * 60, srt) or "")
+        assert reanchored_summary_error("x" * 60, "   ") is not None
+
+    def test_la_regle_est_repliquee_dans_les_cinq_prompts(self):
+        """Une consigne ajoutée au FR et oubliée ailleurs = une fonctionnalité qui
+        n'existe que pour les livrables français."""
+        fr = (ROOT / "configs/prompts/correction_prompt.txt").read_text(encoding="utf-8")
+        assert "synthese_a_reancrer.md" in fr and "summary_reancree.md" in fr
+        for loc in ("en", "de", "es", "it"):
+            texte = (ROOT / f"configs/prompts/{loc}/correction_prompt.txt").read_text(encoding="utf-8")
+            assert "synthese_a_reancrer.md" in texte, f"{loc} : entrée absente"
+            assert "summary_reancree.md" in texte, f"{loc} : sortie absente"
+            assert "is_animator" in texte, f"{loc} : règle animateur absente"
+
+    def test_le_reancrage_est_demande_APRES_le_srt(self):
+        """Le SRT est l'artefact critique : la re-synthèse est une étape finale, jamais un
+        second objectif mené de front (un agent à qui on demande deux choses fait moins
+        bien les deux)."""
+        source = (ROOT / "transcria/llm_tools/opencode_runner.py").read_text(encoding="utf-8")
+        bloc = source.split("def run_correction(", 1)[1].split("def ", 1)[0]
+
+        assert "ENSUITE SEULEMENT" in bloc
+        assert bloc.index("transcription_corrigee.srt") < bloc.index("summary_reancree.md")

transcria/context/meeting_context.py

@@ -12,6 +12,19 @@
 
 
 
+def synthese_section(raw_md: str, headings: list[str]) -> str:
+    """La seule section « Synthèse » d'un summary.md brut, sinon le markdown entier.
+
+    PURE : les marqueurs de section (langue-dépendants) sont fournis par l'appelant —
+    c'est ce qui permet à la phase de correction comme au wizard de partager l'extraction
+    sans que ce module ait à connaître le catalogue de marqueurs.
+    """
+    for heading in headings:
+        if heading and heading in raw_md:
+            return raw_md.split(heading, 1)[1].split("\n##", 1)[0].strip()
+    return raw_md.strip()
+
+
 class MeetingContextManager:
     @staticmethod
     def get(job: Job, jobs_dir: str) -> dict:

transcria/llm_tools/opencode_runner.py

@@ -617,6 +617,7 @@ def run_correction(
         lexicon_path: str,
         invite_path: str | None = None,
         output_language: str = "fr",
+        summary_path: str | None = None,
     ) -> dict:
         """Corrige le SRT via opencode : speakers + lexique + orthographe.
 
@@ -626,8 +627,15 @@ def run_correction(
 
         ``output_language`` : langue des livrables (Axe B) — prompt localisé + consigne.
 
+        ``summary_path`` (facultatif) : la synthèse à RÉANCRER sur le SRT corrigé. La
+        synthèse livrée est aujourd'hui rédigée sur la transcription RAPIDE, d'avant
+        correction ; l'agent relit déjà l'intégralité du SRT ici, le réancrage ne coûte
+        donc que la génération. Tâche BORNÉE et best-effort : pas de fichier rendu ⇒ la
+        synthèse existante est conservée telle quelle.
+
         Returns:
-            {"success": bool, "corrected_srt": str, "report": str, "error": str}
+            {"success": bool, "corrected_srt": str, "report": str,
+             "rewritten_summary": str, "error": str}
         """
         prompt_file = resolve_prompt_file(self._config, "correction_prompt.txt", output_language)
 
@@ -658,6 +666,16 @@ def run_correction(
             "(2) correction_report.md — rapport Markdown uniquement, "
             "aucune ligne SRT dans ce fichier."
         )
+        if summary_path and os.path.isfile(summary_path):
+            # ORDRE, pas parallèle : le SRT est l'artefact critique (gardes de parité et
+            # de ratio côté code). Le réancrage se fait APRÈS, depuis le fichier corrigé.
+            instruction += (
+                f" ENSUITE SEULEMENT, une fois transcription_corrigee.srt terminé : lis la "
+                f"synthèse {summary_path} et réancre-la sur le SRT corrigé selon le § 8 du "
+                "prompt système, puis écris un 3e fichier summary_reancree.md. Si tu ne peux "
+                "pas le faire dans ces contraintes, n'écris pas ce fichier — le système "
+                "conservera la synthèse existante."
+            )
 
         timeout = self._get_correction_timeout()
         result = self.run(instruction, prompt_file, timeout=timeout)
@@ -666,10 +684,14 @@ def run_correction(
 
         corrected_file = self.work_dir / "transcription_corrigee.srt"
         report_file = self.work_dir / "correction_report.md"
+        summary_file = self.work_dir / "summary_reancree.md"
+        rewritten_summary = ""
         if corrected_file.is_file():
             corrected_srt = corrected_file.read_text(encoding="utf-8").strip()
         if report_file.is_file():
             report = report_file.read_text(encoding="utf-8").strip()
+        if summary_file.is_file():
+            rewritten_summary = summary_file.read_text(encoding="utf-8").strip()
 
         # Recovery : si transcription_corrigee.srt est présent et non-vide, la correction
         # est faite quelle que soit la raison de sortie d'opencode — timeout, SIGTERM (-15),
@@ -686,6 +708,7 @@ def run_correction(
             "success": result["success"],
             "corrected_srt": corrected_srt,
             "report": report,
+            "rewritten_summary": rewritten_summary,
             "error": result.get("error", ""),
             "warning": result.get("warning", ""),
         }