sprint92: A.II.9 - métriques longitudinales (régression + change-point + détecteur)

L'historique SQLite (Sprint 8) collectait sans qu'aucune métrique
n'en sorte dans le rapport. Complémentaire à A.I.3 (off-baseline)
qui dit "écart anormal sur ce corpus" sans caractériser la dynamique.

picarones/core/longitudinal.py :
- LinearTrend + ChangePointResult dataclasses.
- compute_linear_trend : OLS pure Python sans scipy, slope + R².
- detect_change_point : balayage Pettitt simplifié.
- compute_engine_longitudinal : combine, garde-fous min_runs_for_trend=3
et change_point_threshold=0.01.
- compute_corpus_longitudinal : agrège tous les moteurs.

FactType.REGRESSION_IN_HISTORY (priority 170, MEDIUM par défaut,
HIGH si |absolute_delta| >= 0.05). Détecteur déclenche si pente
> +1 pt/an OU change-point delta > 1 pt CER. Payload trace pattern
trend/change_point/trend_and_change_point.

Templates FR/EN sans chiffres en dur. Couples complémentaires
(GLOBAL_LEADER_CER, REGRESSION_IN_HISTORY) et
(ENGINE_OFF_BASELINE, REGRESSION_IN_HISTORY) ajoutés à l'arbitre.

picarones/report/longitudinal_render.py : tableau moteur ×
{n_runs, premier/dernier CER, Δ cumulé coloré (rouge dégradation /
bleu amélioration), pente annualisée, R², change-point}. Tri par
Δ décroissant. Adaptive masking.

10 clés i18n FR/EN. 28 tests dans test_sprint92_longitudinal.py
incluant traçabilité anti-hallucination FR + EN sur sentences de
build_synthesis.

