docs(config): .env.example aligne sur Settings, seed aux 14 domaines, README a jour

.env.example :
- chaque reglage de Mistral et de Groq y figure, avec les plafonds verifies
du palier gratuit ; MISTRAL_MODEL suit le defaut de config.py (14b) ;
INTENT_CLASSIFIER n'annonce plus « local » ;
- plus aucun commentaire en fin de ligne : docker --env-file le garde dans
la valeur, et « groq # groq | local » etait refuse au demarrage ;
- l'extraction des PDF annonce Docling, son moteur par defaut.
tests/test_core/test_env_example.py verifie que chaque cle est un reglage
(Settings ignore en silence une cle inconnue), qu'aucune ligne ne porte de
commentaire, que les valeurs actives se chargent et que chaque reglage des
fournisseurs est documente.

scripts/seed_database.py semait cinq categories aux identifiants fixes et
aux noms d'avant la migration 013 : sur une base migree, une quinzieme
categorie, et des lois rattachees a l'identifiant 1, 2 ou 3, quel qu'il
soit. Il cree les 14 domaines manquants par leur nom et rattache ses lois
par le nom.

Textes perimes : « 12 categories » du modele Category, exemples des routes
de categories et du schema de recherche. generate_eval_set.py ne plantait
plus apres une generation entiere sur la cle `rejected`.

README : Mistral et Groq avec leurs quotas reels et leur comportement en
cas de saturation, la procedure de reclassement, Alembic qui exige
DATABASE_URL, les marqueurs groq_live et mistral_live et la garde reseau.

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

.env.example

@@ -37,20 +37,60 @@ DATABASE_URL=postgresql+asyncpg://jurix:jurix@localhost:5433/jurix_dev
 # differents.
 PGSSLMODE=require
 
-# ---- LLM Provider pour le Chat RAG ----
-# LLM_PROVIDER=mistral        # mistral (recommandé, rapide, bilingue FR/EN) | gemini
+# ---- Generation du chat (LLM_PROVIDER) ----
+# mistral (defaut : rapide, bilingue FR/EN) ou gemini.
+#
+# Aucune ligne de ce fichier ne porte de commentaire a sa suite : docker
+# --env-file le garderait DANS la valeur (INTENT_CLASSIFIER deviendrait
+# « groq   # groq | local », refuse au demarrage).
 LLM_PROVIDER=mistral
 
-# ---- Mistral AI (LLM de génération du Chat RAG) ----
-# Clé API : https://console.mistral.ai
+# ---- Mistral AI ----
+# Cle API : https://console.mistral.ai
+# Palier gratuit (verifie le 07/10/2026) : 30 requetes par minute pour
+# ministral-14b, 188 pour ministral-8b. Une reponse coupee est completee une
+# fois ; un 429 est rejoue, puis passe au modele de secours.
 MISTRAL_API_KEY=your-mistral-api-key-here
-MISTRAL_MODEL=ministral-8b-latest
-
-# ---- Groq (Routage d'intention ultra-rapide < 100 ms) ----
-# Clé API : https://console.groq.com
-INTENT_CLASSIFIER=groq        # groq (recommandé) | local | gemini
+MISTRAL_MODEL=ministral-14b-latest
+# Modele essaye quand le principal reste en 429. Vide : pas de secours.
+# MISTRAL_MODEL_SECOURS=ministral-8b-latest
+# Delai minimal d'une reponse entiere (il croit avec le budget de jetons) ;
+# en flux, delai maximal entre deux morceaux.
+# MISTRAL_TIMEOUT_S=60
+# MISTRAL_REQUETES_PAR_SECONDE=0.5
+# MISTRAL_REQUETES_PAR_SECONDE_SECOURS=3.0
+# Generations simultanees au plus.
+# MISTRAL_CONCURRENCE=4
+# Attente totale acceptee (limiteur et 429) avant de repondre « sature,
+# reessayez » (503).
+# MISTRAL_ATTENTE_MAX_S=20
+# Jetons de la suite demandee quand une reponse est coupee.
+# MISTRAL_JETONS_SUITE=2048
+
+# ---- Groq : classement d'intention et classement des lois ----
+# Cle API : https://console.groq.com
+# Palier gratuit, PAR MODELE : 30 requetes et 8 000 jetons par minute,
+# 1 000 requetes et 200 000 jetons par jour. Un quota epuise ferme le modele
+# jusqu'a l'echeance : le chat traite alors chaque message comme une question
+# de droit, et le reclassement s'arrete en disant quand reprendre.
 GROQ_API_KEY=your-groq-api-key-here
