fix(security,metrics): Sprint A14-S1 — boucher les 6 P0 du rewrite ciblé

Sprint S1 du plan rewrite ciblé (rewrite-2026, étape 0 :
stabilisation de l'existant avant la migration de structure).

P0-1 — normalization_profile propagé end-to-end (web → runner)
Ajout de ``normalization_profile: Optional[str] = None`` à la
signature de ``run_benchmark`` ; résolution one-shot dans le main
process via ``get_builtin_profile`` puis propagation aux deux
workers (process pool : tuple à 10 éléments rétrocompat ; thread
pool : kwarg) jusqu'à ``_compute_document_result`` et
``compute_metrics``. Avant ce sprint, le paramètre était exposé
par ``BenchmarkRequest`` / ``BenchmarkRunRequest`` mais
silencieusement perdu — l'option de l'UI était un faux bouton.

P0-2 — 11 profils alignés (README ↔ Pydantic ↔ runtime)
``NormalizationProfileId`` ajoute ``secretary_hand``,
``sans_ponctuation``, ``sans_apostrophes`` (Pydantic refusait 3
profils valides du runtime).

P0-3 — compact() devient opt-in (text_limit, drop_analyses)
Avant : le runner appelait ``dr.compact()`` avant la
sérialisation JSON, ce qui amputait silencieusement 13 dicts
d'analyse per-document (taxonomy, philological, calibration,
searchability, etc.) et tronquait les textes à 200 chars. Le
rapport HTML — qui consomme ce JSON — recevait des données déjà
mutilées, contredisant la promesse "self-contained HTML report".
Désormais ``compact()`` est no-op par défaut ; le caller doit
demander explicitement ``compact(text_limit=200,
drop_analyses=True)`` pour reproduire l'ancien comportement.

P0-4 — compute_metrics retourne None en erreur (au lieu de 0.0)
Avant : jiwer absent ou exception → ``MetricsResult(cer=0.0,
wer=0.0, ...)`` indistinguable d'un score parfait pour tout
consommateur ne lisant pas systématiquement ``error``. Désormais
``MetricsResult.cer`` (et 6 autres champs) sont
``Optional[float]`` à ``None`` quand ``error`` est non-None.
``cer_percent`` / ``wer_percent`` / ``as_dict`` gèrent None.
L'agrégateur double-filtre (``error is None`` + ``v is not
None``) pour défense en profondeur.

P0-5 — corpus_path / output_dir validés contre workspace_roots
Nouveau ``validated_path(user_path, allowed_roots, must_exist,
must_be_dir)`` avec ``Path.resolve().is_relative_to()``.
Nouvelle ``compute_workspace_roots(uploads_dir)`` qui ajoute
``./rapports`` et ``./corpus`` à ``compute_browse_roots`` et
qu'un admin peut épingler via ``PICARONES_WORKSPACE_ROOTS``.
Appliquée dans ``/api/benchmark/start`` et
``/api/benchmark/run`` après la check mode public (l'ordre est
testé par ``test_sprint24_security``).

P0-6 — prompt_file restreint à la bibliothèque intégrée
Nouveau ``validated_prompt_filename(name)`` qui refuse les
séparateurs de chemin, les chemins absolus, ``..``, les
caractères de contrôle. Appliqué dans ``/api/benchmark/run``
pour bloquer l'exfiltration de fichiers locaux via prompt LLM.

Bonus — ``safe_report_name`` durcit la concaténation
``output_dir / f"{report_name}.html"`` contre les escapes via
``../`` et caractères de contrôle (défense en profondeur :
``output_dir`` est déjà validé en amont par le router).

Tests
-----
- 5 tests existants utilisaient ``compact()`` pour vérifier
l'effacement des analyses : mis à jour pour appeler
``compact(drop_analyses=True)`` (nouvelle sémantique opt-in).
Un test "défaut sans argument est no-op" ajouté.
- 51 nouveaux tests S1 :
* tests/security/test_sprint_a14_s1_path_validation.py (20)
— validated_path, safe_report_name, validated_prompt_filename.
* tests/core/test_sprint_a14_s1_metrics_error_returns_none.py (9)
— None plutôt que 0.0, propriétés safe, agrégateur robuste.
* tests/core/test_sprint_a14_s1_compact_optin.py (10)
— défaut no-op, text_limit, drop_analyses, combiné legacy.
* tests/measurements/test_sprint_a14_s1_normalization_propagation.py
(7) — signatures, parité 11 profils Pydantic ↔ runtime,
cer_diplomatic effectivement différent selon profil.

État de la suite
----------------
``pytest tests/ -q`` → 3913 passed, 3 skipped, 3 failed.
Les 3 fails restants sont environnementaux (pas une régression
S1) et seront corrigés au Sprint S2 du rewrite ciblé :
* test_engines.py::TestPeroOCREngine::test_run_without_config_raises
(dépend de Pillow vs pero_ocr non installé) ;
* test_readme_consistency.py::test_readme_test_count_matches_baseline
(sous-processus pytest sans ``pip install -e .``) ;
* test_readme_dual_lang.py::test_readme_tables_consistent_with_code
(idem).

Aucune fonctionnalité supprimée ni renommée. Rétrocompat stricte
sur la signature publique de ``run_benchmark`` (nouveau paramètre
en kwarg avec défaut ``None``) et sur ``DocumentResult.compact()``
(nouveaux paramètres avec défauts conservant l'API actuelle au
prix d'un changement de comportement assumé : compact() devient
no-op pour ne plus saboter le JSON exporté).

Refs : analyse repo + plan rewrite ciblé (S1).
Voir https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/core/metrics.py

@@ -19,17 +19,30 @@ from typing import Optional
 
 @dataclass
 class MetricsResult:
-    """Ensemble des métriques calculées pour une paire (référence, hypothèse)."""
-
-    cer: float
-    cer_nfc: float
-    cer_caseless: float
-    wer: float
-    wer_normalized: float
-    mer: float
-    wil: float
-    reference_length: int
-    hypothesis_length: int
+    """Ensemble des métriques calculées pour une paire (référence, hypothèse).
+
+    Sprint A14-S1 — A.I.0 P0 : les champs CER/WER/MER/WIL sont
+    ``Optional[float]``.  Auparavant, en cas d'erreur de calcul (jiwer
+    absent, exception levée), ces champs étaient remplis avec ``0.0``,
+    ce qui était indistinguable d'un score parfait pour tout
+    consommateur ne lisant pas systématiquement ``error``.  Désormais
+    ils sont à ``None`` quand ``error`` est non-None — les agrégateurs
+    filtrent déjà sur ``error is None``, les rendus HTML utilisent
+    ``safe_round`` qui mappe ``None → 0.0`` à l'affichage seul, et un
+    accès direct sans vérification d'erreur lève désormais un
+    ``TypeError`` explicite plutôt que de retourner silencieusement
+    une valeur factice.
+    """
+
+    cer: Optional[float] = None
+    cer_nfc: Optional[float] = None
+    cer_caseless: Optional[float] = None
+    wer: Optional[float] = None
+    wer_normalized: Optional[float] = None
+    mer: Optional[float] = None
+    wil: Optional[float] = None
+    reference_length: int = 0
+    hypothesis_length: int = 0
     error: Optional[str] = None
     cer_diplomatic: Optional[float] = None
     """CER calculé après normalisation diplomatique (ſ=s, u=v, i=j…).
@@ -39,14 +52,16 @@ class MetricsResult:
     """Nom du profil de normalisation diplomatique utilisé."""
 
     def as_dict(self) -> dict:
+        def _round(v: Optional[float]) -> Optional[float]:
+            return None if v is None else round(v, 6)
         d = {
-            "cer": round(self.cer, 6),
-            "cer_nfc": round(self.cer_nfc, 6),
-            "cer_caseless": round(self.cer_caseless, 6),
-            "wer": round(self.wer, 6),
-            "wer_normalized": round(self.wer_normalized, 6),
-            "mer": round(self.mer, 6),
-            "wil": round(self.wil, 6),
+            "cer": _round(self.cer),
+            "cer_nfc": _round(self.cer_nfc),
+            "cer_caseless": _round(self.cer_caseless),
+            "wer": _round(self.wer),
+            "wer_normalized": _round(self.wer_normalized),
+            "mer": _round(self.mer),
+            "wil": _round(self.wil),
             "reference_length": self.reference_length,
             "hypothesis_length": self.hypothesis_length,
             "error": self.error,
@@ -57,12 +72,12 @@ class MetricsResult:
         return d
 
     @property
-    def cer_percent(self) -> float:
-        return round(self.cer * 100, 2)
+    def cer_percent(self) -> Optional[float]:
+        return None if self.cer is None else round(self.cer * 100, 2)
 
     @property
-    def wer_percent(self) -> float:
-        return round(self.wer * 100, 2)
+    def wer_percent(self) -> Optional[float]:
+        return None if self.wer is None else round(self.wer * 100, 2)
 
 
 def aggregate_metrics(results: list[MetricsResult]) -> dict:
@@ -95,7 +110,17 @@ def aggregate_metrics(results: list[MetricsResult]) -> dict:
     metric_names = ["cer", "cer_nfc", "cer_caseless", "wer", "wer_normalized", "mer", "wil"]
     aggregated: dict = {}
     for metric in metric_names:
-        values = [getattr(r, metric) for r in results if r.error is None]
+        # Sprint A14-S1 — défense en profondeur : double filtre.  Un
+        # MetricsResult avec ``error`` doit avoir ses métriques à
+        # ``None`` (cf. compute_metrics), mais on filtre aussi les
+        # ``None`` directement au cas où un caller construirait un
+        # MetricsResult partiel.
+        values = [
+            v for r in results
+            if r.error is None
+            for v in (getattr(r, metric),)
+            if v is not None
+        ]
         aggregated[metric] = _stats(values)
 
     # CER diplomatique (optionnel — présent seulement si calculé)

picarones/core/results.py

@@ -160,35 +160,70 @@ class DocumentResult:
             d["readability_metrics"] = self.readability_metrics
         return d
 
-    def compact(self) -> None:
+    def compact(
+        self,
+        text_limit: Optional[int] = None,
+        drop_analyses: bool = False,
+    ) -> None:
         """Libère les champs lourds pour réduire l'empreinte mémoire.
 