Tests : 2996 passed, 2 skipped.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,70 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 92 — A.II.9 : métriques longitudinales (régression
+  linéaire + change-point + détecteur narratif + vue HTML).**
+  L'historique SQLite (`core/history.py`, Sprint 8) collectait
+  les résultats sans qu'aucune métrique n'en sorte dans le
+  rapport.  Ce sprint exploite la série temporelle des CER
+  pour signaler tendances et ruptures — complémentaire à
+  A.I.3 (off-baseline) qui dit *« écart anormal sur ce
+  corpus »* sans caractériser la dynamique.
+
+  - `picarones/core/longitudinal.py` : `compute_linear_trend`
+    régression OLS pure Python sans scipy retourne
+    `LinearTrend(slope, intercept, r_squared, n_runs)` ;
+    `detect_change_point(series, min_segment_size=3)` balayage
+    exhaustif (Pettitt simplifié) retourne
+    `ChangePointResult(index, timestamp, mean_before,
+    mean_after, delta, n_before, n_after)` ;
+    `compute_engine_longitudinal(history, engine, corpus)`
+    combine les deux avec garde-fou `min_runs_for_trend=3` et
+    seuil `change_point_threshold=0.01` (1 point CER) pour
+    filtrer le bruit ; `compute_corpus_longitudinal` agrège
+    sur tous les moteurs présents.
+
+  - Nouveau `FactType.REGRESSION_IN_HISTORY` (priority 170,
+    importance MEDIUM par défaut, HIGH si `|absolute_delta| ≥
+    0.05`) + détecteur `detect_regression_in_history` qui lit
+    `benchmark_data["longitudinal_trends"]`.  Déclenche si
+    pente > +1 pt CER/an **ou** change-point delta > 1 pt CER.
+    Garde-fou `n_runs ≥ 3`.  Le payload trace
+    `pattern in {"trend", "change_point",
+    "trend_and_change_point"}`.  Templates FR/EN sans chiffres
+    en dur.  Ajout aux paires complémentaires de l'arbitre :
+    `(GLOBAL_LEADER_CER, REGRESSION_IN_HISTORY)` (le leader
+    peut être en régression, info critique) et
+    `(ENGINE_OFF_BASELINE, REGRESSION_IN_HISTORY)` (les deux
+    se complètent : écart anormal vs tendance dans le temps).
+
+  - `picarones/report/longitudinal_render.py` :
+    `build_longitudinal_html(trends, labels)` rend un tableau
+    moteur × {n_runs, premier CER, dernier CER, Δ cumulé
+    coloré (gradient vert → orange → rouge sur ±5 pts ; bleu
+    si amélioration), pente annualisée, R², point de rupture
+    avec timestamp + delta entre parenthèses}.  Tri par Δ
+    décroissant.  Adaptive : `""` si pas de données.  Module
+    pur — l'utilisateur compose
+    `BenchmarkHistory.list_entries()` →
+    `compute_corpus_longitudinal` →
+    `build_longitudinal_html`.
+
+  +10 clés i18n FR/EN (`longitudinal_*`).  +28 tests dans
+  `test_sprint92_longitudinal.py` (régression OLS pente + R² +
+  série plate + lt 2 + même timestamp ; change-point delta
+  exact + lt segments + uniforme ; intégration entries +
+  filtre corpus + min_runs + threshold ; multi-moteurs ;
+  détecteur 6 cas dont silence sans data, silence si plat,
+  HIGH si Δ ≥ 5 pts, change-point seul, garde-fou n_runs < 3 ;
+  **traçabilité anti-hallucination FR + EN** sur les sentences
+  de `build_synthesis` ; vue HTML 4 cas dont anti-injection,
+  complétude i18n 10 clés).  **Verrou levé** : un benchmark
+  qui pousse ses résultats dans l'historique voit désormais
+  *« sur les 8 runs historiques pour tess, le CER moyen est
+  passé de 4 % à 7 % (variation cumulée 3 points) »* dans la
+  synthèse + le tableau d'évolution dans la vue.  Permet de
+  relier une régression à un changement de pipeline.
+
 - **Sprint 91 — A.II.6 : métriques économiques (throughput
   effectif + coût marginal par erreur évitée).**  Le throughput
   brut (pages/heure d'OCR pur) ment quand un moteur est rapide

CLAUDE.md

@@ -207,6 +207,7 @@ AZURE_DOC_INTEL_KEY=...
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
 | 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 | 35 | **Sprint 4 du plan d'évolution 2026 — Étape 2 / axe A : métriques inter-moteurs (couche de calcul)**. Nouveau module `picarones/core/inter_engine.py` qui répond à deux questions distinctes mais liées : *(a) à quel point les moteurs font-ils des erreurs de natures différentes ?* via `kl_divergence`, `jensen_shannon_divergence` (symétrique, bornée `[0, 1]`), et `taxonomy_divergence_matrix` qui construit la matrice triangulaire inter-moteurs ; *(b) quel CER serait atteignable si on combinait les moteurs ?* via `oracle_token_recall` (proxy bag-of-words, borne supérieure du recall atteignable), `complementarity_gap` (oracle vs meilleur moteur seul, gap absolu/relatif), et `pairwise_disagreement_rate`. Fonctions pures, sans I/O ni intégration runner — la couche de calcul est livrée indépendamment, le câblage narratif (`ENSEMBLE_OPPORTUNITY`) et HTML (matrice de divergence, badge oracle) suit au Sprint 36. +27 tests couvrant les invariants mathématiques (KL ≥ 0, KL(p,p) = 0, JS symétrique et bornée, oracle ≥ best_single, multiplicité respectée), les cas concrets (deux moteurs spécialisés sortent comme candidats ensemble, complémentarité parfaite atteint oracle = 1), et les garde-fous (référence vide, hypothèses vides, métrique inconnue). |
+| 92 | **Sprint 61 du plan d'évolution 2026 — A.II.9 : métriques longitudinales (régression linéaire + change-point + détecteur narratif + vue HTML)**. L'historique SQLite (Sprint 8) collectait sans qu'aucune métrique n'en sorte. Complémentaire à A.I.3 qui dit *« écart anormal sur ce corpus »* sans caractériser la dynamique. Nouveau module `picarones/core/longitudinal.py` : `compute_linear_trend` régression OLS pure Python sans scipy retourne `LinearTrend(slope, intercept, r_squared, n_runs)` ; `detect_change_point(series, min_segment_size=3)` balayage exhaustif (Pettitt simplifié) retourne `ChangePointResult(index, timestamp, mean_before, mean_after, delta, n_before, n_after)` ; `compute_engine_longitudinal` combine les deux avec garde-fou `min_runs_for_trend=3` et seuil `change_point_threshold=0.01` (1 pt CER) ; `compute_corpus_longitudinal` agrège tous les moteurs. Nouveau `FactType.REGRESSION_IN_HISTORY` (priority 170, MEDIUM par défaut, HIGH si `|absolute_delta| ≥ 0.05`) + détecteur lit `benchmark_data["longitudinal_trends"]`, déclenche si pente > +1 pt CER/an **ou** change-point delta > 1 pt CER, payload trace `pattern in {"trend", "change_point", "trend_and_change_point"}`. Templates FR/EN sans chiffres en dur. Ajout aux paires complémentaires : `(GLOBAL_LEADER_CER, REGRESSION_IN_HISTORY)` et `(ENGINE_OFF_BASELINE, REGRESSION_IN_HISTORY)`. Module de rendu `picarones/report/longitudinal_render.py` : tableau moteur × {n_runs, premier CER, dernier CER, Δ cumulé coloré (vert→orange→rouge sur ±5 pts ; bleu si amélioration), pente annualisée, R², point de rupture avec timestamp + delta}. Tri par Δ décroissant. Adaptive masking. +10 clés i18n FR/EN (`longitudinal_*`). +28 tests (régression OLS, change-point, intégration entries + filtre corpus + min_runs + threshold, multi-moteurs, détecteur 6 cas, **traçabilité anti-hallucination FR + EN** sur sentences de `build_synthesis`, vue HTML 4 cas dont anti-injection, complétude i18n 10 clés). **Verrou levé** : un benchmark voit désormais *« sur les 8 runs historiques pour tess, le CER moyen est passé de 4 % à 7 % (variation cumulée 3 points) »* — permet de relier une régression à un changement de pipeline. |
 | 91 | **Sprint 60 du plan d'évolution 2026 — A.II.6 : métriques économiques (throughput effectif + coût marginal par erreur évitée, couche calcul + vue HTML throughput)**. Le throughput brut ment quand un moteur est rapide mais imprécis : la correction humaine *post hoc* absorbe le gain. Discrimine fortement entre cloud rapide à 30 % de timeouts et local lent à 100 % de fiabilité. Nouveau module `picarones/core/throughput.py` : `compute_effective_throughput(n_pages, duration_seconds, n_errors, time_per_error_seconds=5.0)` retourne `{n_pages, duration_seconds, n_errors, time_per_error_seconds, correction_time_seconds, total_seconds, pages_per_hour_raw, pages_per_hour_effective, drag_ratio}`. Constante HTR-United (5 s/erreur) surchargeable. Garde-fous : `None` si `n_pages = 0` ou `total_seconds = 0`, `ValueError` sur valeurs négatives. `aggregate_effective_throughput(per_engine)` agrège par moteur. Nouveau module `picarones/core/marginal_cost.py` : `compute_marginal_cost(cost_a, errors_a, cost_b, errors_b)` retourne `{cost_per_avoided_error, n_errors_avoided, cost_delta, dominated}` ou `None` si `errors_b ≥ errors_a`. `dominated=True` quand B moins cher ET plus précis. `compute_marginal_cost_matrix(per_engine)` retourne paires ordonnées (A → B) triées par coût marginal croissant. Nouveau module `picarones/report/throughput_render.py` : `build_throughput_html(aggregated, labels)` produit tableau résumé moteur × {pages/h brut, pages/h **utilisable** (gradient rouge → vert sur le max observé), % drag (gradient vert → rouge), pages, erreurs}, tri par pages/h utilisable décroissant. Adaptive : `""` si pas de données. Module pur — l'utilisateur compose la liste `per_engine`. Vue HTML coût marginal couplée à la vue Pareto reportée à un sprint ultérieur. +9 clés i18n FR/EN (`throughput_*`). +27 tests dans `test_sprint91_throughput.py` (formule effective avec/sans erreurs, custom time_per_error, garde-fous, drag_ratio élevé, agrégation 3 cas, marginal cost 5 cas dont dominé/non comparable, matrice tri ascendant + lt 2 + données invalides, **cas réaliste BnF** Tesseract local 600 p/h brut → 423 p/h effectif vs GPT-4o cloud 1800 p/h brut → 300 p/h effectif, vue HTML 4 cas dont anti-injection + tri descendant, complétude i18n 9 clés). **Verrou levé** : un archiviste BnF qui pondère un budget contre une exigence de délai voit immédiatement *« Tesseract local 423 p/h utilisable, GPT-4o cloud 300 p/h utilisable malgré son apparente vitesse de 1800 p/h brut »* — la décision business s'aligne sur la réalité opérationnelle. |
 | 90 | **Sprint 59 du plan d'évolution 2026 — A.II.4 finition : détecteur narratif `engine_unstable` + vue HTML stabilité multi-runs**. Le module `picarones/core/reliability.py` (Sprint 83) livrait la couche de calcul ; aucun détecteur ni vue ne consommaient les données. Critique pour les moteurs LLM/VLM dont la non-déterministie sape la reproductibilité scientifique. Nouveau `FactType.ENGINE_UNSTABLE` (priority 160, importance HIGH) + détecteur `detect_engine_unstable` qui lit `benchmark_data["multirun_stability"]` (liste enrichie d'`engine_name` + sortie de `compute_multirun_stability`). Garde-fous : `n_runs ≥ 2`, déclenche si `cer_cv > 0.10` **ou** `identical_run_rate < 0.50`. Templates FR/EN sans chiffres en dur. Ajout du couple `(GLOBAL_LEADER_CER, ENGINE_UNSTABLE)` à `_COMPLEMENTARY_PAIRS` de l'arbitre — un moteur peut être leader **et** instable, et c'est précisément l'information critique à remonter ensemble. Nouveau module `picarones/report/multirun_stability_render.py` : `build_multirun_stability_html(stability, labels)` rend un tableau moteur × {n_runs, CER moyen ± σ, CV (gradient vert→orange→rouge sur 0–25 %), % runs identiques, sorties distinctes}. Adaptive : `""` si liste vide ou tous `cer_cv` None. Note d'intégration : la vue est un module pur (l'utilisateur exécute lui-même les N runs ; option runner `--repeats N` reportée à un sprint dédié). +8 clés i18n FR/EN (`stability_*`). +18 tests dans `test_sprint90_engine_unstable.py` (FactType + arbiter, détecteur 6 cas, **traçabilité anti-hallucination FR + EN** sur les sentences de `build_synthesis`, vue HTML 4 cas dont anti-injection, complétude i18n 8 clés). **Verrou levé** : un papier scientifique qui rapporte un CER LLM voit désormais *« sur 4 runs successifs, gpt-4o produit des sorties variables (CV 24,3 %) — interpréter avec prudence »* dans la synthèse + le tableau de stabilité dans la vue. |
 | 89 | **Sprint 58 du plan d'évolution 2026 — A.II.8b : score de spécialisation inter-moteurs (couche calcul + vue HTML)**. La matrice de divergence taxonomique (Sprint 35) répondait à *« à quel point ces moteurs se trompent-ils différemment ? »* ; ce sprint transforme cette information en un score lisible et un **top-N des paires les plus spécialisées**, qui répond directement à la question *« quels moteurs sont des candidats pour un voting ensemble ? »*. Le module **ne recommande pas** d'ensemble — observation factuelle, le chercheur arbitre. Nouveau module `picarones/core/specialization.py` : `compute_specialization_score(taxonomy_a, taxonomy_b)` retourne un score normalisé ∈ [0, 1] (délégué à `inter_engine.jensen_shannon_divergence` Sprint 35, pas de double calcul) ; `classify_specialization(score)` classe en `similar` (< 0,10) / `distinct` (0,10–0,30) / `highly_specialized` (≥ 0,30) — seuils éditoriaux pas verdict, surchargeables ; `compute_specialization_matrix(taxonomies)` retourne matrice symétrique avec `max_pair` ; `top_specialized_pairs(matrix, n=5, min_score=0)` retourne paires triées par score décroissant + catégorie. Nouveau module `picarones/report/specialization_render.py` : `build_specialization_html` rend tableau Moteur A × Moteur B × Score (gradient blanc → bleu profond) × Lecture (libellé i18n). Adaptive : `""` si < 2 moteurs avec taxonomie. Anti-injection. Câblage générator : lit `aggregated_taxonomy` exposés sur les moteurs (Sprint 5/runner historique), construit map `{engine: counts}`. Insertion `view_analyses.html` derrière la lisibilité. +9 clés i18n FR/EN (`specialization_*`). +24 tests dans `test_sprint89_specialization.py` (score symétrique + identité 0 + disjoint 1 + bornes [0,1], classify 5 cas dont custom thresholds, matrice diagonale 0 + symétrique + max_pair correctement identifié, top_pairs tri/n/min_score/None, rendu adaptive + anti-injection + FR/EN, complétude i18n 9 clés). **Verrou levé** : un benchmark BnF avec ≥ 2 moteurs voit immédiatement *« tess et pero ont une spécialisation forte (0,489) — ils font des erreurs de natures différentes »* — observation factuelle. |
@@ -309,7 +310,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 2968 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout ; Sprint 89 = A.II.8b — score de spécialisation inter-moteurs (couche calcul + vue HTML « Top paires spécialisées ») ; Sprint 90 = A.II.4 finition — détecteur narratif `engine_unstable` + vue HTML stabilité multi-runs ; **Sprint 91 = A.II.6 — métriques économiques (throughput effectif + coût marginal par erreur évitée, couche calcul + vue HTML throughput)**)
+- **Tests** : 2996 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livr��es ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout ; Sprint 89 = A.II.8b — score de spécialisation inter-moteurs (couche calcul + vue HTML « Top paires spécialisées ») ; Sprint 90 = A.II.4 finition — détecteur narratif `engine_unstable` + vue HTML stabilité multi-runs ; Sprint 91 = A.II.6 — métriques économiques (throughput effectif + coût marginal par erreur évitée, couche calcul + vue HTML throughput) ; **Sprint 92 = A.II.9 — métriques longitudinales (régression linéaire + change-point + détecteur narratif + vue HTML)**)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/core/longitudinal.py