+# groq (defaut) ou llm (le modele du chat : un appel de plus par question).
+INTENT_CLASSIFIER=groq
+# Modele du classement d'intention (chaque message du chat).
 GROQ_MODEL=qwen/qwen3.8-27b
+# Modele du classement des lois : son quota est distinct de celui du chat.
+GROQ_MODEL_CLASSEMENT=openai/gpt-oss-120b
+# GROQ_TIMEOUT_S=10
+# Au-dela, le message est traite comme une question de droit.
+# GROQ_INTENTION_TIMEOUT_S=3
+# GROQ_REQUETES_PAR_MINUTE=30
+# GROQ_RAFALE=5
+# GROQ_JETONS_PAR_MINUTE=8000
+# GROQ_JETONS_ENTREE_PAR_MINUTE=7000
+# GROQ_REQUETES_PAR_JOUR=1000
+# GROQ_JETONS_PAR_JOUR=200000
+# Attente imposee par un 429 au-dela de laquelle c'est un quota epuise.
+# GROQ_ATTENTE_MAX_429_S=120
 
 # ---- Gemini API (optionnel) ----
 # GEMINI_API_KEY=your-gemini-api-key-here
@@ -69,13 +109,17 @@ GROQ_MODEL=qwen/qwen3.8-27b
 # Apres une migration de dimension ou un changement de fournisseur :
 #   python scripts/regenerate_embeddings.py --all
 #   python scripts/regenerate_embeddings.py --reindex
-# EMBEDDING_PROVIDER=gemma          # gemma (local, defaut) | gemini (API payante)
+# gemma (local, defaut) ou gemini (API payante).
+# EMBEDDING_PROVIDER=gemma
 # GEMMA_MODEL_DIR=models/embeddinggemma-300m-onnx
-# GEMMA_INTRA_OP_THREADS=0          # 0 = coeurs physiques moins un
+# 0 = coeurs physiques moins un.
+# GEMMA_INTRA_OP_THREADS=0
 
 # ---- Extraction des PDF ----
-# L'extraction passe par Gemini multimodal : meme cle que la generation.
-# Pages envoyees par appel. La limite du modele est de 65 536 jetons EN SORTIE ;
+# docling (defaut) : en local, gratuit, OCR de toutes les pages. gemini :
+# l'API multimodale payante, reglee par les PDF_EXTRACTION_* ci-dessous.
+# PDF_EXTRACTION_ENGINE=docling
+# Pages envoyees par appel a Gemini. La limite du modele est de 65 536 jetons EN SORTIE ;
 # a ~2400 caracteres par page, 20 pages en produisent ~13 000. Le palier gratuit
 # plafonne a 20 appels par jour : agrandir le lot economise des appels.
 # PDF_EXTRACTION_PAGES_PER_CALL=20
@@ -130,15 +174,18 @@ ALLOWED_ORIGINS=https://jurix.vercel.app
 # Ils etaient absents de ce fichier alors qu'ils pilotent tout le classement.
 # Attention : config.py pose `extra = "ignore"`, donc une cle mal orthographiee
 # ici est ignoree EN SILENCE.
-# EMBEDDING_DIM=768               # fixe : la colonne est en vector(768), toute
-#                                 # autre valeur est refusee au demarrage
+# Fixe : la colonne est en vector(768), toute autre valeur est refusee au
+# demarrage.
+# EMBEDDING_DIM=768
 # GEMINI_TIMEOUT_S=120
 # RERANK_ENABLED=true
 # RERANK_LLM_ENABLED=false
 # RERANK_LLM_TOP_N=20
 # RERANK_LLM_TIMEOUT_S=4.0
-# TITLE_TRIGRAM_THRESHOLD=0.5     # tolerance aux fautes sur les titres
-# RRF_K=60                        # fusion des classements texte et semantique
+# Tolerance aux fautes sur les titres.
+# TITLE_TRIGRAM_THRESHOLD=0.5
+# Fusion des classements texte et semantique.
+# RRF_K=60
 # TEXT_WEIGHT=0.4
 # SEMANTIC_WEIGHT=0.6
 