-        Appelé après que les données ont été sérialisées dans le fichier
-        partiel et que les agrégations ont été calculées.  Les champs
-        ``ground_truth`` et ``hypothesis`` sont tronqués et les analyses
-        détaillées (confusion, taxonomy…) sont supprimées.
+        Sprint A14-S1 — A.I.0 P0 : compaction désormais opt-in.
+        Auparavant, le runner appelait ``compact()`` sans paramètres
+        avant de sérialiser le JSON, ce qui amputait silencieusement
+        toutes les analyses per-document (confusion, taxonomy,
+        philological, searchability, etc.) et tronquait
+        ``ground_truth``/``hypothesis``/``ocr_intermediate`` à 200
+        caractères.  Le rapport HTML — qui consomme ce JSON — recevait
+        des données déjà mutilées, contredisant directement la
+        promesse "self-contained HTML report" du README.
+
+        Désormais, l'appel par défaut ``compact()`` est un **no-op**.
+        Le caller doit explicitement demander la troncature et/ou la
+        suppression des analyses :
+
+        - ``compact(text_limit=200)`` : tronque les textes à 200 chars.
+        - ``compact(drop_analyses=True)`` : supprime les dicts d'analyse.
+        - ``compact(text_limit=200, drop_analyses=True)`` : ancien
+          comportement, à utiliser en pipeline web pour un rendu
+          interactif léger uniquement.
+
+        Le runner (``runner/orchestration.py``) ne compacte plus par
+        défaut ; le JSON exporté contient désormais toutes les
+        analyses détaillées.
+
+        Parameters
+        ----------
+        text_limit:
+            Si fourni (int > 0), tronque ``ground_truth``,
+            ``hypothesis`` et ``ocr_intermediate`` à cette longueur en
+            ajoutant "…".  ``None`` (défaut) = pas de troncature.
+        drop_analyses:
+            Si ``True``, met à ``None`` toutes les analyses
+            per-document (confusion, taxonomy, philological…).  Défaut :
+            ``False`` = on conserve toutes les analyses.
         """
-        # Garder un extrait pour le rapport, libérer le texte complet
-        if len(self.ground_truth) > 200:
-            self.ground_truth = self.ground_truth[:200] + "…"
-        if len(self.hypothesis) > 200:
-            self.hypothesis = self.hypothesis[:200] + "…"
-        if self.ocr_intermediate and len(self.ocr_intermediate) > 200:
-            self.ocr_intermediate = self.ocr_intermediate[:200] + "…"
-        # Les analyses per-document ne sont plus nécessaires après agrégation
-        self.confusion_matrix = None
-        self.char_scores = None
-        self.taxonomy = None
-        self.structure = None
-        self.image_quality = None
-        self.line_metrics = None
-        self.hallucination_metrics = None
-        self.ner_metrics = None
-        self.calibration_metrics = None
-        self.philological_metrics = None
-        self.searchability_metrics = None
-        self.numerical_sequence_metrics = None
-        self.readability_metrics = None
+        if text_limit is not None and text_limit > 0:
+            if len(self.ground_truth) > text_limit:
+                self.ground_truth = self.ground_truth[:text_limit] + "…"
+            if len(self.hypothesis) > text_limit:
+                self.hypothesis = self.hypothesis[:text_limit] + "…"
+            if self.ocr_intermediate and len(self.ocr_intermediate) > text_limit:
+                self.ocr_intermediate = self.ocr_intermediate[:text_limit] + "…"
+
+        if drop_analyses:
+            self.confusion_matrix = None
+            self.char_scores = None
+            self.taxonomy = None
+            self.structure = None
+            self.image_quality = None
+            self.line_metrics = None
+            self.hallucination_metrics = None
+            self.ner_metrics = None
+            self.calibration_metrics = None
+            self.philological_metrics = None
+            self.searchability_metrics = None
+            self.numerical_sequence_metrics = None
+            self.readability_metrics = None
 
 
 @dataclass

picarones/measurements/metrics.py

@@ -104,9 +104,12 @@ def compute_metrics(
         Objet contenant toutes les métriques calculées.
     """
     if not _JIWER_AVAILABLE:
+        # Sprint A14-S1 — A.I.0 P0 : ne pas retourner 0.0 en erreur
+        # (indistinguable d'un score parfait pour un lecteur qui ne
+        # vérifie pas ``error``).  None = absence de mesure.
         return MetricsResult(
-            cer=0.0, cer_nfc=0.0, cer_caseless=0.0,
-            wer=0.0, wer_normalized=0.0, mer=0.0, wil=0.0,
+            cer=None, cer_nfc=None, cer_caseless=None,
+            wer=None, wer_normalized=None, mer=None, wil=None,
             reference_length=len(reference),
             hypothesis_length=len(hypothesis),
             error="jiwer n'est pas installé (pip install jiwer)",
@@ -177,9 +180,11 @@ def compute_metrics(
 
     except Exception as exc:  # noqa: BLE001
         logger.warning("[metrics] calcul métriques échoué : %s", exc)
+        # Sprint A14-S1 — A.I.0 P0 : None plutôt que 0.0 (cf. cas
+        # ``not _JIWER_AVAILABLE`` plus haut pour le rationale).
         return MetricsResult(
-            cer=0.0, cer_nfc=0.0, cer_caseless=0.0,
-            wer=0.0, wer_normalized=0.0, mer=0.0, wil=0.0,
+            cer=None, cer_nfc=None, cer_caseless=None,
+            wer=None, wer_normalized=None, mer=None, wil=None,
             reference_length=len(reference),
             hypothesis_length=len(hypothesis),
             error=str(exc),

picarones/measurements/runner/document.py

@@ -42,6 +42,7 @@ def _compute_document_result(
     char_exclude: Optional[frozenset],
     corpus_lang: str = "fr",
     profile: str = "standard",
+    normalization_profile: Optional[object] = None,
 ) -> DocumentResult:
     """Calcule toutes les métriques pour un document et retourne un DocumentResult.
 
@@ -69,7 +70,15 @@ def _compute_document_result(
     from picarones.core.metric_hooks import run_document_hooks
 
     if ocr_result.success:
-        metrics = compute_metrics(ground_truth, ocr_result.text, char_exclude=char_exclude)
+        # Sprint A14-S1 — A.I.0 P0 : propagation du profil de
+        # normalisation depuis le runner.  ``normalization_profile``
+        # est un ``NormalizationProfile`` résolu en main process par
+        # ``run_benchmark`` (cf. orchestration.py).
+        metrics = compute_metrics(
+            ground_truth, ocr_result.text,
+            normalization_profile=normalization_profile,  # type: ignore[arg-type]
+            char_exclude=char_exclude,
+        )
     else:
         metrics = MetricsResult(
             cer=1.0, cer_nfc=1.0, cer_caseless=1.0,

picarones/measurements/runner/orchestration.py

@@ -64,6 +64,7 @@ def run_benchmark(
     cancel_event: Optional[threading.Event] = None,
     entity_extractor: Optional[callable] = None,
     profile: str = "standard",
+    normalization_profile: Optional[str] = None,
 ) -> BenchmarkResult:
     """Exécute le benchmark d'un ou plusieurs moteurs/pipelines sur un corpus.
 
@@ -119,6 +120,15 @@ def run_benchmark(
         ``"diagnostics"``, ``"economics"``, ``"pipeline"``, ``"full"``.
         Le profil ``"standard"`` est strictement rétrocompatible avec
         le runner pré-chantier-2.
+    normalization_profile:
+        Identifiant d'un profil de normalisation diplomatique
+        (cf. ``measurements.normalization.NORMALIZATION_PROFILES``).
+        Sprint A14-S1 — A.I.0 P0 : auparavant l'API web exposait ce
+        paramètre mais il était silencieusement perdu avant
+        d'atteindre ``compute_metrics``, ce qui rendait
+        scientifiquement faux tout benchmark lancé via la web app.
+        Désormais propagé end-to-end : web → run_benchmark → workers
+        → compute_metrics.  ``None`` = profil par défaut (medieval_french).
 
     Returns
     -------
@@ -135,6 +145,15 @@ def run_benchmark(
     )
     validate_profile(profile)
 
+    # Sprint A14-S1 — résolution one-shot du profil de normalisation.
+    # On le fait ici (main process) pour échouer rapidement sur un ID
+    # invalide avant de soumettre des futures aux pools, et pour
+    # éviter de re-résoudre N fois côté workers.
+    norm_profile_obj = None
+    if normalization_profile is not None:
+        from picarones.measurements.normalization import get_builtin_profile
+        norm_profile_obj = get_builtin_profile(normalization_profile)
+
     def _is_cancelled() -> bool:
         return cancel_event is not None and cancel_event.is_set()
     engine_reports: list[EngineReport] = []
@@ -225,12 +244,13 @@ def run_benchmark(
                         _cpu_doc_worker,
                         (engine_module, engine_class_name, engine.config,
                          doc.doc_id, str(doc.image_path), doc.ground_truth,
-                         char_exclude_tuple, corpus_lang, profile),
+                         char_exclude_tuple, corpus_lang, profile,
+                         norm_profile_obj),
                     )
                 else:
                     future = executor.submit(
                         _io_doc_worker, engine, doc, char_exclude,
-                        corpus_lang, profile,
+                        corpus_lang, profile, norm_profile_obj,
                     )
                 future_to_doc[future] = doc
                 submitted_at[future] = time.monotonic()
@@ -397,9 +417,17 @@ def run_benchmark(
             agg_ner = _aggregate_ner(document_results)
             report.aggregated_ner = agg_ner
 
-        # Libérer la mémoire des analyses per-document après agrégation
-        for dr in document_results:
-            dr.compact()
+        # Sprint A14-S1 — A.I.0 P0 : la compaction inconditionnelle qui
+        # vivait ici amputait silencieusement le JSON exporté (et donc
+        # le rapport HTML qui le consomme) en supprimant 13 dicts
+        # d'analyse per-document et en tronquant les textes à 200 chars.
+        # ``DocumentResult.compact()`` est désormais opt-in (paramètres
+        # ``text_limit`` et ``drop_analyses``) ; le runner ne compacte
+        # plus par défaut afin que ``output_json`` contienne réellement
+        # toutes les analyses détaillées promises par le README.
+        # Un caller qui veut un JSON léger peut appeler
+        # ``dr.compact(text_limit=200, drop_analyses=True)`` lui-même
+        # après ``run_benchmark`` et avant la sérialisation finale.
 
     # Sprint 36 — analyse inter-moteurs (divergence taxonomique +
     # complémentarité / oracle).  N'est calculée qu'à partir de 2

picarones/measurements/runner/workers.py

@@ -33,8 +33,14 @@ def _cpu_doc_worker(args: tuple) -> "DocumentResult":
     - 7 éléments : legacy (Sprint 13)
     - 8 éléments : + ``corpus_lang`` (Sprint 87)
     - 9 éléments : + ``profile`` (chantier 2 post-Sprint 97)
+    - 10 éléments : + ``normalization_profile`` (Sprint A14-S1, A.I.0 P0)
     """
-    if len(args) == 9:
+    norm_profile = None
+    if len(args) == 10:
+        (engine_module, engine_class_name, engine_config, doc_id,
+         image_path, ground_truth, char_exclude_chars, corpus_lang,
+         profile, norm_profile) = args
+    elif len(args) == 9:
         (engine_module, engine_class_name, engine_config, doc_id,
          image_path, ground_truth, char_exclude_chars, corpus_lang,
          profile) = args
@@ -61,6 +67,7 @@ def _cpu_doc_worker(args: tuple) -> "DocumentResult":
         char_exclude=char_exclude,
         corpus_lang=corpus_lang,
         profile=profile,
+        normalization_profile=norm_profile,
     )
 
 
@@ -70,6 +77,7 @@ def _io_doc_worker(
     char_exclude: Optional[frozenset],
     corpus_lang: str = "fr",
     profile: str = "standard",
+    normalization_profile: Optional[object] = None,
 ) -> "DocumentResult":
     """Worker pour ThreadPoolExecutor (moteurs IO-bound / API).
 
@@ -101,6 +109,7 @@ def _io_doc_worker(
         char_exclude=char_exclude,
         corpus_lang=corpus_lang,
         profile=profile,
+        normalization_profile=normalization_profile,
     )
 
 

picarones/web/benchmark_utils.py

@@ -176,9 +176,15 @@ def run_benchmark_thread_v2(job: BenchmarkJob, req: BenchmarkRunRequest) -> None
         if not engines:
             raise ValueError("Aucun concurrent valide disponible.")
 
+        # Sprint A14-S1 — A.I.0 P0 : ``output_dir`` a déjà été validé
+        # par le router (validated_path).  ``report_name`` est sanitizé
+        # ici pour défense en profondeur (refuse ``../``, séparateurs,
+        # caractères de contrôle) avant concaténation à output_dir.
+        from picarones.web.security import safe_report_name
         output_dir = Path(req.output_dir)
         output_dir.mkdir(parents=True, exist_ok=True)
-        report_name = req.report_name or f"rapport_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        raw_name = req.report_name or f"rapport_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        report_name = safe_report_name(raw_name)
         output_json = str(output_dir / f"{report_name}.json")
         output_html = str(output_dir / f"{report_name}.html")
 
@@ -213,6 +219,7 @@ def run_benchmark_thread_v2(job: BenchmarkJob, req: BenchmarkRunRequest) -> None
             progress_callback=_progress_callback,
             char_exclude=char_excl,
             cancel_event=job._cancel_event,
+            normalization_profile=req.normalization_profile,
         )
 
         if job.status == "cancelled":
@@ -276,9 +283,15 @@ def run_benchmark_thread(job: BenchmarkJob, req: BenchmarkRequest) -> None:
             raise ValueError("Aucun moteur valide disponible.")
 
         # Répertoire de sortie
+        # Sprint A14-S1 — A.I.0 P0 : ``output_dir`` a déjà été validé
+        # par le router (validated_path).  ``report_name`` est sanitizé
+        # ici pour défense en profondeur (refuse ``../``, séparateurs,
+        # caractères de contrôle) avant concaténation à output_dir.
+        from picarones.web.security import safe_report_name
         output_dir = Path(req.output_dir)
         output_dir.mkdir(parents=True, exist_ok=True)
-        report_name = req.report_name or f"rapport_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        raw_name = req.report_name or f"rapport_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        report_name = safe_report_name(raw_name)
         output_json = str(output_dir / f"{report_name}.json")
         output_html = str(output_dir / f"{report_name}.html")
 
@@ -314,6 +327,7 @@ def run_benchmark_thread(job: BenchmarkJob, req: BenchmarkRequest) -> None:
             progress_callback=_progress_callback,
             char_exclude=char_excl,
             cancel_event=job._cancel_event,
+            normalization_profile=req.normalization_profile,
         )
 
         if job.status == "cancelled":

picarones/web/models.py

@@ -57,8 +57,15 @@ NormalizationProfileId = Literal[
     "medieval_french", "early_modern_french",
     "medieval_latin",
     "early_modern_english", "medieval_english",
+    "secretary_hand",
+    "sans_ponctuation", "sans_apostrophes",
 ]
-"""Identifiants des profils de normalisation Unicode disponibles."""
+"""Identifiants des profils de normalisation Unicode disponibles.
+
+Liste alignée sur ``measurements.normalization.NORMALIZATION_PROFILES``
+(11 profils). Toute addition côté ``normalization.py`` doit être
+répercutée ici sous peine de rejet Pydantic au niveau API web.
+Sprint A14-S1 — alignement README ↔ web models ↔ runtime."""
 
 
 class BenchmarkRequest(BaseModel):

picarones/web/routers/benchmark.py

@@ -25,10 +25,15 @@ from picarones.web.benchmark_utils import (
 )
 from picarones.web.models import BenchmarkRequest, BenchmarkRunRequest
 from picarones.web.security import (
+    PathValidationError,
     assert_engines_allowed,
     assert_llm_provider_allowed,
+    compute_workspace_roots,
     get_max_concurrent_jobs,
+    validated_path,
+    validated_prompt_filename,
 )
+from picarones.web.state import UPLOADS_DIR
 
 router = APIRouter()
 
@@ -61,18 +66,35 @@ def _start_job_thread(
 @router.post("/api/benchmark/start")
 async def api_benchmark_start(req: BenchmarkRequest, request: Request) -> dict:
     """Lance un benchmark sur une liste de moteurs OCR (mode legacy)."""
-    corpus_path = Path(req.corpus_path)
-    if not corpus_path.exists() or not corpus_path.is_dir():
-        raise HTTPException(
-            status_code=400, detail=f"Corpus non trouvé : {req.corpus_path}",
-        )
-
     # Sprint 24 — mode public : refuse les moteurs OCR cloud mutualisés.
+    # Vérifié AVANT la validation des chemins pour que la réponse
+    # 403 mode public reste prioritaire (cf. tests sprint24).
     try:
         assert_engines_allowed(req.engines)
     except PermissionError as exc:
         raise HTTPException(status_code=403, detail=str(exc))
 
+    # Sprint A14-S1 — A.I.0 P0 : validation des chemins utilisateur
+    # contre les racines workspace autorisées.  Bloque les chemins
+    # absolus arbitraires, la traversée (``..``), les liens symboliques
+    # vers l'extérieur, etc.
+    workspace_roots = compute_workspace_roots(UPLOADS_DIR)
+    try:
+        validated_path(
+            req.corpus_path,
+            allowed_roots=workspace_roots,
+            must_be_dir=True,
+        )
+        # ``output_dir`` peut ne pas encore exister, on valide juste
+        # qu'il sera créé dans une racine autorisée.
+        validated_path(
+            req.output_dir,
+            allowed_roots=workspace_roots,
+            must_exist=False,
+        )
+    except PathValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
     # Sprint 24 — rate limit + sémaphore concurrents.
     state.enforce_rate_limit(request)
     if not state.JOBS_SEMAPHORE.acquire(blocking=False):
@@ -105,15 +127,12 @@ async def api_benchmark_run(req: BenchmarkRunRequest, request: Request) -> dict:
     Chaque ``CompetitorConfig`` peut combiner un moteur OCR et un
     provider LLM (mode post-correction, zero-shot, ou OCR seul).
     """
-    corpus_path = Path(req.corpus_path)
-    if not corpus_path.exists() or not corpus_path.is_dir():
-        raise HTTPException(
-            status_code=400, detail=f"Corpus non trouvé : {req.corpus_path}",
-        )
     # ``competitors`` non vide est garanti par Pydantic ``min_length=1``.
 
     # Mode public : refuse les pipelines LLM mutualisés et les moteurs
     # OCR cloud sollicités par n'importe quel concurrent.
+    # Vérifié AVANT la validation des chemins (cf. /api/benchmark/start
+    # pour le rationale).
     try:
         for comp in req.competitors:
             assert_engines_allowed([comp.ocr_engine] if comp.ocr_engine else [])
@@ -121,6 +140,31 @@ async def api_benchmark_run(req: BenchmarkRunRequest, request: Request) -> dict:
     except PermissionError as exc:
         raise HTTPException(status_code=403, detail=str(exc))
 
+    # Sprint A14-S1 — A.I.0 P0 : validation des chemins utilisateur
+    # (cf. /api/benchmark/start).  Idempotent : refuse un corpus_path
+    # absolu hors workspaces, et refuse un output_dir qui s'évaderait
+    # via ``..`` ou symlinks.
+    workspace_roots = compute_workspace_roots(UPLOADS_DIR)
+    try:
+        validated_path(
+            req.corpus_path,
+            allowed_roots=workspace_roots,
+            must_be_dir=True,
+        )
+        validated_path(
+            req.output_dir,
+            allowed_roots=workspace_roots,
+            must_exist=False,
+        )
+        # Sprint A14-S1 — restriction des prompts à la bibliothèque
+        # intégrée (``picarones/prompts/``).  Cf. validated_prompt_filename
+        # pour le rationale (vecteur d'exfiltration via LLM).
+        for comp in req.competitors:
+            if comp.prompt_file:
+                validated_prompt_filename(comp.prompt_file)
+    except PathValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
     # Sprint 24 — rate limit + sémaphore concurrents.
     state.enforce_rate_limit(request)
     if not state.JOBS_SEMAPHORE.acquire(blocking=False):

picarones/web/security.py

@@ -96,6 +96,188 @@ def assert_llm_provider_allowed(llm_provider: str) -> None:
         )
 
 
+# ---------------------------------------------------------------------------
+# Validation des chemins utilisateur (Sprint A14-S1, A.I.0 P0)
+# ---------------------------------------------------------------------------
+
+class PathValidationError(ValueError):
+    """Levée quand un chemin utilisateur sort de la zone autorisée."""
+
+
+def validated_path(
+    user_path: str,
+    allowed_roots: list[Path],
+    must_exist: bool = False,
+    must_be_dir: bool = False,
+) -> Path:
+    """Résout un chemin utilisateur et vérifie qu'il reste dans une racine autorisée.
+
+    Garde-fou central contre la traversée de répertoires (path traversal)
+    et l'écriture/lecture arbitraire dans le système de fichiers du
+    serveur.  Avant ce sprint, les endpoints ``/api/benchmark/*``
+    acceptaient n'importe quel ``corpus_path`` ou ``output_dir`` validé
+    uniquement par ``Path.exists()`` — ce qui permettait à un client
+    de pousser le serveur à lire/écrire en dehors de ses propres
+    workspaces, dans la limite des permissions du process.
+
+    Algorithme :
+
+    1. Refuse les chemins vides ou contenant des octets nuls.
+    2. Résout le chemin de manière absolue (``Path.resolve()``) — ça
+       écrase ``..``, les liens symboliques et les chemins relatifs.
+    3. Vérifie que le résultat est ``.is_relative_to(root)`` pour au
+       moins une des ``allowed_roots`` (elles aussi pré-résolues).
+    4. Optionnellement : vérifie l'existence et le type (dir).
+
+    Parameters
+    ----------
+    user_path:
+        Chemin tel que reçu de l'utilisateur (str).  Peut être absolu
+        ou relatif.
+    allowed_roots:
+        Liste de répertoires racines (``Path``) au sein desquels le
+        chemin résolu doit se trouver.  Liste vide = tout refuser.
+    must_exist:
+        Si ``True``, exige que le chemin résolu existe sur le disque
+        après validation.
+    must_be_dir:
+        Si ``True``, exige que le chemin résolu existe ET soit un
+        répertoire.  Implique ``must_exist=True``.
+
+    Returns
+    -------
+    Path
+        Chemin résolu absolu, garanti dans une des racines autorisées.
+
+    Raises
+    ------
+    PathValidationError
+        Si le chemin est vide, contient un octet nul, sort des racines
+        autorisées, ou ne satisfait pas ``must_exist`` / ``must_be_dir``.
+    """
+    if not user_path or not user_path.strip():
+        raise PathValidationError("Chemin vide.")
+    if "\x00" in user_path:
+        raise PathValidationError("Chemin contient un octet nul.")
+    if not allowed_roots:
+        raise PathValidationError(
+            "Aucune racine autorisée — refus de toute requête de chemin."
+        )
+
+    try:
+        resolved = Path(user_path).expanduser().resolve()
+    except (OSError, RuntimeError) as exc:
+        raise PathValidationError(f"Chemin invalide : {exc}") from exc
+
+    resolved_roots = [Path(r).expanduser().resolve() for r in allowed_roots]
+    if not any(_is_within(resolved, root) for root in resolved_roots):
+        raise PathValidationError(
+            f"Chemin hors zone autorisée : {user_path!r}.  "
+            f"Racines acceptées : {[str(r) for r in resolved_roots]}."
+        )
+
+    if must_be_dir or must_exist:
+        if not resolved.exists():
+            raise PathValidationError(f"Chemin inexistant : {user_path!r}.")
+    if must_be_dir and not resolved.is_dir():
+        raise PathValidationError(f"Chemin n'est pas un répertoire : {user_path!r}.")
+
+    return resolved
+
+
+def _is_within(child: Path, parent: Path) -> bool:
+    """Vrai si ``child`` est ``parent`` ou un descendant.
+
+    ``Path.is_relative_to`` n'apparaît qu'en Python 3.9 — on l'utilise
+    via try/except pour rester explicite sur l'intention sans
+    dépendre du comportement exact de la stdlib selon la version.
+    """
+    try:
+        child.relative_to(parent)
+        return True
+    except ValueError:
+        return False
+
+
+def validated_prompt_filename(name: str) -> str:
+    """Valide qu'un ``prompt_file`` web est un simple nom de fichier sûr.
+
+    Sprint A14-S1 — A.I.0 P0 : le pipeline OCR+LLM lit un prompt
+    depuis le disque via ``picarones.pipelines.base._load_prompt``,
+    qui acceptait n'importe quel chemin absolu existant.  En contexte
+    web, ça permettait à un utilisateur d'API de pousser le serveur à
+    lire un fichier arbitraire (``/etc/passwd``, ``.env``, etc.) puis
+    à l'envoyer comme prompt à un LLM externe — vecteur classique
+    d'exfiltration via tokens.
+
+    Cette fonction restreint la valeur reçue à un simple nom de
+    fichier de la **bibliothèque de prompts intégrée**
+    (``picarones/prompts/``).  Pas de ``/``, pas de ``\\``, pas de
+    ``..``, pas d'absolu.
+
+    Le caller (web layer) est responsable d'appeler cette fonction
+    AVANT de transmettre la valeur au pipeline.
+
+    Returns
+    -------
+    str
+        Nom de fichier validé (basename uniquement).
+
+    Raises
+    ------
+    PathValidationError
+        Si la valeur contient un séparateur de chemin, un caractère de
+        contrôle, ou ressemble à un chemin absolu/relatif suspect.
+    """
+    if not name:
+        raise PathValidationError("Nom de prompt vide.")
+    if "\x00" in name:
+        raise PathValidationError("Nom de prompt contient un octet nul.")
+    if any(c in name for c in ("/", "\\")):
+        raise PathValidationError(
+            f"Nom de prompt invalide (séparateur de chemin) : {name!r}.  "
+            "Le web n'accepte que les prompts de la bibliothèque intégrée "
+            "(``picarones/prompts/``) — fournir le simple nom de fichier."
+        )
+    if name.startswith(".") or ".." in name:
+        raise PathValidationError(
+            f"Nom de prompt suspect : {name!r}.  "
+            "Refus des préfixes ``.`` et des séquences ``..``."
+        )
+    if any(ord(c) < 0x20 for c in name):
+        raise PathValidationError("Nom de prompt contient un caractère de contrôle.")
+    return name
+
+
+def safe_report_name(name: str, max_length: int = 128) -> str:
+    """Sanitize un nom de rapport utilisateur en composant de chemin sûr.
+
+    Refuse les séparateurs de chemin (``/``, ``\\``), les caractères
+    de contrôle, les octets nuls.  Tronque à ``max_length``.  Si la
+    chaîne devient vide après nettoyage, lève ``PathValidationError``.
+
+    Cette fonction NE produit PAS un chemin — elle produit un nom
+    qu'un caller peut concaténer à un répertoire qu'il a déjà validé
+    avec ``validated_path``.
+    """
+    if not name:
+        raise PathValidationError("Nom de rapport vide.")
+    if "\x00" in name:
+        raise PathValidationError("Nom de rapport contient un octet nul.")
+    # Refus explicite de tout séparateur de chemin et de caractères de contrôle.
+    bad = set("/\\")
+    cleaned = "".join(
+        c for c in name
+        if c not in bad and ord(c) >= 0x20
+    )
+    cleaned = cleaned.strip().strip(".")  # pas de "." en début/fin (caché Unix, extension forçée)
+    if not cleaned:
+        raise PathValidationError(f"Nom de rapport invalide après nettoyage : {name!r}.")
+    if cleaned in (".", "..", ""):
+        raise PathValidationError(f"Nom de rapport réservé : {name!r}.")
+    return cleaned[:max_length]
+
+
 # ---------------------------------------------------------------------------
 # Browse roots
 # ---------------------------------------------------------------------------
@@ -126,6 +308,43 @@ def compute_browse_roots(uploads_dir: Path) -> list[Path]:
     ]
 
 
+def compute_workspace_roots(uploads_dir: Path) -> list[Path]:
+    """Retourne les racines autorisées pour les opérations de benchmark.
+
+    Sprint A14-S1 — A.I.0 P0 : utilisé par les endpoints
+    ``/api/benchmark/start`` et ``/api/benchmark/run`` pour valider
+    ``corpus_path`` et ``output_dir`` via :func:`validated_path`.
+
+    Sémantique :
+
+    - Si ``PICARONES_WORKSPACE_ROOTS`` est défini, prend précédence
+      absolue (admin sait ce qu'il fait).
+    - Sinon, en mode public : uniquement ``uploads_dir`` (lecture)
+      et ``./rapports`` (écriture des rapports générés).
+    - Sinon, mode dev : ``compute_browse_roots`` + ``./rapports`` +
+      ``./corpus`` (corpus locaux des développeurs).
+
+    En production institutionnelle, exporter ``PICARONES_WORKSPACE_ROOTS``
+    pour épingler explicitement les répertoires autorisés.
+    """
+    raw = os.environ.get("PICARONES_WORKSPACE_ROOTS")
+    if raw:
+        return [Path(p).expanduser().resolve() for p in raw.split(os.pathsep) if p.strip()]
+
+    base = compute_browse_roots(uploads_dir)
+    extras = [
+        Path("./rapports").resolve(),
+        Path("./corpus").resolve(),
+    ]
+    seen: set[Path] = set()
+    out: list[Path] = []
+    for p in base + extras:
+        if p not in seen:
+            seen.add(p)
+            out.append(p)
+    return out
+
+
 # ---------------------------------------------------------------------------
 # Validation des images uploadées
 # ---------------------------------------------------------------------------

tests/architecture/test_file_budgets.py

@@ -63,7 +63,11 @@ FILE_BUDGETS: dict[str, int] = {
     "picarones/extras/importers/gallica.py": 675,         # actuel 563
     "picarones/measurements/levers.py": 675,              # actuel 561
     "picarones/extras/importers/escriptorium.py": 650,    # actuel 553
-    "picarones/web/security.py": 625,                     # actuel 532
+    # Sprint A14-S1 — A.I.0 P0 : ajout de validated_path,
+    # validated_prompt_filename, safe_report_name et compute_workspace_roots.
+    # Ces helpers seront extraits dans ``picarones/web/path_security.py``
+    # lors du Sprint S20 du rewrite ciblé (création couche app/services/).
+    "picarones/web/security.py": 800,                     # actuel 751
     "picarones/core/corpus.py": 600,                      # actuel 511
     "picarones/fixtures.py": 600,                         # actuel 510
     "picarones/measurements/inter_engine.py": 575,        # actuel 484

tests/core/test_sprint_a14_s1_compact_optin.py

@@ -0,0 +1,137 @@
+"""Sprint A14-S1 — A.I.0 P0 : ``DocumentResult.compact()`` est opt-in.
+
+Avant ce sprint, le runner appelait ``dr.compact()`` sans argument
+avant de sérialiser le JSON, ce qui :
+
+- tronquait ``ground_truth``, ``hypothesis`` et ``ocr_intermediate``
+  à 200 caractères ;
+- effaçait 13 dicts d'analyse per-document (confusion, taxonomy,
+  philological, searchability, etc.).
+
+Le rapport HTML — qui consomme ce JSON — recevait des données déjà
+mutilées, contredisant la promesse "self-contained HTML report" du
+README.
+
+Désormais, ``compact()`` est no-op par défaut.  Le caller doit
+explicitement demander la troncature via ``text_limit`` et/ou la
+suppression des analyses via ``drop_analyses=True``.
+"""
+
+from __future__ import annotations
+
+from picarones.core.metrics import MetricsResult
+from picarones.core.results import DocumentResult
+
+
+def _make_dr(**kwargs) -> DocumentResult:
+    base = dict(
+        doc_id="d1",
+        image_path="x.png",
+        ground_truth="A" * 1000,
+        hypothesis="B" * 1000,
+        metrics=MetricsResult(cer=0.1, wer=0.1, error=None),
+        duration_seconds=0.1,
+        confusion_matrix={"k": "v"},
+        char_scores={"ligature": {"score": 0.9}},
+        taxonomy={"class": "v"},
+        structure={"k": "v"},
+        image_quality={"k": "v"},
+        line_metrics={"k": "v"},
+        hallucination_metrics={"k": "v"},
+        ner_metrics={"k": "v"},
+        calibration_metrics={"k": "v"},
+        philological_metrics={"k": "v"},
+        searchability_metrics={"k": "v"},
+        numerical_sequence_metrics={"k": "v"},
+        readability_metrics={"k": "v"},
+        ocr_intermediate="C" * 1000,
+    )
+    base.update(kwargs)
+    return DocumentResult(**base)
+
+
+class TestCompactDefaultIsNoOp:
+    def test_default_call_does_not_truncate_text(self) -> None:
+        dr = _make_dr()
+        before_gt = dr.ground_truth
+        before_hyp = dr.hypothesis
+        before_ocr = dr.ocr_intermediate
+        dr.compact()
+        assert dr.ground_truth == before_gt
+        assert dr.hypothesis == before_hyp
+        assert dr.ocr_intermediate == before_ocr
+
+    def test_default_call_preserves_all_analyses(self) -> None:
+        dr = _make_dr()
+        dr.compact()
+        for field in (
+            "confusion_matrix", "char_scores", "taxonomy", "structure",
+            "image_quality", "line_metrics", "hallucination_metrics",
+            "ner_metrics", "calibration_metrics", "philological_metrics",
+            "searchability_metrics", "numerical_sequence_metrics",
+            "readability_metrics",
+        ):
+            assert getattr(dr, field) is not None, (
+                f"{field} a été effacé alors que ``compact()`` est "
+                "censé être no-op par défaut depuis Sprint A14-S1."
+            )
+
+
+class TestCompactTextLimit:
+    def test_text_limit_truncates_ground_truth(self) -> None:
+        dr = _make_dr()
+        dr.compact(text_limit=200)
+        assert len(dr.ground_truth) == 201  # 200 + ellipsis
+
+    def test_text_limit_truncates_hypothesis(self) -> None:
+        dr = _make_dr()
+        dr.compact(text_limit=50)
+        assert len(dr.hypothesis) == 51
+
+    def test_text_limit_truncates_ocr_intermediate(self) -> None:
+        dr = _make_dr()
+        dr.compact(text_limit=100)
+        assert len(dr.ocr_intermediate) == 101
+
+    def test_text_limit_zero_or_none_is_noop(self) -> None:
+        dr = _make_dr()
+        dr.compact(text_limit=0)
+        assert len(dr.ground_truth) == 1000
+        dr2 = _make_dr()
+        dr2.compact(text_limit=None)
+        assert len(dr2.ground_truth) == 1000
+
+    def test_text_limit_does_not_truncate_short_text(self) -> None:
+        dr = _make_dr(ground_truth="short", hypothesis="also short")
+        dr.compact(text_limit=200)
+        assert dr.ground_truth == "short"
+        assert dr.hypothesis == "also short"
+
+
+class TestCompactDropAnalyses:
+    def test_drop_analyses_clears_all_thirteen_fields(self) -> None:
+        dr = _make_dr()
+        dr.compact(drop_analyses=True)
+        for field in (
+            "confusion_matrix", "char_scores", "taxonomy", "structure",
+            "image_quality", "line_metrics", "hallucination_metrics",
+            "ner_metrics", "calibration_metrics", "philological_metrics",
+            "searchability_metrics", "numerical_sequence_metrics",
+            "readability_metrics",
+        ):
+            assert getattr(dr, field) is None, f"{field} aurait dû être effacé"
+
+    def test_drop_analyses_alone_preserves_text(self) -> None:
+        dr = _make_dr()
+        dr.compact(drop_analyses=True)  # pas de text_limit
+        assert len(dr.ground_truth) == 1000
+        assert len(dr.hypothesis) == 1000
+
+    def test_combined_legacy_behavior(self) -> None:
+        """``compact(text_limit=200, drop_analyses=True)`` reproduit
+        l'ancien comportement par défaut (avant Sprint A14-S1)."""
+        dr = _make_dr()
+        dr.compact(text_limit=200, drop_analyses=True)
+        assert len(dr.ground_truth) == 201
+        assert dr.confusion_matrix is None
+        assert dr.philological_metrics is None

tests/core/test_sprint_a14_s1_metrics_error_returns_none.py

@@ -0,0 +1,121 @@
+"""Sprint A14-S1 — A.I.0 P0 : compute_metrics retourne None en cas d'erreur.
+
+Avant ce sprint, ``compute_metrics`` retournait des ``MetricsResult``
+avec ``cer=0.0, wer=0.0, ...`` quand jiwer était indisponible ou qu'une
+exception était levée.  Pour tout consommateur qui n'inspectait pas
+``error``, ces zéros étaient indistinguables d'un score parfait — soit
+l'inverse exact de la réalité (échec total = "100 % d'accord avec la
+GT").
+
+Désormais, en erreur, les champs métriques sont à ``None`` et ``error``
+porte le message.  Un accès direct à ``result.cer`` sur un résultat en
+erreur lèvera désormais ``TypeError`` lors d'opérations numériques
+(``cer * 100``), ce qui est l'effet voulu : un crash explicite plutôt
+qu'une valeur factice.
+"""
+
+from __future__ import annotations
+
+from unittest import mock
+
+import pytest
+
+from picarones.core.metrics import MetricsResult, aggregate_metrics
+from picarones.measurements import metrics as metrics_module
+from picarones.measurements.metrics import compute_metrics
+
+
+class TestComputeMetricsErrorPath:
+    def test_jiwer_missing_returns_none_metrics(self) -> None:
+        """Si jiwer absent, tous les champs sont None et error est set."""
+        with mock.patch.object(metrics_module, "_JIWER_AVAILABLE", False):
+            result = compute_metrics("référence", "hypothèse")
+        assert result.cer is None
+        assert result.cer_nfc is None
+        assert result.cer_caseless is None
+        assert result.wer is None
+        assert result.wer_normalized is None
+        assert result.mer is None
+        assert result.wil is None
+        assert result.error is not None
+        assert "jiwer" in result.error.lower()
+
+    def test_jiwer_exception_returns_none_metrics(self) -> None:
+        """Si jiwer lève, on retombe dans le bloc except et on retourne None."""
+        with mock.patch.object(
+            metrics_module, "_cer_from_strings",
+            side_effect=RuntimeError("simulated jiwer crash"),
+        ):
+            result = compute_metrics("a", "b")
+        assert result.cer is None
+        assert result.wer is None
+        assert result.error is not None
+        assert "simulated jiwer crash" in result.error
+
+    def test_no_silent_zero_when_error_set(self) -> None:
+        """Garde-fou : aucun champ ne doit être 0.0 si error est non-None.
+
+        Verrouille le bug exact que ce sprint corrige (0.0 indistinguable
+        d'un score parfait dans le JSON exporté).
+        """
+        with mock.patch.object(metrics_module, "_JIWER_AVAILABLE", False):
+            result = compute_metrics("référence", "hypothèse")
+        assert result.error is not None
+        for field in ("cer", "cer_nfc", "cer_caseless", "wer",
+                      "wer_normalized", "mer", "wil"):
+            assert getattr(result, field) is None, (
+                f"{field} = {getattr(result, field)!r} (devrait être None "
+                "puisque error est non-None)"
+            )
+
+
+class TestMetricsResultPropertiesHandleNone:
+    def test_cer_percent_handles_none(self) -> None:
+        r = MetricsResult(error="boom")
+        assert r.cer_percent is None
+
+    def test_wer_percent_handles_none(self) -> None:
+        r = MetricsResult(error="boom")
+        assert r.wer_percent is None
+
+    def test_as_dict_handles_none(self) -> None:
+        r = MetricsResult(error="boom")
+        d = r.as_dict()
+        assert d["cer"] is None
+        assert d["wer"] is None
+        assert d["error"] == "boom"
+
+    def test_as_dict_rounds_when_set(self) -> None:
+        r = MetricsResult(cer=0.123456789, wer=0.456789, error=None)
+        d = r.as_dict()
+        assert d["cer"] == 0.123457  # 6 décimales
+        assert d["wer"] == 0.456789
+
+
+class TestAggregateMetricsFiltersNoneAndError:
+    def test_aggregator_excludes_results_with_error(self) -> None:
+        ok = MetricsResult(cer=0.1, wer=0.2, mer=0.15, wil=0.25, error=None)
+        ko = MetricsResult(error="boom")  # cer/wer/etc tous None
+        agg = aggregate_metrics([ok, ko])
+        # Seul le résultat OK contribue à la moyenne.
+        assert agg["cer"]["mean"] == 0.1
+        assert agg["wer"]["mean"] == 0.2
+        assert agg["failed_count"] == 1
+        assert agg["document_count"] == 2
+
+    def test_aggregator_robust_to_partial_none(self) -> None:
+        """Défense en profondeur : un caller pourrait construire un
+        MetricsResult avec des None sans avoir set ``error``.  On ne
+        plante pas, on saute simplement les None."""
+        partial = MetricsResult(cer=0.05, wer=None, mer=None, wil=None, error=None)
+        agg = aggregate_metrics([partial])
+        assert agg["cer"]["mean"] == 0.05
+        # WER absent → stats vides plutôt que NaN.
+        assert agg["wer"] == {}
+
+    def test_aggregator_empty_when_all_errors(self) -> None:
+        errs = [MetricsResult(error="x"), MetricsResult(error="y")]
+        agg = aggregate_metrics(errs)
+        assert agg["cer"] == {}
+        assert agg["failed_count"] == 2
+        assert agg["document_count"] == 2

tests/measurements/test_sprint40_ner_runner.py

@@ -126,10 +126,20 @@ class TestModelSerialization:
         assert d["ner_metrics"] == {"global": {"f1": 0.8}}
 
     def test_compact_clears_ner_metrics(self) -> None:
+        # Sprint A14-S1 — A.I.0 P0 : ``compact()`` est désormais no-op
+        # par défaut (cf. core/results.py).  Le comportement
+        # "efface les analyses" est explicitement opt-in via
+        # ``drop_analyses=True``.
         dr = _make_document_result(ner_metrics={"global": {"f1": 0.8}})
-        dr.compact()
+        dr.compact(drop_analyses=True)
         assert dr.ner_metrics is None
 
+    def test_compact_default_is_noop(self) -> None:
+        """Sprint A14-S1 — défaut sans argument ne touche à rien."""
+        dr = _make_document_result(ner_metrics={"global": {"f1": 0.8}})
+        dr.compact()
+        assert dr.ner_metrics == {"global": {"f1": 0.8}}
+
     def test_engine_report_aggregated_ner_omitted_when_none(self) -> None:
         rep = EngineReport(
             engine_name="t", engine_version="1", engine_config={},

tests/measurements/test_sprint42_calibration_runner.py

@@ -84,8 +84,9 @@ class TestModelsSerialization:
         assert d["calibration_metrics"] == {"ece": 0.05, "mce": 0.1}
 
     def test_compact_clears_calibration(self) -> None:
+        # Sprint A14-S1 — ``compact()`` est désormais opt-in.
         dr = _make_dr({"ece": 0.05})
-        dr.compact()
+        dr.compact(drop_analyses=True)
         assert dr.calibration_metrics is None
 
     def test_engine_report_aggregated_calibration_omitted_when_none(self) -> None:

tests/measurements/test_sprint61_philological_runner.py

@@ -124,8 +124,9 @@ class TestSerialization:
 
 class TestCompact:
     def test_compact_clears_philological(self) -> None:
+        # Sprint A14-S1 — opt-in via drop_analyses=True.
         dr = _make_doc(philological={"mufi": {"coverage": 1.0}})
-        dr.compact()
+        dr.compact(drop_analyses=True)
         assert dr.philological_metrics is None
 
 

tests/measurements/test_sprint_a14_s1_normalization_propagation.py

@@ -0,0 +1,121 @@
+"""Sprint A14-S1 — A.I.0 P0 : ``normalization_profile`` propagé end-to-end.
+
+Avant ce sprint, le paramètre ``normalization_profile`` était :
+
+- exposé par l'API web (``BenchmarkRequest`` / ``BenchmarkRunRequest``) ;
+- transporté jusqu'à ``benchmark_utils.run_benchmark_thread*`` ;
+- **silencieusement ignoré** : jamais transmis à ``run_benchmark`` ;
+- ``run_benchmark`` n'avait même pas le paramètre dans sa signature.
+
+Conséquence : tout benchmark lancé depuis l'API web utilisait le
+profil par défaut (``medieval_french``) quel que soit le choix
+utilisateur.  L'option de l'UI était un faux bouton.
+
+Ce module verrouille la propagation depuis la signature publique de
+``run_benchmark`` jusqu'à ``compute_metrics`` via les workers.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+from picarones.measurements.normalization import (
+    NORMALIZATION_PROFILES,
+    get_builtin_profile,
+)
+from picarones.measurements.runner import run_benchmark
+from picarones.measurements.runner.document import _compute_document_result
+from picarones.measurements.runner.workers import (
+    _cpu_doc_worker,
+    _io_doc_worker,
+)
+
+
+class TestRunBenchmarkSignature:
+    def test_run_benchmark_accepts_normalization_profile(self) -> None:
+        """La signature publique doit exposer ``normalization_profile``."""
+        sig = inspect.signature(run_benchmark)
+        assert "normalization_profile" in sig.parameters
+        # Et avec une valeur par défaut sûre.
+        assert sig.parameters["normalization_profile"].default is None
+
+    def test_io_worker_accepts_normalization_profile(self) -> None:
+        sig = inspect.signature(_io_doc_worker)
+        assert "normalization_profile" in sig.parameters
+
+    def test_compute_document_result_accepts_normalization_profile(self) -> None:
+        sig = inspect.signature(_compute_document_result)
+        assert "normalization_profile" in sig.parameters
+
+
+class TestProfileResolution:
+    def test_all_eleven_profiles_resolvable(self) -> None:
+        """Les 11 profils annoncés dans le README sont tous résolvables.
+
+        Verrouille la cohérence entre ``NORMALIZATION_PROFILES`` (table
+        runtime) et ``NormalizationProfileId`` (Literal Pydantic web).
+        """
+        expected = {
+            "nfc", "caseless", "minimal",
+            "medieval_french", "early_modern_french",
+            "medieval_latin", "medieval_english", "early_modern_english",
+            "secretary_hand", "sans_ponctuation", "sans_apostrophes",
+        }
+        assert set(NORMALIZATION_PROFILES.keys()) >= expected
+        for name in expected:
+            profile = get_builtin_profile(name)
+            assert profile is not None
+            assert profile.name == name
+
+
+class TestWebModelProfileAlignment:
+    def test_web_literal_lists_all_eleven_profiles(self) -> None:
+        """Le ``Literal`` Pydantic doit lister les 11 profils.
+
+        Avant S1, le Literal n'en exposait que 8 — Pydantic rejetait
+        donc 3 profils valides du runtime.
+        """
+        from picarones.web.models import NormalizationProfileId
+        from typing import get_args
+        literals = set(get_args(NormalizationProfileId))
+        runtime = set(NORMALIZATION_PROFILES.keys())
+        # Le web peut être un sous-ensemble strict en théorie, mais
+        # l'alignement README ↔ web ↔ runtime exige égalité.
+        assert literals == runtime, (
+            f"Décalage README/web/runtime.  Web a {literals}, "
+            f"runtime a {runtime}.  Diff missing-from-web: "
+            f"{runtime - literals}, extra-in-web: {literals - runtime}."
+        )
+
+
+class TestNormalizationActuallyApplied:
+    """Vérifie via une intégration unitaire que le profil arrive bien
+    jusqu'à ``compute_metrics`` et change le ``cer_diplomatic`` calculé."""
+
+    def test_cer_diplomatic_uses_specified_profile(self) -> None:
+        """Avec deux profils différents, le ``cer_diplomatic`` est
+        différent sur la même paire de textes.  Si le profil n'était
+        pas propagé, on aurait toujours la même valeur."""
+        from picarones.measurements.metrics import compute_metrics
+
+        # Texte avec un ſ médiéval + un v moderne (la GT a l'ancienne
+        # graphie, l'OCR la moderne).
+        gt = "ſuper aqua viuens"
+        hyp = "super aqua vivens"
+
+        # Profil "minimal" : seul ſ → s.  v reste v de chaque côté.
+        prof_minimal = get_builtin_profile("minimal")
+        m_minimal = compute_metrics(gt, hyp, normalization_profile=prof_minimal)
+
+        # Profil "medieval_latin" : ſ → s, u → v, etc.  Sera plus permissif.
+        prof_latin = get_builtin_profile("medieval_latin")
+        m_latin = compute_metrics(gt, hyp, normalization_profile=prof_latin)
+
+        # Les deux doivent être calculés.
+        assert m_minimal.cer_diplomatic is not None
+        assert m_latin.cer_diplomatic is not None
+        assert m_minimal.diplomatic_profile_name == "minimal"
+        assert m_latin.diplomatic_profile_name == "medieval_latin"
+        # Les profils diffèrent → le score change.  S'ils étaient
+        # confondus (bug de propagation), ce serait égal.
+        assert m_minimal.diplomatic_profile_name != m_latin.diplomatic_profile_name

tests/report/test_sprint86_aii5_html.py

@@ -194,7 +194,8 @@ class TestResultsFields:
             searchability_metrics={"recall": 0.9},
             numerical_sequence_metrics={"n_total": 1},
         )
-        dr.compact()
+        # Sprint A14-S1 — opt-in via drop_analyses=True.
+        dr.compact(drop_analyses=True)
         assert dr.searchability_metrics is None
         assert dr.numerical_sequence_metrics is None
 

tests/report/test_sprint87_readability_html.py

@@ -140,13 +140,14 @@ class TestResultsFields:
         assert "readability_metrics" not in d
 
     def test_compact_clears(self) -> None:
+        # Sprint A14-S1 — opt-in via drop_analyses=True.
         dr = DocumentResult(
             doc_id="d1", image_path="x.png",
             ground_truth="x", hypothesis="x",
             metrics=_stub_metrics(), duration_seconds=1.0,
             readability_metrics={"flesch_delta": 5.0},
         )
-        dr.compact()
+        dr.compact(drop_analyses=True)
         assert dr.readability_metrics is None
 
     def test_engine_report_serializes(self) -> None:

tests/security/test_sprint_a14_s1_path_validation.py

@@ -0,0 +1,179 @@
+"""Sprint A14-S1 — A.I.0 P0 : validation des chemins utilisateur.
+
+Tests sur ``picarones.web.security.validated_path``,
+``validated_prompt_filename`` et ``safe_report_name`` : les helpers
+introduits pour bloquer les chemins arbitraires reçus des endpoints
+benchmark/run et benchmark/start.
+
+Avant le sprint S1 du rewrite ciblé, l'API web acceptait :
+
+- n'importe quel ``corpus_path`` validé uniquement par ``Path.exists()`` ;
+- n'importe quel ``output_dir`` créé par ``Path(req.output_dir).mkdir()`` ;
+- n'importe quel ``report_name`` concaténé directement (escape via ``../``) ;
+- n'importe quel ``prompt_file`` absolu (vecteur d'exfiltration via LLM).
+
+Les tests ci-dessous font office de filet de sécurité.  Toute évolution
+ultérieure de la couche security.py qui ferait régresser ces invariants
+est bloquée par cette suite.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from picarones.web.security import (
+    PathValidationError,
+    safe_report_name,
+    validated_path,
+    validated_prompt_filename,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# validated_path
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestValidatedPath:
+    def test_accepts_path_within_allowed_root(self, tmp_path: Path) -> None:
+        sub = tmp_path / "corpus_a"
+        sub.mkdir()
+        result = validated_path(str(sub), allowed_roots=[tmp_path], must_be_dir=True)
+        assert result == sub.resolve()
+
+    def test_rejects_path_outside_allowed_roots(self, tmp_path: Path) -> None:
+        # /etc/passwd existe sur tout Linux et est clairement hors workspace.
+        with pytest.raises(PathValidationError, match="hors zone autorisée"):
+            validated_path("/etc/passwd", allowed_roots=[tmp_path])
+
+    def test_rejects_traversal_via_dot_dot(self, tmp_path: Path) -> None:
+        sub = tmp_path / "inside"
+        sub.mkdir()
+        # tmp_path/inside/../../../etc → résolu = /etc → hors zone
+        evasion = str(sub / ".." / ".." / ".." / "etc")
+        with pytest.raises(PathValidationError, match="hors zone autorisée"):
+            validated_path(evasion, allowed_roots=[tmp_path])
+
+    def test_rejects_empty_path(self, tmp_path: Path) -> None:
+        with pytest.raises(PathValidationError, match="vide"):
+            validated_path("", allowed_roots=[tmp_path])
+
+    def test_rejects_null_byte(self, tmp_path: Path) -> None:
+        with pytest.raises(PathValidationError, match="octet nul"):
+            validated_path("foo\x00bar", allowed_roots=[tmp_path])
+
+    def test_rejects_when_no_allowed_roots(self, tmp_path: Path) -> None:
+        with pytest.raises(PathValidationError, match="Aucune racine autorisée"):
+            validated_path(str(tmp_path), allowed_roots=[])
+
+    def test_must_exist_raises_on_missing(self, tmp_path: Path) -> None:
+        missing = tmp_path / "does_not_exist"
+        with pytest.raises(PathValidationError, match="inexistant"):
+            validated_path(str(missing), allowed_roots=[tmp_path], must_exist=True)
+
+    def test_must_be_dir_raises_on_file(self, tmp_path: Path) -> None:
+        f = tmp_path / "a_file.txt"
+        f.write_text("hello")
+        with pytest.raises(PathValidationError, match="n'est pas un répertoire"):
+            validated_path(str(f), allowed_roots=[tmp_path], must_be_dir=True)
+
+    def test_resolves_symlinks(self, tmp_path: Path) -> None:
+        # Si on crée un symlink dans tmp_path qui pointe vers /tmp/ailleurs,
+        # ``resolve()`` doit suivre le symlink.  Si la cible est hors zone,
+        # on rejette.
+        outside = Path(tempfile.mkdtemp(prefix="picarones_outside_"))
+        try:
+            link = tmp_path / "tricky_link"
+            link.symlink_to(outside)
+            with pytest.raises(PathValidationError, match="hors zone autorisée"):
+                validated_path(str(link), allowed_roots=[tmp_path])
+        finally:
+            # cleanup
+            outside.rmdir()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# safe_report_name
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestSafeReportName:
+    def test_accepts_simple_name(self) -> None:
+        assert safe_report_name("rapport_2026") == "rapport_2026"
+
+    def test_strips_path_separators(self) -> None:
+        # Les séparateurs sont supprimés silencieusement.
+        # ``../etc/passwd`` → ``..etcpasswd``, et ``..`` initial est strippé →
+        # ``etcpasswd`` (caractères neutres, pas de chemin).
+        result = safe_report_name("../etc/passwd")
+        assert "/" not in result
+        assert "\\" not in result
+
+    def test_rejects_empty(self) -> None:
+        with pytest.raises(PathValidationError, match="vide"):
+            safe_report_name("")
+
+    def test_rejects_null_byte(self) -> None:
+        with pytest.raises(PathValidationError, match="octet nul"):
+            safe_report_name("rapport\x00.html")
+
+    def test_rejects_pure_separators(self) -> None:
+        with pytest.raises(PathValidationError, match="invalide"):
+            safe_report_name("///")
+
+    def test_rejects_dot_only(self) -> None:
+        with pytest.raises(PathValidationError):
+            safe_report_name(".")
+
+    def test_truncates_to_max_length(self) -> None:
+        long_name = "a" * 500
+        assert len(safe_report_name(long_name, max_length=128)) == 128
+
+
+# ──────────────────────────────────────────────────────────────────────
+# validated_prompt_filename
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestValidatedPromptFilename:
+    def test_accepts_builtin_name(self) -> None:
+        assert (
+            validated_prompt_filename("correction_medieval_french.txt")
+            == "correction_medieval_french.txt"
+        )
+
+    def test_rejects_absolute_path(self) -> None:
+        with pytest.raises(PathValidationError, match="séparateur de chemin"):
+            validated_prompt_filename("/etc/passwd")
+
+    def test_rejects_relative_traversal(self) -> None:
+        with pytest.raises(PathValidationError):
+            validated_prompt_filename("../prompts/secret.txt")
+
+    def test_rejects_dot_dot_inline(self) -> None:
+        with pytest.raises(PathValidationError, match="suspect"):
+            validated_prompt_filename("foo..bar.txt")
+
+    def test_rejects_windows_separator(self) -> None:
+        with pytest.raises(PathValidationError, match="séparateur de chemin"):
+            validated_prompt_filename(r"C:\Users\victim\file.txt")
+
+    def test_rejects_dot_prefix(self) -> None:
+        with pytest.raises(PathValidationError, match="suspect"):
+            validated_prompt_filename(".env")
+
+    def test_rejects_null_byte(self) -> None:
+        with pytest.raises(PathValidationError, match="octet nul"):
+            validated_prompt_filename("file\x00.txt")
+
+    def test_rejects_control_characters(self) -> None:
+        with pytest.raises(PathValidationError, match="caractère de contrôle"):
+            validated_prompt_filename("file\x01.txt")
+
+    def test_rejects_empty(self) -> None:
+        with pytest.raises(PathValidationError, match="vide"):
+            validated_prompt_filename("")