@@ -0,0 +1,373 @@
+"""Métriques longitudinales — Sprint 92 (A.II.9).
+
+Sprint 92 — A.II.9 du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+L'historique SQLite (`core/history.py`, Sprint 8) collecte les
+résultats de chaque run de benchmark, mais aucune métrique
+n'en sortait dans le rapport.  Ce module exploite la série
+temporelle des CER d'un moteur pour répondre à deux
+questions :
+
+1. **Y a-t-il une tendance ?**  Régression linéaire simple
+   (méthode des moindres carrés) sur ``(t, CER)`` —  pente,
+   ordonnée à l'origine, R², n_runs.  Une pente > 0 signale
+   une régression progressive ; une pente < 0 une amélioration.
+
+2. **Y a-t-il un point de rupture ?**  Algorithme de
+   change-point pur Python (différence de moyennes maximale,
+   variante de Pettitt simplifiée).  Identifie l'index où la
+   série se sépare en deux segments avec moyennes les plus
+   différentes — typiquement le run où un modèle a changé de
+   comportement.
+
+Pas de scipy
+------------
+Pour rester sans dépendance lourde, on implémente :
+- la régression linéaire en pur Python (closed-form OLS) ;
+- le change-point par balayage exhaustif (O(N) pour de petits
+  N — l'historique d'une institution dépasse rarement quelques
+  centaines de runs).
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import statistics
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Iterable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LinearTrend:
+    """Résultat d'une régression linéaire sur une série CER."""
+    slope: float
+    """Pente (CER par jour). Positif = régression."""
+    intercept: float
+    """Ordonnée à l'origine."""
+    r_squared: float
+    """Qualité de l'ajustement, ∈ [0, 1]."""
+    n_runs: int
+    """Nombre de points utilisés."""
+
+    def as_dict(self) -> dict:
+        return {
+            "slope": self.slope,
+            "intercept": self.intercept,
+            "r_squared": self.r_squared,
+            "n_runs": self.n_runs,
+        }
+
+
+@dataclass
+class ChangePointResult:
+    """Résultat d'une détection de point de rupture."""
+    index: int
+    """Index de la rupture (0-based, le segment 1 est [0:index],
+    le segment 2 est [index:N])."""
+    timestamp: str
+    """Timestamp du run à la rupture."""
+    mean_before: float
+    mean_after: float
+    delta: float
+    """``mean_after - mean_before``. Positif = régression."""
+    n_before: int
+    n_after: int
+
+    def as_dict(self) -> dict:
+        return {
+            "index": self.index,
+            "timestamp": self.timestamp,
+            "mean_before": self.mean_before,
+            "mean_after": self.mean_after,
+            "delta": self.delta,
+            "n_before": self.n_before,
+            "n_after": self.n_after,
+        }
+
+
+def _parse_timestamp(ts: str) -> Optional[float]:
+    """Parse un ISO timestamp en jour ordinal float.
+
+    Tolère ``YYYY-MM-DD`` et ``YYYY-MM-DDTHH:MM:SS``.  Retourne
+    ``None`` si non parsable.
+    """
+    if not ts:
+        return None
+    formats = (
+        "%Y-%m-%dT%H:%M:%S.%f",
+        "%Y-%m-%dT%H:%M:%S",
+        "%Y-%m-%d %H:%M:%S",
+        "%Y-%m-%d",
+    )
+    for fmt in formats:
+        try:
+            dt = datetime.strptime(ts.split("+")[0].split("Z")[0], fmt)
+            return dt.toordinal() + (
+                dt.hour * 3600 + dt.minute * 60 + dt.second
+            ) / 86400.0
+        except ValueError:
+            continue
+    return None
+
+
+def compute_linear_trend(
+    cer_series: Iterable[tuple[str, float]],
+) -> Optional[LinearTrend]:
+    """Régression linéaire OLS sur une série temporelle de CER.
+
+    Parameters
+    ----------
+    cer_series:
+        Itérable de ``(timestamp_iso, cer)``.  Au moins 2 points
+        valides requis.
+
+    Returns
+    -------
+    LinearTrend | None
+        ``None`` si moins de 2 points ou si tous les timestamps
+        sont identiques (variance nulle sur t).
+    """
+    points: list[tuple[float, float]] = []
+    for ts, cer in cer_series:
+        t = _parse_timestamp(ts)
+        if t is None or cer is None:
+            continue
+        try:
+            cer_f = float(cer)
+        except (TypeError, ValueError):
+            continue
+        points.append((t, cer_f))
+    n = len(points)
+    if n < 2:
+        return None
+    xs = [p[0] for p in points]
+    ys = [p[1] for p in points]
+    x_mean = statistics.fmean(xs)
+    y_mean = statistics.fmean(ys)
+    sxx = sum((x - x_mean) ** 2 for x in xs)
+    sxy = sum((x - x_mean) * (y - y_mean) for x, y in zip(xs, ys))
+    if sxx == 0:
+        return None
+    slope = sxy / sxx
+    intercept = y_mean - slope * x_mean
+    syy = sum((y - y_mean) ** 2 for y in ys)
+    if syy == 0:
+        # Tous les CER sont égaux → R² mathématiquement indéfini ;
+        # on retourne 1.0 (parfaite "non-tendance").
+        r_squared = 1.0
+    else:
+        ss_res = sum(
+            (y - (slope * x + intercept)) ** 2
+            for x, y in zip(xs, ys)
+        )
+        r_squared = max(0.0, 1.0 - ss_res / syy)
+    return LinearTrend(
+        slope=slope,
+        intercept=intercept,
+        r_squared=r_squared,
+        n_runs=n,
+    )
+
+
+def detect_change_point(
+    cer_series: Iterable[tuple[str, float]],
+    min_segment_size: int = 3,
+) -> Optional[ChangePointResult]:
+    """Détecte le point de rupture maximisant l'écart de moyennes.
+
+    Algorithme : balayage des indices ``i`` où la série se
+    sépare en deux segments d'au moins ``min_segment_size``
+    points chacun ; on retient l'index où ``|mean_after -
+    mean_before|`` est maximal.  Variante simplifiée de Pettitt.
+
+    Parameters
+    ----------
+    cer_series:
+        Itérable de ``(timestamp_iso, cer)``.
+    min_segment_size:
+        Taille minimale des deux segments.  Défaut 3.
+
+    Returns
+    -------
+    ChangePointResult | None
+        ``None`` si la série a moins de ``2 × min_segment_size``
+        points valides.
+    """
+    points: list[tuple[str, float, float]] = []
+    for ts, cer in cer_series:
+        t = _parse_timestamp(ts)
+        if t is None or cer is None:
+            continue
+        try:
+            cer_f = float(cer)
+        except (TypeError, ValueError):
+            continue
+        points.append((ts, t, cer_f))
+    if len(points) < 2 * min_segment_size:
+        return None
+    points.sort(key=lambda p: p[1])
+    n = len(points)
+    best_index = -1
+    best_abs_delta = -1.0
+    best_delta = 0.0
+    best_mean_before = 0.0
+    best_mean_after = 0.0
+    for i in range(min_segment_size, n - min_segment_size + 1):
+        before = [p[2] for p in points[:i]]
+        after = [p[2] for p in points[i:]]
+        mean_b = statistics.fmean(before)
+        mean_a = statistics.fmean(after)
+        delta = mean_a - mean_b
+        abs_delta = abs(delta)
+        if abs_delta > best_abs_delta:
+            best_abs_delta = abs_delta
+            best_index = i
+            best_delta = delta
+            best_mean_before = mean_b
+            best_mean_after = mean_a
+    if best_index < 0:
+        return None
+    return ChangePointResult(
+        index=best_index,
+        timestamp=points[best_index][0],
+        mean_before=best_mean_before,
+        mean_after=best_mean_after,
+        delta=best_delta,
+        n_before=best_index,
+        n_after=n - best_index,
+    )
+
+
+def compute_engine_longitudinal(
+    history_entries: Iterable,
+    engine_name: str,
+    corpus_name: Optional[str] = None,
+    *,
+    min_runs_for_trend: int = 3,
+    min_segment_size: int = 3,
+    change_point_threshold: float = 0.01,
+) -> Optional[dict]:
+    """Calcule trend + change_point pour un moteur.
+
+    Parameters
+    ----------
+    history_entries:
+        Liste de ``HistoryEntry`` (ou dicts compatibles).
+    engine_name:
+        Filtre sur le nom du moteur.
+    corpus_name:
+        Filtre optionnel sur le corpus.  ``None`` (défaut) : tous
+        les corpus.
+    min_runs_for_trend:
+        Minimum de runs pour calculer une tendance.
+    min_segment_size:
+        Taille minimale des segments pour le change-point.
+    change_point_threshold:
+        Magnitude absolue minimale du delta (en CER) pour
+        retenir le change-point.  Défaut 0.01 (1 point de CER).
+
+    Returns
+    -------
+    dict | None
+        ``{
+            "engine_name", "corpus_name", "n_runs", "trend",
+            "change_point",  # ou None
+            "first_timestamp", "last_timestamp",
+            "first_cer", "last_cer", "absolute_delta_pct",
+        }`` ou ``None`` si moins de ``min_runs_for_trend`` runs.
+    """
+    series: list[tuple[str, float]] = []
+    for entry in history_entries:
+        if hasattr(entry, "as_dict"):
+            data = entry.as_dict()
+        else:
+            data = entry
+        if data.get("engine_name") != engine_name:
+            continue
+        if corpus_name is not None and data.get("corpus_name") != corpus_name:
+            continue
+        cer = data.get("cer_mean")
+        ts = data.get("timestamp")
+        if cer is None or ts is None:
+            continue
+        series.append((ts, float(cer)))
+    if len(series) < min_runs_for_trend:
+        return None
+    series.sort(key=lambda p: _parse_timestamp(p[0]) or 0.0)
+    trend = compute_linear_trend(series)
+    cp = detect_change_point(series, min_segment_size=min_segment_size)
+    if cp is not None and abs(cp.delta) < change_point_threshold:
+        cp = None
+    first_ts, first_cer = series[0]
+    last_ts, last_cer = series[-1]
+    return {
+        "engine_name": engine_name,
+        "corpus_name": corpus_name,
+        "n_runs": len(series),
+        "trend": trend.as_dict() if trend else None,
+        "change_point": cp.as_dict() if cp else None,
+        "first_timestamp": first_ts,
+        "last_timestamp": last_ts,
+        "first_cer": first_cer,
+        "last_cer": last_cer,
+        "absolute_delta": last_cer - first_cer,
+        "absolute_delta_pct": round((last_cer - first_cer) * 100, 2),
+    }
+
+
+def compute_corpus_longitudinal(
+    history_entries: Iterable,
+    corpus_name: Optional[str] = None,
+    *,
+    min_runs_for_trend: int = 3,
+    min_segment_size: int = 3,
+    change_point_threshold: float = 0.01,
+) -> list[dict]:
+    """Pour chaque moteur présent dans l'historique sur ``corpus_name``,
+    calcule trend + change_point.
+
+    Returns
+    -------
+    list[dict]
+        Une entrée par moteur (filtrée), liste vide si rien.
+    """
+    entries = list(history_entries)
+    engines: set[str] = set()
+    for entry in entries:
+        data = entry.as_dict() if hasattr(entry, "as_dict") else entry
+        if corpus_name is not None and data.get("corpus_name") != corpus_name:
+            continue
+        name = data.get("engine_name")
+        if name:
+            engines.add(name)
+    out: list[dict] = []
+    for engine in sorted(engines):
+        result = compute_engine_longitudinal(
+            entries, engine, corpus_name=corpus_name,
+            min_runs_for_trend=min_runs_for_trend,
+            min_segment_size=min_segment_size,
+            change_point_threshold=change_point_threshold,
+        )
+        if result is not None:
+            out.append(result)
+    return out
+
+
+__all__ = [
+    "LinearTrend",
+    "ChangePointResult",
+    "compute_linear_trend",
+    "detect_change_point",
+    "compute_engine_longitudinal",
+    "compute_corpus_longitudinal",
+]
+
+
+# Marqueur d'évitement d'import inutilisé (math)
+_ = math