README.md

@@ -4,7 +4,7 @@ API de la plateforme juridique camerounaise JuriX.
 
 Recherche et question-réponse sur un corpus de textes officiels : recherche
 plein texte et sémantique, extraction OCR des PDF scannés, découpage par
-article, réponses citées via Gemini.
+article, réponses citées via Mistral, classements par Groq.
 
 ## Pile technique
 
@@ -15,7 +15,8 @@ article, réponses citées via Gemini.
 | Recherche plein texte | `tsvector` / `websearch_to_tsquery`, index GIN, triggers |
 | Recherche sémantique | `pgvector` + index HNSW, embeddings EmbeddingGemma 768 dim. calculés en local (Gemini en option) |
 | Cache | tables `query_cache` et `embedding_cache` |
-| LLM | Gemini (`google-genai`) |
+| Réponses du chat, explications, comparaisons | Mistral `ministral-14b` (API REST, `LLM_PROVIDER=mistral`) ; Gemini en option |
+| Classement d'intention et des lois | Groq : `qwen3.8-27b` (chat), `gpt-oss-120b` (lois) |
 | Extraction PDF | Docling en local, OCR pleine page (Gemini en option) |
 | Tâches de fond | `BackgroundTasks` FastAPI |
 
@@ -26,7 +27,9 @@ d'attente sont assurés par PostgreSQL et par le serveur applicatif.
 
 - Python 3.11
 - PostgreSQL 16 avec les extensions `vector` et `pg_trgm`
-- Une clé API Gemini (Google AI Studio), pour le chat
+- Une clé API Mistral (console.mistral.ai), pour le chat
+- Une clé API Groq (console.groq.com), pour le classement des messages et des
+  lois
 - Le modèle EmbeddingGemma sur disque (voir plus bas), pour la recherche
   sémantique
 - Pour ingérer des PDF : Docling et torch (`requirements-ingestion.txt`), un GPU
@@ -52,7 +55,9 @@ pip install -r requirements-dev.txt      # + outils de test
 
 cp .env.example .env                     # puis renseigner les valeurs
 
-alembic upgrade head                     # schéma, extensions, index, triggers
+# Schéma, extensions, index, triggers. Alembic ne lit PAS le .env : la base
+# visée est nommée à chaque commande, et elle est affichée avant de migrer.
+DATABASE_URL=postgresql://jurix:jurix@localhost:5433/jurix_dev alembic upgrade head
 python scripts/create_admin.py           # premier compte administrateur
 
 uvicorn app.main:app --reload
@@ -101,13 +106,70 @@ Toutes les variables de `.env.example` sont réellement lues par
 | Variable | Rôle |
 |---|---|
 | `DATABASE_URL` | `postgresql+asyncpg://…` — le driver asyncpg est obligatoire |
-| `GEMINI_API_KEY` / `GEMINI_MODEL` | LLM des réponses. Modèles Flash actuels : `gemini-3.8-flash`, `3.7`, `3.6`, `3.5` |
+| `LLM_PROVIDER` | `mistral` (défaut) ou `gemini` : le modèle des réponses, explications et comparaisons |
+| `MISTRAL_API_KEY` / `MISTRAL_MODEL` | Modèle des réponses (`ministral-14b-latest`) ; `MISTRAL_MODEL_SECOURS` (`ministral-8b-latest`) sert quand le premier reste saturé |
+| `GROQ_API_KEY` | Classement d'intention (`GROQ_MODEL`) et classement des lois (`GROQ_MODEL_CLASSEMENT`), deux modèles pour deux quotas |
+| `INTENT_CLASSIFIER` | `groq` (défaut) ou `llm` (le modèle du chat, un appel de plus par question) |
+| `GEMINI_API_KEY` / `GEMINI_MODEL` | Seulement si `LLM_PROVIDER=gemini` ou `EMBEDDING_PROVIDER=gemini` |
 | `EMBEDDING_PROVIDER` | `gemma` (défaut, local et gratuit) ou `gemini` (API payante). En changer impose de régénérer les vecteurs |
 | `GEMMA_MODEL_DIR` | Dossier du modèle EmbeddingGemma (défaut `models/embeddinggemma-300m-onnx`) |
 | `PDF_EXTRACTION_PAGES_PER_CALL` | Pages envoyées par appel d'extraction (défaut 20) |
 | `SECRET_KEY` | Signature JWT. **Obligatoire hors développement** : l'application refuse de démarrer si la valeur du dépôt est conservée |
 | `ADMIN_EMAIL` / `ADMIN_PASSWORD` | Valeurs par défaut de `scripts/create_admin.py` |
 
+### Fournisseurs et quotas
+
+Paliers gratuits vérifiés le 07/10/2026 :
+
+| Fournisseur | Modèle | Plafonds |
+|---|---|---|
+| Mistral | `ministral-14b` | 30 requêtes par minute |
+| Mistral | `ministral-8b` (secours) | 188 requêtes par minute |
+| Groq, **par modèle** | `qwen3.8-27b`, `gpt-oss-120b` | 30 requêtes et 8 000 jetons par minute, 1 000 requêtes et 200 000 jetons par jour |
+
+Chaque appel passe par un **limiteur** (`app/core/limiteur.py`) qui fait
+attendre avant d'envoyer, plutôt que de collectionner les refus.
+
+- **Mistral.** Un 429 est rejoué (`Retry-After`), puis le modèle de secours
+  prend le relais ; au-delà de 20 s d'attente, l'utilisateur reçoit « service
+  saturé, réessayez » (503), jamais « quota épuisé ». Une réponse coupée — budget
+  de jetons, ou flux rompu en cours de route — est **complétée** par une suite ;
+  la mention « réponse interrompue » ne reste que si la suite échoue. Chaque
+  appel journalise modèle, fin, jetons et durée.
+- **Groq, classement d'intention.** Consignes courtes, verdicts en cache. Quand
+  Groq ne peut pas répondre dans les temps (quota, attente, panne), le message
+  est traité comme une question de droit : c'est l'erreur sans conséquence. Mesure
+  sur 122 messages étiquetés : 121 justes, aucune question de droit perdue
+  (`python -m scripts.eval.evaluer_intention --limite 122`).
+- **Groq, classement des lois.** Par lots (40 titres par requête). Jamais de
+  catégorie inventée : un classement impossible laisse la catégorie vide et le
+  dit dans `processing_error`.
+
+### Reclassement des lois
+
+Les catégories se recalculent par lots, en deux temps, avec relecture entre
+les deux (`scripts/maintenance/reclassify_domains.py`) :
+
+```bash
+# 1. Verdicts dans data/reclassement/verdicts.jsonl, rien en base. Reprenable :
+#    une relance saute les lois déjà classées. Code 4 = quota du jour épuisé,
+#    l'heure de reprise est affichée.
+python scripts/maintenance/reclassify_domains.py classer --extrait 0 --lot 40
+python scripts/maintenance/reclassify_domains.py classer --incertains --extrait 500 --lot 15
+
+# 2. Simulation : rapport, changements.csv et a_revoir.csv. À RELIRE.
+python scripts/maintenance/reclassify_domains.py appliquer --dry-run
+
+# 3. Écriture en base, catégories déjà posées comprises.
+python scripts/maintenance/reclassify_domains.py appliquer --force
+```
+
+Une loi « à revoir » ou sous le seuil de confiance (`--seuil`, 0,6) n'est jamais
+appliquée. Le nom de la catégorie est figé dans le texte vectorisé
+(`embed_text`) : les lois de `changements.csv` sont à redécouper puis
+revectoriser. Pour une ingestion de masse, `ingest_corpus.py --sans-classement`
+laisse le classement à ce script : une requête pour 40 lois au lieu de 40.
+
 ## Authentification
 
 JWT porteur, trois rôles : `user`, `admin`, `superadmin`.
@@ -295,7 +357,7 @@ restauration ou un changement de fournisseur, les vecteurs manquants ou
 d'un autre modèle doivent être régénérés :
 
 ```bash
-alembic upgrade head
+DATABASE_URL=postgresql://jurix:jurix@localhost:5433/jurix_dev alembic upgrade head
 python scripts/regenerate_embeddings.py --all --batch-size 16   # reprenable
 python scripts/regenerate_embeddings.py --reindex               # index en masse
 ```