picarones/core/narrative/arbiter.py

@@ -78,6 +78,11 @@ _FALLBACK_TYPE_ORDER: tuple[FactType, ...] = (
     # discrédite toute autre conclusion sur ce moteur ; on la
     # remonte en dernier pour ne pas l'enterrer.
     FactType.ENGINE_UNSTABLE,
+    # Sprint 92 — priority 170, après ENGINE_UNSTABLE.  La
+    # régression historique complète A.I.3 (off-baseline) en
+    # caractérisant la tendance : l'écart courant est-il une
+    # dégradation graduelle, une rupture brutale, ou un bruit ?
+    FactType.REGRESSION_IN_HISTORY,
 )
 
 
@@ -112,6 +117,14 @@ _COMPLEMENTARY_PAIRS: frozenset[frozenset[FactType]] = frozenset({
     # leader **et** instable, et c'est précisément l'information
     # critique pour la reproductibilité scientifique.
     frozenset({FactType.GLOBAL_LEADER_CER, FactType.ENGINE_UNSTABLE}),
+    # Sprint 92 — la régression historique caractérise la tendance
+    # du leader : un leader peut être en régression progressive,
+    # info critique pour décider quand re-tester.
+    frozenset({FactType.GLOBAL_LEADER_CER, FactType.REGRESSION_IN_HISTORY}),
+    # Off-baseline (Sprint 73) dit "écart anormal sur ce corpus" ;
+    # regression-in-history (Sprint 92) dit "tendance dans le
+    # temps" — les deux se complètent sans se redonder.
+    frozenset({FactType.ENGINE_OFF_BASELINE, FactType.REGRESSION_IN_HISTORY}),
 })
 
 