@@ -310,7 +372,7 @@ Les chunks remontés passent par `app/services/reranker.py` avant d'être tronqu
 et mis en cache. L'étage 1 est lexical (numéro d'article demandé, densité des
 termes, expression exacte, titre de loi, pénalité des formules d'exécution) :
 sans dépendance, sans réseau, actif par défaut. L'étage 2 fait noter les 20
-meilleurs chunks par Gemini ; il ajoute un appel facturé sur le chemin critique,
+meilleurs chunks par le modèle du chat ; il ajoute un appel sur le chemin critique,
 reste désactivé (`RERANK_LLM_ENABLED`) et dégrade toujours vers l'étage 1.
 
 ### Explication et comparaison
@@ -328,12 +390,13 @@ n'y a rien à converser :
   (`app/services/comparison_service.py`). **Une recherche par sujet**, l'une
   après l'autre : une requête unique mélangeant les deux termes rendait six
   articles d'un régime contre trois de l'autre, en ratant le bloc qui définissait
-  le second. La sortie est contrainte par un schéma JSON où chaque cellule doit
-  citer ses articles ; un numéro cité sans article correspondant est renvoyé
+  le second. La sortie est contrainte par un schéma JSON **strict** où chaque
+  cellule doit citer ses articles (une grille coupée est redemandée une fois, au
+  double du budget) ; un numéro cité sans article correspondant est renvoyé
   dans `unmatched_citations` plutôt qu'avalé, et le texte intégral des sources
   accompagne chaque cellule pour que le lecteur vérifie lui-même.
 
-Aucun des deux n'est mis en cache : chaque appel dépense un appel Gemini.
+Aucun des deux n'est mis en cache : chaque appel dépense un appel au modèle.
 
 ### Mesure
 
@@ -365,14 +428,24 @@ triggers, extensions) n'existent que dans les migrations, jamais dans
      realite n'en a jamais compte qu'un. -->
 
 export TEST_DATABASE_URL=postgresql+asyncpg://jurix:jurix@localhost:5433/jurix_test
-pytest                                   # tout
+pytest                                   # tout, sans aucun appel reseau
 pytest -m "not integration"              # sans base
+pytest -m groq_live                      # appels reels a Groq (une poignee)
+pytest -m mistral_live                   # appels reels a Mistral (cinq)
 pytest --cov=app --cov-report=term-missing
 ```
 
 Sans base joignable, les tests qui en dépendent sont **ignorés avec la commande
 à lancer** — jamais silencieusement verts.
 
+**Aucun appel réel par défaut.** Les clés de Gemini, Groq et Mistral sont
+remplacées par des clés factices, et une garde réseau fait échouer tout test qui
+tenterait de joindre Groq ou Mistral : une suite complète vidait le quota
+gratuit de Groq. Les tests marqués `groq_live` ou `mistral_live` lèvent la garde
+du seul service visé, avec les vraies clés, et ne tournent que sur demande
+(`-m`). `JURIX_E2E=1` garde les vraies clés et ouvre tout, pour un essai de bout
+en bout délibéré.
+
 ## Structure
 
 ```

app/api/routes/categories.py

@@ -140,9 +140,9 @@ async def list_categories(
     ```json
     [
         {
-            "id": 1,
-            "name": "Droit Civil",
-            "description": "Civil law",
+            "id": 1007,
+            "name": "Droit Civil et Procédure Civile",
+            "description": "Personnes, obligations, contrats, instances civiles et voies d'exécution",
             "created_at": "2024-01-01T00:00:00",
             "law_count": 45
         }
@@ -424,8 +424,8 @@ async def get_category_stats(
     **Example Response:**
     ```json
     {
-        "category_id": 1,
-        "category_name": "Droit Civil",
+        "category_id": 1007,
+        "category_name": "Droit Civil et Procédure Civile",
         "law_count": 45,
         "percentage": 26.47
     }
@@ -476,14 +476,14 @@ async def get_all_category_stats(
     ```json
     [
         {
-            "category_id": 1,
-            "category_name": "Droit Civil",
+            "category_id": 1007,
+            "category_name": "Droit Civil et Procédure Civile",
             "law_count": 45,
             "percentage": 26.47
         },
         {
-            "category_id": 2,
-            "category_name": "Droit Pénal",
+            "category_id": 1006,
+            "category_name": "Droit Pénal et Procédure Pénale",
             "law_count": 38,
             "percentage": 22.35
         }
@@ -532,9 +532,9 @@ async def get_id_to_name_mapping(
     **Example Response:**
     ```json
     {
-        "1": "Droit Civil",
-        "2": "Droit Pénal",
-        "3": "Droit Commercial"
+        "1007": "Droit Civil et Procédure Civile",
+        "1006": "Droit Pénal et Procédure Pénale",
+        "1010": "Droit des Affaires, Banque et OHADA"
     }
     ```
 
@@ -576,9 +576,9 @@ async def get_name_to_id_mapping(
     **Example Response:**
     ```json
     {
-        "Droit Civil": 1,
-        "Droit Pénal": 2,
-        "Droit Commercial": 3
+        "Droit Civil et Procédure Civile": 1007,
+        "Droit Pénal et Procédure Pénale": 1006,
+        "Droit des Affaires, Banque et OHADA": 1010
     }
     ```
 

app/models/law.py

@@ -4,7 +4,7 @@ Modèles SQLAlchemy pour les lois, articles et catégories.
 Ce module définit les modèles de base de données pour le système JuriX:
 - Law: Documents juridiques (lois, décrets, ordonnances)
 - Article: Articles individuels d'une loi
-- Category: Catégories juridiques (12 catégories camerounaises)
+- Category: Catégories juridiques (les 14 domaines canoniques, migration 013)
 
 Features v2.1:
 - Détection automatique de langue (language, language_confidence)
@@ -47,19 +47,11 @@ class Category(Base):
     """
     Modèle pour les catégories juridiques.
 
-    Représente les 12 catégories de droit camerounais:
-    1. Droit Constitutionnel
-    2. Droit Civil
-    3. Droit Pénal
-    4. Droit Commercial OHADA
-    5. Droit du Travail
-    6. Droit Fiscal
-    7. Droit Administratif
-    8. Droit Foncier
-    9. Droit de la Famille
-    10. Droit de l'Environnement
-    11. Droit International
-    12. Droit des Affaires
+    Représente les 14 domaines canoniques du droit camerounais, fixés par
+    la migration 013 et repris dans legal_domain_classifier.CANONICAL_DOMAINS
+    (un test vérifie l'accord) : du Droit Constitutionnel à l'Éducation,
+    Recherche, Culture et Médias. Une loi s'y rattache PAR LE NOM du domaine,
+    jamais par une position.
 
     Attributes:
         id: Identifiant unique

app/schemas/search.py

@@ -384,8 +384,8 @@ class SearchResponse(BaseModel):
                         "type": "code",
                         "language": "fr",
                         "status": "published",
-                        "category_id": 3,
-                        "category_name": "Droit Commercial OHADA",
+                        "category_id": 1010,
+                        "category_name": "Droit des Affaires, Banque et OHADA",
                         "relevance_score": 0.92,
                         "matched_articles": [],
                         "highlights": {

app/services/category_service.py

@@ -362,7 +362,7 @@ class CategoryService:
             Dictionary mapping category IDs to names
 
         Example:
-            {1: "Droit Civil", 2: "Droit Pénal", ...}
+            {1007: "Droit Civil et Procédure Civile", 1006: "Droit Pénal et Procédure Pénale", ...}
         """
         try:
             logger.debug("🗺️  Fetching category ID → Name mapping")
@@ -387,7 +387,7 @@ class CategoryService:
             Dictionary mapping category names to IDs
 
         Example:
-            {"Droit Civil": 1, "Droit Pénal": 2, ...}
+            {"Droit Civil et Procédure Civile": 1007, "Droit Pénal et Procédure Pénale": 1006, ...}
         """
         try:
             logger.debug("🗺️  Fetching category Name → ID mapping")

scripts/eval/generate_eval_set.py

@@ -208,7 +208,9 @@ def _write_review_file(path: Path, items: List[Dict[str, Any]],
     for index, item in enumerate(items):
         source = articles[item["expected_article_id"]]
         excerpt = " ".join(source["content"].split())[:140]
-        flag = " ⚠️" if item["rejected"] else ""
+        # `rejected` est retire des items retenus avant l'ecriture du jeu :
+        # le lire en dur levait KeyError apres une generation entiere.
+        flag = " ⚠️" if item.get("rejected") else ""
         lines.append(
             f"| {index} | {item['lexical_overlap']:.2f}{flag} | {item['question']} | "
             f"{source['reference']} art. {source['number']} — {excerpt}… |"

scripts/seed_database.py

@@ -1,4 +1,14 @@
-"""Seed database with sample Cameroonian laws for testing."""
+"""
+Seed database with sample Cameroonian laws for testing.
+
+Les categories sont les 14 domaines canoniques, crees PAR LEUR NOM s'ils
+manquent, et les lois s'y rattachent par le nom. L'ancienne version semait
+cinq categories aux identifiants fixes (1 a 5) et aux noms d'avant la
+migration 013 : sur une base migree, elle en ajoutait une quinzieme, et ses
+lois pointaient sur la categorie qui portait par hasard l'identifiant 1, 2
+ou 3 — le defaut meme que la resolution par le nom a corrige dans le
+pipeline.
+"""
 
 import asyncio
 import sys
@@ -11,21 +21,20 @@ from datetime import date
 
 from app.core.database import AsyncSessionLocal, Base, engine
 from app.models.law import Article, Category, Law
-
-SAMPLE_CATEGORIES = [
-    {"id": 1, "name": "Droit Civil", "description": "Droit civil camerounais"},
-    {"id": 2, "name": "Droit Commercial OHADA", "description": "Droit commercial OHADA"},
-    {"id": 3, "name": "Droit Pénal", "description": "Droit pénal camerounais"},
-    {"id": 4, "name": "Droit Administratif", "description": "Droit administratif"},
-    {"id": 5, "name": "Droit du Travail", "description": "Code du travail"},
-]
+from app.services.legal_domain_classifier import (
+    AFFAIRES,
+    CANONICAL_DOMAINS,
+    CIVIL,
+    DESCRIPTIONS_DOMAINES,
+    PENAL,
+)
 
 SAMPLE_LAWS = [
     {
         "reference": "LOI-2024-001",
         "title": "Code Civil Camerounais - Livre 1",
         "type": "Loi",
-        "category_id": 1,
+        "domaine": CIVIL,
         "language": "fr",
         "status": "published",
         "publication_date": date(2024, 1, 15),
@@ -73,7 +82,7 @@ Article 9. La responsabilité civile engage celui qui cause un dommage à autrui
         "reference": "LOI-OHADA-2023-015",
         "title": "Acte Uniforme OHADA - Droit Commercial",
         "type": "Acte Uniforme",
-        "category_id": 2,
+        "domaine": AFFAIRES,
         "language": "fr",
         "status": "published",
         "publication_date": date(2023, 6, 20),
@@ -115,7 +124,7 @@ Article 7. Les formes de sociétés commerciales reconnues sont : la société e
         "reference": "LOI-2016-007",
         "title": "Code Pénal Camerounais",
         "type": "Loi",
-        "category_id": 3,
+        "domaine": PENAL,
         "language": "fr",
         "status": "published",
         "publication_date": date(2016, 7, 12),
@@ -164,25 +173,33 @@ async def seed_database():
     print("   Tables created successfully")
 
     async with AsyncSessionLocal() as session:
-        # Create categories (skip if exist)
+        # Les 14 domaines, par leur nom : seuls les manquants sont crees.
         print("\n[2/4] Creating categories...")
         from sqlalchemy import select
-        result = await session.execute(select(Category))
-        existing_categories = result.scalars().all()
-
-        if not existing_categories:
-            for cat_data in SAMPLE_CATEGORIES:
-                category = Category(**cat_data)
-                session.add(category)
-            await session.commit()
-            print(f"   Created {len(SAMPLE_CATEGORIES)} categories")
-        else:
-            print(f"   Skipped (already exist: {len(existing_categories)} categories)")
+        presents = {
+            nom.lower(): identifiant
+            for nom, identifiant in (await session.execute(select(Category.name, Category.id))).all()
+        }
+        crees = 0
+        for ordre, nom in enumerate(CANONICAL_DOMAINS):
+            if nom.lower() not in presents:
+                session.add(Category(
+                    name=nom, description=DESCRIPTIONS_DOMAINES[nom], display_order=ordre,
+                ))
+                crees += 1
+        await session.commit()
+        ids = {
+            nom.lower(): identifiant
+            for nom, identifiant in (await session.execute(select(Category.name, Category.id))).all()
+        }
+        print(f"   {crees} created, {len(CANONICAL_DOMAINS) - crees} already present")
 
         # Create laws with articles
         print("\n[3/4] Creating laws and articles...")
         for law_data in SAMPLE_LAWS:
             articles_data = law_data.pop("articles")
+            # Rattachement par le NOM du domaine, jamais par une position.
+            law_data["category_id"] = ids[law_data.pop("domaine").lower()]
             law = Law(**law_data)
             session.add(law)
             await session.flush()  # Get law ID

tests/test_core/test_env_example.py

@@ -0,0 +1,77 @@
+"""
+.env.example et Settings s'accordent.
+
+`Settings` pose `extra = "ignore"` : une cle mal orthographiee dans le .env
+est ignoree EN SILENCE, et le reglage garde sa valeur par defaut. Un exemple
+qui documente une cle inexistante — ou qui en oublie une — est donc la source
+la plus probable d'un reglage qui « ne marche pas ». Ces tests tournent sans
+base ni reseau.
+
+Usage:
+    pytest tests/test_core/test_env_example.py -v
+"""
+
+import re
+from pathlib import Path
+
+from app.core.config import Settings
+
+EXEMPLE = Path(__file__).resolve().parents[2] / ".env.example"
+
+# Lues ailleurs que par Settings : legitimes dans l'exemple.
+EXTERNES = {
+    "PGSSLMODE": "lue par libpq et asyncpg, pas par l'application",
+    "ADMIN_EMAIL": "lue par scripts/create_admin.py",
+    "ADMIN_PASSWORD": "lue par scripts/create_admin.py",
+}
+
+_LIGNE = re.compile(r"^(#\s*)?([A-Z][A-Z0-9_]+)=(.*)$")
+
+
+def _cles():
+    """(numero de ligne, commentee ?, cle, valeur) de chaque affectation."""
+    for numero, ligne in enumerate(EXEMPLE.read_text(encoding="utf-8").splitlines(), start=1):
+        correspondance = _LIGNE.match(ligne.strip())
+        if correspondance:
+            commentee, cle, valeur = correspondance.groups()
+            yield numero, bool(commentee), cle, valeur
+
+
+def test_chaque_cle_est_un_reglage():
+    inconnues = [
+        (numero, cle) for numero, _, cle, _ in _cles()
+        if cle not in Settings.model_fields and cle not in EXTERNES
+    ]
+
+    assert inconnues == []
+
+
+def test_aucun_commentaire_en_fin_de_ligne():
+    """docker --env-file garde « groq   # groq | local » tout entier comme valeur."""
+    fautives = [(numero, cle) for numero, _, cle, valeur in _cles() if re.search(r"\s#", valeur)]
+
+    assert fautives == []
+
+
+def test_les_valeurs_actives_se_chargent():
+    """Chaque valeur active de l'exemple est acceptee par Settings."""
+    valeurs = {
+        cle: valeur for _, commentee, cle, valeur in _cles()
+        if not commentee and cle in Settings.model_fields
+    }
+
+    reglages = Settings(**valeurs)
+
+    assert reglages.INTENT_CLASSIFIER == "groq"
+    assert reglages.LLM_PROVIDER == "mistral"
+
+
+def test_les_reglages_des_fournisseurs_sont_documentes():
+    """Chaque reglage Mistral et Groq apparait dans l'exemple, actif ou commente."""
+    documentees = {cle for _, _, cle, _ in _cles()}
+    reglages = [
+        cle for cle in Settings.model_fields
+        if cle.startswith(("MISTRAL_", "GROQ_")) or cle in ("INTENT_CLASSIFIER", "LLM_PROVIDER")
+    ]
+
+    assert [cle for cle in reglages if cle not in documentees] == []