picarones/core/narrative/detectors.py

@@ -992,6 +992,124 @@ def detect_engine_unstable(benchmark_data: dict) -> list[Fact]:
     return facts
 
 
+# ---------------------------------------------------------------------------
+# Détecteur Sprint 92 — régression dans l'historique (A.II.9)
+# ---------------------------------------------------------------------------
+
+@register_detector(
+    FactType.REGRESSION_IN_HISTORY,
+    priority=170,
+    importance=FactImportance.MEDIUM,
+)
+def detect_regression_in_history(benchmark_data: dict) -> list[Fact]:
+    """Émet un Fact pour chaque moteur dont l'historique montre
+    une dégradation : pente positive significative ou rupture
+    brutale (Sprint 92).
+
+    Lit ``benchmark_data["longitudinal_trends"]`` : liste de
+    dicts produits par ``compute_corpus_longitudinal`` du module
+    ``longitudinal``.  Si la clé est absente ou vide, le
+    détecteur reste silencieux — typiquement le cas quand
+    aucun historique n'a été chargé ou que la série est trop
+    courte.
+
+    Garde-fous :
+
+    - ``n_runs ≥ 3`` (déjà filtré par
+      ``compute_engine_longitudinal``).
+    - Déclenche si **soit** ``trend.slope`` traduit une
+      régression d'au moins ``slope_threshold`` (en CER/jour,
+      défaut équivalent à +1 point CER sur 365 jours), **soit**
+      ``change_point.delta > change_threshold`` (défaut
+      0.01 = +1 point de CER d'un segment à l'autre).
+    - Importance ``HIGH`` si la dégradation cumulée
+      ``absolute_delta`` ≥ 5 points de CER.
+    """
+    trends = benchmark_data.get("longitudinal_trends") or []
+    if not isinstance(trends, (list, tuple)):
+        return []
+    slope_threshold = (
+        0.01 / 365.0  # +1 point de CER sur 365 jours minimum
+    )
+    change_threshold = 0.01
+    facts: list[Fact] = []
+    for entry in trends:
+        if not isinstance(entry, dict):
+            continue
+        engine = entry.get("engine_name")
+        if not engine:
+            continue
+        n_runs = entry.get("n_runs")
+        if not isinstance(n_runs, int) or n_runs < 3:
+            continue
+        trend = entry.get("trend") or {}
+        cp = entry.get("change_point")
+        slope = trend.get("slope")
+        slope_high = (
+            isinstance(slope, (int, float))
+            and float(slope) > slope_threshold
+        )
+        cp_high = (
+            isinstance(cp, dict)
+            and isinstance(cp.get("delta"), (int, float))
+            and float(cp["delta"]) > change_threshold
+        )
+        if not (slope_high or cp_high):
+            continue
+        absolute_delta = entry.get("absolute_delta") or 0.0
+        importance = (
+            FactImportance.HIGH
+            if isinstance(absolute_delta, (int, float))
+            and abs(float(absolute_delta)) >= 0.05
+            else FactImportance.MEDIUM
+        )
+        payload: dict = {
+            "engine": engine,
+            "n_runs": int(n_runs),
+            "absolute_delta_pct": round(
+                float(absolute_delta) * 100, 2,
+            ) if isinstance(absolute_delta, (int, float)) else 0.0,
+            "first_cer_pct": round(
+                float(entry.get("first_cer") or 0.0) * 100, 2,
+            ),
+            "last_cer_pct": round(
+                float(entry.get("last_cer") or 0.0) * 100, 2,
+            ),
+        }
+        if slope_high:
+            payload["slope_per_year_pct"] = round(
+                float(slope) * 365 * 100, 2,
+            )
+            payload["r_squared"] = round(
+                float(trend.get("r_squared") or 0.0), 3,
+            )
+            payload["pattern"] = "trend"
+        if cp_high:
+            payload["change_point_timestamp"] = str(
+                cp.get("timestamp") or "?",
+            )
+            payload["change_delta_pct"] = round(
+                float(cp["delta"]) * 100, 2,
+            )
+            payload["mean_before_pct"] = round(
+                float(cp.get("mean_before") or 0.0) * 100, 2,
+            )
+            payload["mean_after_pct"] = round(
+                float(cp.get("mean_after") or 0.0) * 100, 2,
+            )
+            # Si on a aussi une rupture, le pattern domine
+            payload["pattern"] = (
+                "trend_and_change_point" if slope_high else "change_point"
+            )
+        facts.append(Fact(
+            type=FactType.REGRESSION_IN_HISTORY,
+            importance=importance,
+            payload=payload,
+            engines_involved=(engine,),
+        ))
+    return facts
+
+
 # ---------------------------------------------------------------------------
 # Détecteur Sprint 36 — opportunité d'ensemble (complémentarité)
 # ---------------------------------------------------------------------------

picarones/core/narrative/facts.py

@@ -91,6 +91,15 @@ class FactType(str, Enum):
     de variation du CER (>10 % par défaut) ou sur le rappel de
     runs identiques (<50 %)."""
 
+    REGRESSION_IN_HISTORY = "regression_in_history"
+    """Un moteur montre une tendance ou une rupture défavorable
+    sur l'historique SQLite : son CER moyen s'est dégradé sur
+    les N derniers runs (Sprint 92).  Lit
+    ``compute_corpus_longitudinal`` du module ``longitudinal``.
+    Garde-fous : ≥ 3 runs historiques et soit pente > seuil
+    (régression progressive), soit change-point avec delta >
+    seuil (rupture brutale)."""
+
 
 class FactImportance(int, Enum):
     """Score d'importance d'un fait — décide l'ordre et la sélection."""

picarones/core/narrative/templates/en.yaml

@@ -87,3 +87,9 @@ engine_unstable: >-
   Over {n_runs} successive runs, {engine} produces variable outputs
   (CER CV {cer_cv_pct} %, identical-run pair rate {identical_run_rate_pct} %).
   Reproducibility is limited — interpret the average CER with caution.
+
+regression_in_history: >-
+  Over the {n_runs} historical runs for {engine}, the average CER
+  moved from {first_cer_pct} % to {last_cer_pct} %
+  (cumulative change {absolute_delta_pct} points). Investigate what
+  changed in the pipeline or the models.

picarones/core/narrative/templates/fr.yaml

@@ -91,3 +91,9 @@ engine_unstable: >-
   Sur {n_runs} runs successifs, {engine} produit des sorties variables
   (CV CER {cer_cv_pct} %, paires de runs identiques {identical_run_rate_pct} %).
   La reproductibilité est limitée — interpréter le CER moyen avec prudence.
+
+regression_in_history: >-
+  Sur les {n_runs} runs historiques pour {engine}, le CER moyen
+  est passé de {first_cer_pct} % à {last_cer_pct} %
+  (variation cumulée {absolute_delta_pct} points). Vérifier ce qui
+  a changé dans le pipeline ou les modèles.

picarones/report/i18n/en.json

@@ -341,5 +341,15 @@
   "throughput_effective": "Pages/h usable",
   "throughput_drag": "% correction",
   "throughput_pages": "Pages",
-  "throughput_errors": "Errors"
+  "throughput_errors": "Errors",
+  "longitudinal_title": "Evolution over time",
+  "longitudinal_note": "Trend and change-points on the SQLite history of previous runs. A positive change signals cumulative degradation — useful to link a regression to a pipeline or model change.",
+  "longitudinal_engine": "Engine",
+  "longitudinal_n_runs": "Runs",
+  "longitudinal_first": "First CER",
+  "longitudinal_last": "Last CER",
+  "longitudinal_delta": "Cumulative Δ (pts)",
+  "longitudinal_slope": "Annual slope (pts/yr)",
+  "longitudinal_r2": "R²",
+  "longitudinal_change": "Change-point"
 }

picarones/report/i18n/fr.json

@@ -341,5 +341,15 @@
   "throughput_effective": "Pages/h utilisable",
   "throughput_drag": "% correction",
   "throughput_pages": "Pages",
-  "throughput_errors": "Erreurs"
+  "throughput_errors": "Erreurs",
+  "longitudinal_title": "Évolution dans le temps",
+  "longitudinal_note": "Tendance et points de rupture sur l'historique SQLite des runs précédents. Une variation positive signale une dégradation cumulée — utile pour relier une régression à un changement de pipeline ou de modèle.",
+  "longitudinal_engine": "Moteur",
+  "longitudinal_n_runs": "Runs",
+  "longitudinal_first": "Premier CER",
+  "longitudinal_last": "Dernier CER",
+  "longitudinal_delta": "Δ cumulé (pts)",
+  "longitudinal_slope": "Pente annuelle (pts/an)",
+  "longitudinal_r2": "R²",
+  "longitudinal_change": "Rupture"
 }

picarones/report/longitudinal_render.py

@@ -0,0 +1,174 @@
+"""Rendu HTML « Évolution dans le temps » — Sprint 92 (A.II.9).
+
+Suite directe ``picarones/core/longitudinal.py``.  Pattern
+identique aux autres rendus : server-side, pas de JS, anti-
+injection systématique.
+
+Vue
+---
+Tableau résumé moteur × {n_runs, premier CER, dernier CER,
+variation cumulée colorée, pente annualisée, R², point de
+rupture si détecté}.
+
+Adaptive : ``""`` si la liste est vide.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose :
+
+.. code-block:: python
+
+    from picarones.core.history import BenchmarkHistory
+    from picarones.core.longitudinal import compute_corpus_longitudinal
+    from picarones.report.longitudinal_render import build_longitudinal_html
+
+    hist = BenchmarkHistory(db_path)
+    entries = hist.list_entries()
+    trends = compute_corpus_longitudinal(entries, corpus_name)
+    html = build_longitudinal_html(trends, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+def _color_for_delta(delta_pct: float) -> str:
+    """Vert (≈0) → orange → rouge (≥ +5 pts CER) ;
+    vert → bleu (≤ -5 pts CER, amélioration)."""
+    if abs(delta_pct) < 1.0:
+        return "#a7f0a7"
+    f = max(-1.0, min(1.0, delta_pct / 5.0))
+    if f >= 0:
+        # vert → orange profond → rouge profond
+        if f < 0.5:
+            t = f / 0.5
+            r = int(167 + (235 - 167) * t)
+            g = int(240 + (180 - 240) * t)
+            b = int(167 + (60 - 167) * t)
+        else:
+            t = (f - 0.5) / 0.5
+            r = int(235 + (220 - 235) * t)
+            g = int(180 + (50 - 180) * t)
+            b = int(60 + (50 - 60) * t)
+    else:
+        # vert → bleu (amélioration)
+        f = -f
+        r = int(167 + (90 - 167) * f)
+        g = int(240 + (160 - 240) * f)
+        b = int(167 + (210 - 167) * f)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def build_longitudinal_html(
+    trends: Optional[list],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la vue HTML longitudinale.
+
+    Parameters
+    ----------
+    trends:
+        Sortie de ``compute_corpus_longitudinal`` (liste de
+        dicts).  Si ``None`` ou vide, retourne ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``longitudinal_*``.
+    """
+    if not trends:
+        return ""
+    rows = [t for t in trends if isinstance(t, dict) and t.get("engine_name")]
+    if not rows:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "longitudinal_title", "Évolution dans le temps",
+    )
+    note = labels.get(
+        "longitudinal_note",
+        "Tendance et points de rupture sur l'historique SQLite "
+        "des runs précédents. Une variation positive signale "
+        "une dégradation cumulée — utile pour relier une "
+        "régression à un changement de pipeline ou de modèle.",
+    )
+    h_engine = labels.get("longitudinal_engine", "Moteur")
+    h_n_runs = labels.get("longitudinal_n_runs", "Runs")
+    h_first = labels.get("longitudinal_first", "Premier CER")
+    h_last = labels.get("longitudinal_last", "Dernier CER")
+    h_delta = labels.get("longitudinal_delta", "Δ cumulé (pts)")
+    h_slope = labels.get("longitudinal_slope", "Pente annuelle (pts/an)")
+    h_r2 = labels.get("longitudinal_r2", "R²")
+    h_change = labels.get("longitudinal_change", "Rupture")
+
+    parts = [
+        '<section class="longitudinal-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.6rem">'
+        f'{_e(note)}</div>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+    ]
+    for col in (h_engine, h_n_runs, h_first, h_last, h_delta,
+                h_slope, h_r2, h_change):
+        parts.append(
+            f'<th style="padding:.4rem .6rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+    for entry in sorted(
+        rows,
+        key=lambda r: -float(r.get("absolute_delta") or 0.0),
+    ):
+        engine = str(entry.get("engine_name") or "?")
+        n_runs = int(entry.get("n_runs") or 0)
+        first_cer = float(entry.get("first_cer") or 0.0)
+        last_cer = float(entry.get("last_cer") or 0.0)
+        delta_pct = float(entry.get("absolute_delta_pct") or 0.0)
+        delta_color = _color_for_delta(delta_pct)
+        trend = entry.get("trend") or {}
+        slope = trend.get("slope")
+        r2 = trend.get("r_squared")
+        slope_str = (
+            f"{float(slope) * 365 * 100:+.2f}"
+            if isinstance(slope, (int, float)) else "—"
+        )
+        r2_str = (
+            f"{float(r2):.2f}"
+            if isinstance(r2, (int, float)) else "—"
+        )
+        cp = entry.get("change_point")
+        if isinstance(cp, dict) and cp.get("timestamp"):
+            cp_delta = float(cp.get("delta") or 0.0)
+            cp_str = (
+                f'{_e(str(cp["timestamp"]))} '
+                f'<span style="opacity:.75">'
+                f'({cp_delta * 100:+.2f} pts)</span>'
+            )
+        else:
+            cp_str = "—"
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(engine)}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{n_runs}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{first_cer * 100:.2f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{last_cer * 100:.2f}%</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{delta_color};font-family:monospace;'
+            f'font-weight:600">{delta_pct:+.2f}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{slope_str}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'font-family:monospace">{r2_str}</td>'
+            f'<td style="padding:.4rem .6rem">{cp_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></section>")
+    return "".join(parts)
+
+
+__all__ = ["build_longitudinal_html"]

tests/test_sprint92_longitudinal.py

@@ -0,0 +1,428 @@
+"""Tests Sprint 92 — A.II.9 : métriques longitudinales.
+
+Couvre :
+
+1. ``compute_linear_trend`` : pente, R², garde-fous.
+2. ``detect_change_point`` : index correct, garde-fous.
+3. ``compute_engine_longitudinal`` : intégration entries.
+4. ``compute_corpus_longitudinal`` : agrégation multi-moteurs.
+5. Détecteur ``regression_in_history`` :
+   - silence sans data
+   - silence si tendance plate
+   - HIGH si Δ ≥ 5 pts
+   - réagit à change-point seul
+   - traçabilité anti-hallucination FR + EN.
+6. Vue HTML : adaptive, anti-injection, FR + EN.
+7. Complétude i18n.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+import pytest
+
+from picarones.core.longitudinal import (
+    compute_corpus_longitudinal,
+    compute_engine_longitudinal,
+    compute_linear_trend,
+    detect_change_point,
+)
+from picarones.core.narrative import build_synthesis
+from picarones.core.narrative.detectors import detect_regression_in_history
+from picarones.core.narrative.facts import FactImportance, FactType
+from picarones.report.longitudinal_render import build_longitudinal_html
+
+
+def _load_labels(lang: str) -> dict:
+    p = (
+        Path(__file__).parent.parent
+        / "picarones" / "report" / "i18n" / f"{lang}.json"
+    )
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. compute_linear_trend
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestLinearTrend:
+    def test_perfect_trend(self) -> None:
+        series = [
+            ("2025-01-01", 0.04), ("2025-02-01", 0.05),
+            ("2025-03-01", 0.06),
+        ]
+        t = compute_linear_trend(series)
+        assert t.r_squared > 0.99
+        assert t.slope > 0  # CER monte → pente positive
+        assert t.n_runs == 3
+
+    def test_flat_series(self) -> None:
+        series = [
+            ("2025-01-01", 0.05), ("2025-02-01", 0.05),
+            ("2025-03-01", 0.05),
+        ]
+        t = compute_linear_trend(series)
+        # Série plate : pente ≈ 0. R² mathématiquement indéterminé
+        # (variance nulle sur y) ; le code accepte 0 ou 1 selon
+        # l'arrondi flottant.
+        assert t.slope == pytest.approx(0.0, abs=1e-9)
+        assert t.r_squared in (0.0, 1.0) or 0.0 <= t.r_squared <= 1.0
+
+    def test_lt_two_returns_none(self) -> None:
+        assert compute_linear_trend([("2025-01-01", 0.05)]) is None
+        assert compute_linear_trend([]) is None
+
+    def test_invalid_timestamps_skipped(self) -> None:
+        # Tous invalides → < 2 valides
+        assert compute_linear_trend([
+            ("invalid", 0.05), ("garbage", 0.06),
+        ]) is None
+
+    def test_same_timestamp_returns_none(self) -> None:
+        # Tous les t identiques → variance nulle
+        assert compute_linear_trend([
+            ("2025-01-01", 0.05), ("2025-01-01", 0.06),
+            ("2025-01-01", 0.07),
+        ]) is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. detect_change_point
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestChangePoint:
+    def test_clean_break(self) -> None:
+        # 3 points à 0.04 puis 3 points à 0.07
+        series = [
+            ("2025-01-01", 0.04), ("2025-01-15", 0.04),
+            ("2025-02-01", 0.04), ("2025-02-15", 0.07),
+            ("2025-03-01", 0.07), ("2025-03-15", 0.07),
+        ]
+        cp = detect_change_point(series, min_segment_size=3)
+        assert cp is not None
+        assert cp.index == 3
+        assert cp.delta == pytest.approx(0.03)
+
+    def test_too_few_points(self) -> None:
+        series = [
+            ("2025-01-01", 0.04), ("2025-02-01", 0.05),
+        ]
+        assert detect_change_point(series, min_segment_size=3) is None
+
+    def test_uniform_series_returns_change_with_delta_zero(self) -> None:
+        series = [
+            ("2025-01-01", 0.05), ("2025-02-01", 0.05),
+            ("2025-03-01", 0.05), ("2025-04-01", 0.05),
+            ("2025-05-01", 0.05), ("2025-06-01", 0.05),
+        ]
+        cp = detect_change_point(series, min_segment_size=3)
+        # delta = 0
+        assert cp is not None
+        assert abs(cp.delta) < 1e-9
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. compute_engine_longitudinal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestEngineLongitudinal:
+    def _entries(self) -> list[dict]:
+        return [
+            {"engine_name": "tess", "corpus_name": "bnf",
+             "timestamp": ts, "cer_mean": cer}
+            for ts, cer in [
+                ("2025-01-01", 0.04), ("2025-02-01", 0.045),
+                ("2025-03-01", 0.05), ("2025-04-01", 0.06),
+                ("2025-05-01", 0.07), ("2025-06-01", 0.08),
+            ]
+        ]
+
+    def test_basic(self) -> None:
+        r = compute_engine_longitudinal(
+            self._entries(), "tess", corpus_name="bnf",
+        )
+        assert r is not None
+        assert r["n_runs"] == 6
+        assert r["trend"]["slope"] > 0
+        assert r["absolute_delta_pct"] == pytest.approx(4.0, abs=0.01)
+
+    def test_filters_corpus(self) -> None:
+        entries = self._entries() + [
+            {"engine_name": "tess", "corpus_name": "other",
+             "timestamp": "2025-07-01", "cer_mean": 0.99},
+        ]
+        r = compute_engine_longitudinal(
+            entries, "tess", corpus_name="bnf",
+        )
+        # L'entrée "other" ne doit pas polluer
+        assert r["n_runs"] == 6
+
+    def test_min_runs_threshold(self) -> None:
+        # min_runs_for_trend=10 > n_runs=6
+        r = compute_engine_longitudinal(
+            self._entries(), "tess", corpus_name="bnf",
+            min_runs_for_trend=10,
+        )
+        assert r is None
+
+    def test_change_point_threshold(self) -> None:
+        # Avec un threshold immense, le change-point est supprimé
+        r = compute_engine_longitudinal(
+            self._entries(), "tess",
+            change_point_threshold=1.0,
+        )
+        assert r["change_point"] is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. compute_corpus_longitudinal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestCorpusLongitudinal:
+    def test_multiple_engines(self) -> None:
+        entries: list[dict] = []
+        for engine in ("tess", "pero"):
+            for i, cer in enumerate([0.04, 0.045, 0.05, 0.06]):
+                entries.append({
+                    "engine_name": engine, "corpus_name": "bnf",
+                    "timestamp": f"2025-0{i + 1}-01",
+                    "cer_mean": cer,
+                })
+        out = compute_corpus_longitudinal(entries, corpus_name="bnf")
+        names = [e["engine_name"] for e in out]
+        assert "tess" in names
+        assert "pero" in names
+
+    def test_empty(self) -> None:
+        assert compute_corpus_longitudinal([]) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 5. Détecteur regression_in_history
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestDetector:
+    def test_silent_without_data(self) -> None:
+        assert detect_regression_in_history({}) == []
+        assert detect_regression_in_history(
+            {"longitudinal_trends": []},
+        ) == []
+
+    def test_silent_when_flat(self) -> None:
+        data = {"longitudinal_trends": [{
+            "engine_name": "tess", "n_runs": 5,
+            "trend": {"slope": 1e-7, "r_squared": 0.0,
+                      "intercept": 0.05, "n_runs": 5},
+            "change_point": None,
+            "first_cer": 0.05, "last_cer": 0.05,
+            "absolute_delta": 0.0, "absolute_delta_pct": 0.0,
+        }]}
+        assert detect_regression_in_history(data) == []
+
+    def test_emits_when_slope_high(self) -> None:
+        # Slope > 1 pt CER / 365 jours
+        data = {"longitudinal_trends": [{
+            "engine_name": "tess", "n_runs": 5,
+            "trend": {"slope": 0.0005, "r_squared": 0.9,
+                      "intercept": 0.04, "n_runs": 5},
+            "change_point": None,
+            "first_cer": 0.04, "last_cer": 0.06,
+            "absolute_delta": 0.02, "absolute_delta_pct": 2.0,
+        }]}
+        facts = detect_regression_in_history(data)
+        assert len(facts) == 1
+        assert facts[0].type == FactType.REGRESSION_IN_HISTORY
+        assert facts[0].importance == FactImportance.MEDIUM
+        assert facts[0].payload["pattern"] == "trend"
+
+    def test_emits_high_when_delta_large(self) -> None:
+        # |Δ| ≥ 5 pts → HIGH
+        data = {"longitudinal_trends": [{
+            "engine_name": "tess", "n_runs": 8,
+            "trend": {"slope": 0.001, "r_squared": 0.95,
+                      "intercept": 0.04, "n_runs": 8},
+            "change_point": None,
+            "first_cer": 0.04, "last_cer": 0.10,
+            "absolute_delta": 0.06, "absolute_delta_pct": 6.0,
+        }]}
+        facts = detect_regression_in_history(data)
+        assert facts[0].importance == FactImportance.HIGH
+
+    def test_emits_on_change_point_only(self) -> None:
+        # Slope nul mais rupture brutale
+        data = {"longitudinal_trends": [{
+            "engine_name": "tess", "n_runs": 8,
+            "trend": {"slope": 1e-8, "r_squared": 0.0,
+                      "intercept": 0.04, "n_runs": 8},
+            "change_point": {
+                "index": 4, "timestamp": "2025-03-01",
+                "mean_before": 0.04, "mean_after": 0.07,
+                "delta": 0.03, "n_before": 4, "n_after": 4,
+            },
+            "first_cer": 0.04, "last_cer": 0.07,
+            "absolute_delta": 0.03, "absolute_delta_pct": 3.0,
+        }]}
+        facts = detect_regression_in_history(data)
+        assert len(facts) == 1
+        assert facts[0].payload["pattern"] == "change_point"
+        assert "change_point_timestamp" in facts[0].payload
+
+    def test_silent_when_lt_three_runs(self) -> None:
+        data = {"longitudinal_trends": [{
+            "engine_name": "tess", "n_runs": 2,
+            "trend": {"slope": 0.001, "r_squared": 0.9,
+                      "intercept": 0.04, "n_runs": 2},
+            "change_point": None,
+            "absolute_delta": 0.05,
+        }]}
+        assert detect_regression_in_history(data) == []
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 6. Anti-hallucination synthesis
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _payload_numbers(payload: dict) -> set[str]:
+    out: set[str] = set()
+    for v in payload.values():
+        if isinstance(v, (int, float)):
+            out.add(str(v))
+            if isinstance(v, float) and v.is_integer():
+                out.add(str(int(v)))
+    return out
+
+
+def _numbers_in(text: str) -> set[str]:
+    return set(re.findall(r"\d+(?:\.\d+)?", text))
+
+
+class TestAntiHallucination:
+    def _build(self, lang: str) -> tuple[list[str], dict]:
+        data = {
+            "ranking": [{"engine": "tess", "mean_cer": 0.07}],
+            "engines": [{"name": "tess", "mean_cer": 0.07}],
+            "meta": {"document_count": 5},
+            "longitudinal_trends": [{
+                "engine_name": "tess", "n_runs": 8,
+                "trend": {"slope": 0.0002, "r_squared": 0.91,
+                          "intercept": 0.04, "n_runs": 8},
+                "change_point": None,
+                "first_cer": 0.04, "last_cer": 0.07,
+                "absolute_delta": 0.03,
+                "absolute_delta_pct": 3.0,
+                "first_cer_pct": 4.0, "last_cer_pct": 7.0,
+            }],
+        }
+        synthesis = build_synthesis(data, lang=lang, max_facts=10)
+        facts = detect_regression_in_history(data)
+        return synthesis["sentences"], facts[0].payload
+
+    def _find(self, sentences: list[str], lang: str) -> str:
+        marker = "modèles" if lang == "fr" else "models"
+        for s in sentences:
+            if marker in s:
+                return s
+        raise AssertionError(f"phrase introuvable : {sentences}")
+
+    def test_fr_traceable(self) -> None:
+        sentences, payload = self._build("fr")
+        sentence = self._find(sentences, "fr")
+        rendered = _numbers_in(sentence)
+        allowed = _payload_numbers(payload)
+        assert rendered.issubset(allowed), (
+            f"non traçable : {rendered - allowed}"
+        )
+
+    def test_en_traceable(self) -> None:
+        sentences, payload = self._build("en")
+        sentence = self._find(sentences, "en")
+        rendered = _numbers_in(sentence)
+        allowed = _payload_numbers(payload)
+        assert rendered.issubset(allowed), (
+            f"non traçable : {rendered - allowed}"
+        )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 7. Vue HTML
+# ───────────────────────────────────────────────────────────────���──────────
+
+
+class TestRender:
+    def test_empty_returns_empty(self) -> None:
+        assert build_longitudinal_html(None) == ""
+        assert build_longitudinal_html([]) == ""
+
+    def test_renders_table(self) -> None:
+        trends = [{
+            "engine_name": "tess", "n_runs": 8,
+            "trend": {"slope": 0.0001, "r_squared": 0.85},
+            "change_point": {
+                "timestamp": "2025-03-01", "delta": 0.025,
+            },
+            "first_cer": 0.04, "last_cer": 0.07,
+            "absolute_delta": 0.03, "absolute_delta_pct": 3.0,
+        }]
+        html = build_longitudinal_html(trends, _load_labels("fr"))
+        assert "<table" in html
+        assert "tess" in html
+        # Δ +3.00
+        assert "+3.00" in html
+        # change-point
+        assert "2025-03-01" in html
+
+    def test_anti_injection(self) -> None:
+        trends = [{
+            "engine_name": "<script>alert(1)</script>",
+            "n_runs": 5,
+            "trend": {"slope": 0.001, "r_squared": 0.9},
+            "change_point": None,
+            "first_cer": 0.04, "last_cer": 0.05,
+            "absolute_delta": 0.01, "absolute_delta_pct": 1.0,
+        }]
+        html = build_longitudinal_html(trends, _load_labels("fr"))
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_renders_in_english(self) -> None:
+        trends = [{
+            "engine_name": "tess", "n_runs": 5,
+            "trend": {"slope": 0.001, "r_squared": 0.9},
+            "change_point": None,
+            "first_cer": 0.04, "last_cer": 0.05,
+            "absolute_delta": 0.01, "absolute_delta_pct": 1.0,
+        }]
+        html = build_longitudinal_html(trends, _load_labels("en"))
+        assert "Evolution over time" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 8. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_KEYS = {
+    "longitudinal_title", "longitudinal_note", "longitudinal_engine",
+    "longitudinal_n_runs", "longitudinal_first", "longitudinal_last",
+    "longitudinal_delta", "longitudinal_slope", "longitudinal_r2",
+    "longitudinal_change",
+}
+
+
+class TestI18n:
+    def test_fr(self) -> None:
+        d = _load_labels("fr")
+        assert not _KEYS - d.keys()
+
+    def test_en(self) -> None:
+        d = _load_labels("en")
+        assert not _KEYS - d.keys()