Merge branch 'beta'

2026-06-14 16:32:51 +02:00
46 changed files with 488 additions and 911 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -109,10 +109,3 @@ docker-compose.override.yml
 relay/
 scripts/bump-version.mjs
 brain/data/notebooks/5.json
 # ============================================================================
 # Documentation reservee aux patrons (repo Gitea PRIVE separe, clone
 # localement). NE DOIT JAMAIS partir dans le repo LoreMind public.
 # Contient le site premium (sources) + son Worker de gate dans gate/.
 # ============================================================================
 docusaurus/loremind-patreon/
--- a/README.fr.md
+++ b/README.fr.md
@@ -1,68 +0,0 @@
 # LoreMind
 [English](README.md) · **Français**
 > Application web auto-hébergeable pour MJ qui veulent centraliser leur univers, leurs campagnes et leurs personnages — avec un assistant IA contextuel.
 [![Licence: AGPL v3](https://img.shields.io/badge/Licence-AGPL%20v3-blue.svg)](LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-loremind--docs-green)](https://loremind-docs.igmlcreation.fr/)
 [![Démo](https://img.shields.io/badge/d%C3%A9mo-en%20ligne-orange)](https://loremind-demo.igmlcreation.fr/)
 [![Patreon](https://img.shields.io/badge/Patreon-soutenir-red)](https://www.patreon.com/c/IGMLCreation)
 [![Discord](https://img.shields.io/badge/Discord-rejoindre-5865F2)](https://discord.gg/cPpFzCjEzQ)
 ## Découvrir LoreMind en vidéo
 [![Présentation LoreMind](https://img.youtube.com/vi/llJkmlotbB8/maxresdefault.jpg)](https://www.youtube.com/watch?v=llJkmlotbB8)
 ![Tableau de bord](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
 ## Ce que ça fait
 LoreMind regroupe ce qu'un MJ utilise habituellement éparpillé entre plusieurs outils. L'application s'articule autour de trois modules principaux, augmentés par un assistant IA qui exploite tout votre contenu.
 ### Lore
 Construire votre univers avec une arborescence de pages templatées : lieux, factions, PNJ, événements, organisations... Chaque type de page suit un template configurable, ce qui garantit la cohérence et facilite la navigation dans des univers riches.
 ### Game System
 Stocker les règles de votre système de jeu (D&D, Nimble, créations maison...) et définir les modèles de fiches de personnages associés. Les règles indexées peuvent être injectées dans le contexte de l'IA pour des réponses fidèles à votre système.
 ### Campaign
 Structurer vos campagnes en Arcs → Chapitres → Scènes avec séparation claire du contenu MJ et du contenu joueurs. Gérer les PJ et PNJ via des fiches dynamiques basées sur les templates du game system retenu.
 ### Assistant IA
 Un assistant contextuel qui pioche dans votre Lore, vos règles et vos campagnes pour répondre à vos questions, suggérer du contenu cohérent, ou rebondir sur une situation improvisée en table.
 L'IA s'exécute **en local via [Ollama](https://ollama.com/)** ou via **[1min.ai](https://1min.ai/)**. D'autres moteurs seront supportés à l'avenir.
 ## Documentation
 Toute la documentation (installation, configuration, prise en main) est sur **[loremind-docs.igmlcreation.fr](https://loremind-docs.igmlcreation.fr/)**.
 ## Démo en ligne
 Une instance de démonstration est disponible sur **[loremind-demo.igmlcreation.fr](https://loremind-demo.igmlcreation.fr/)**.
 Quelques limites à connaître :
 - 10 utilisateurs maximum simultanés (instances isolées)
 - Session limitée à 20 minutes avant réinitialisation
 - Partie IA non incluse dans la démo (nécessite Ollama ou 1min.ai côté serveur)
 ## Soutenir le projet
 LoreMind est **et restera gratuit en auto-hébergement**. Le développement avance plus vite avec votre soutien :
 - **[Patreon](https://www.patreon.com/c/IGMLCreation)** — accès anticipé aux features, vote sur la roadmap, devlogs exclusifs
 - **[Discord](https://discord.gg/cPpFzCjEzQ)** — annonces, support, retours utilisateurs
 ## Licence
 LoreMind est distribué sous licence **[GNU AGPL v3](LICENSE)**.
 En pratique :
 - Vous pouvez l'utiliser gratuitement, l'héberger, la modifier, la redistribuer.
 - Si vous modifiez le code et que vous exposez l'application modifiée sur un réseau (même en SaaS privé), vous devez rendre vos modifications publiques sous la même licence.
 - Les univers (Lore) et campagnes que vous créez avec LoreMind **vous appartiennent entièrement** — la licence ne couvre que le code de l'application.
--- a/README.md
+++ b/README.md
@@ -1,68 +1,66 @@
 # LoreMind
-**English** · [Français](README.fr.md)
+> Application web auto-hébergeable pour MJ qui veulent centraliser leur univers, leurs campagnes et leurs personnages — avec un assistant IA contextuel.
-> A self-hostable web app for game masters who want to centralize their world, campaigns and characters — with a context-aware AI assistant.
+[![Licence: AGPL v3](https://img.shields.io/badge/Licence-AGPL%20v3-blue.svg)](LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-loremind--docs-green)](https://loremind-docs.igmlcreation.fr/)
 [![Démo](https://img.shields.io/badge/d%C3%A9mo-en%20ligne-orange)](https://loremind-demo.igmlcreation.fr/)
 [![Patreon](https://img.shields.io/badge/Patreon-soutenir-red)](https://www.patreon.com/c/IGMLCreation)
 [![Discord](https://img.shields.io/badge/Discord-rejoindre-5865F2)](https://discord.gg/cPpFzCjEzQ)
-[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](LICENSE)
+## Découvrir LoreMind en vidéo
 [![Documentation](https://img.shields.io/badge/docs-loremind--docs-green)](https://loremind-docs.igmlcreation.fr/en/)
 [![Demo](https://img.shields.io/badge/demo-online-orange)](https://loremind-demo.igmlcreation.fr/)
 [![Patreon](https://img.shields.io/badge/Patreon-support-red)](https://www.patreon.com/c/IGMLCreation)
 [![Discord](https://img.shields.io/badge/Discord-join-5865F2)](https://discord.gg/cPpFzCjEzQ)
-## See LoreMind in action
+[![Présentation LoreMind](https://img.youtube.com/vi/llJkmlotbB8/maxresdefault.jpg)](https://www.youtube.com/watch?v=llJkmlotbB8)
-[![LoreMind overview](https://img.youtube.com/vi/llJkmlotbB8/maxresdefault.jpg)](https://www.youtube.com/watch?v=llJkmlotbB8)
+![Tableau de bord](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
-![Dashboard](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
+## Ce que ça fait
-## What it does
+LoreMind regroupe ce qu'un MJ utilise habituellement éparpillé entre plusieurs outils. L'application s'articule autour de trois modules principaux, augmentés par un assistant IA qui exploite tout votre contenu.
 LoreMind brings together what a game master usually scatters across several tools. The app is built around three core modules, augmented by an AI assistant that draws on all of your content.
 ### Lore
-Build your world with a tree of templated pages: locations, factions, NPCs, events, organizations... Each page type follows a configurable template, which keeps things consistent and makes navigating rich worlds easy.
+Construire votre univers avec une arborescence de pages templatées : lieux, factions, PNJ, événements, organisations... Chaque type de page suit un template configurable, ce qui garantit la cohérence et facilite la navigation dans des univers riches.
 ### Game System
-Store the rules of your game system (D&D, Nimble, homebrew...) and define the matching character sheet templates. Indexed rules can be injected into the AI's context for answers that stay true to your system.
+Stocker les règles de votre système de jeu (D&D, Nimble, créations maison...) et définir les modèles de fiches de personnages associés. Les règles indexées peuvent être injectées dans le contexte de l'IA pour des réponses fidèles à votre système.
 ### Campaign
-Structure your campaigns as Arcs → Chapters → Scenes, with a clear split between GM-only and player-facing content. Manage PCs and NPCs through dynamic sheets based on your chosen game system's templates.
+Structurer vos campagnes en Arcs → Chapitres → Scènes avec séparation claire du contenu MJ et du contenu joueurs. Gérer les PJ et PNJ via des fiches dynamiques basées sur les templates du game system retenu.
-### AI Assistant
+### Assistant IA
-A context-aware assistant that pulls from your Lore, rules and campaigns to answer your questions, suggest consistent content, or improvise around an unexpected situation at the table.
+Un assistant contextuel qui pioche dans votre Lore, vos règles et vos campagnes pour répondre à vos questions, suggérer du contenu cohérent, ou rebondir sur une situation improvisée en table.
-The AI runs **locally via [Ollama](https://ollama.com/)** or via **[1min.ai](https://1min.ai/)**. More engines will be supported in the future.
+L'IA s'exécute **en local via [Ollama](https://ollama.com/)** ou via **[1min.ai](https://1min.ai/)**. D'autres moteurs seront supportés à l'avenir.
 ## Documentation
-The full documentation (installation, configuration, getting started) lives at **[loremind-docs.igmlcreation.fr/en](https://loremind-docs.igmlcreation.fr/en/)**.
+Toute la documentation (installation, configuration, prise en main) est sur **[loremind-docs.igmlcreation.fr](https://loremind-docs.igmlcreation.fr/)**.
-## Live demo
+## Démo en ligne
-A demo instance is available at **[loremind-demo.igmlcreation.fr](https://loremind-demo.igmlcreation.fr/)**.
+Une instance de démonstration est disponible sur **[loremind-demo.igmlcreation.fr](https://loremind-demo.igmlcreation.fr/)**.
-A few limitations to be aware of:
+Quelques limites à connaître :
- 10 concurrent users maximum (isolated instances)
+- 10 utilisateurs maximum simultanés (instances isolées)
- Sessions limited to 20 minutes before reset
+- Session limitée à 20 minutes avant réinitialisation
- The AI part is not included in the demo (requires Ollama or 1min.ai server-side)
+- Partie IA non incluse dans la démo (nécessite Ollama ou 1min.ai côté serveur)
-## Support the project
+## Soutenir le projet
-LoreMind is **and will remain free when self-hosted**. Development moves faster with your support:
+LoreMind est **et restera gratuit en auto-hébergement**. Le développement avance plus vite avec votre soutien :
- **[Patreon](https://www.patreon.com/c/IGMLCreation)** — early access to features, roadmap voting, exclusive devlogs
+- **[Patreon](https://www.patreon.com/c/IGMLCreation)** — accès anticipé aux features, vote sur la roadmap, devlogs exclusifs
- **[Discord](https://discord.gg/cPpFzCjEzQ)** — announcements, support, user feedback
+- **[Discord](https://discord.gg/cPpFzCjEzQ)** — annonces, support, retours utilisateurs
-## License
+## Licence
-LoreMind is distributed under the **[GNU AGPL v3](LICENSE)** license.
+LoreMind est distribué sous licence **[GNU AGPL v3](LICENSE)**.
-In practice:
+En pratique :
- You can use it for free, host it, modify it, and redistribute it.
+- Vous pouvez l'utiliser gratuitement, l'héberger, la modifier, la redistribuer.
- If you modify the code and expose the modified app over a network (even as a private SaaS), you must make your changes public under the same license.
+- Si vous modifiez le code et que vous exposez l'application modifiée sur un réseau (même en SaaS privé), vous devez rendre vos modifications publiques sous la même licence.
- The worlds (Lore) and campaigns you create with LoreMind **belong entirely to you** — the license only covers the application's code.
+- Les univers (Lore) et campagnes que vous créez avec LoreMind **vous appartiennent entièrement** — la licence ne couvre que le code de l'application.
--- a/brain/app/api/routers/chat.py
+++ b/brain/app/api/routers/chat.py
@@ -18,7 +18,6 @@ from app.api.chat_mapping import (
 from app.api.deps import get_chat_use_case
 from app.application.chat import ChatUseCase
 from app.core.config import get_settings
 from app.core.language import get_user_language
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError
@@ -45,7 +44,6 @@ def _count_tokens(text: str | None) -> int:
 async def chat_stream(
    body: ChatStreamRequestDTO,
    use_case: Annotated[ChatUseCase, Depends(get_chat_use_case)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> StreamingResponse:
    """Chat streamé (Server-Sent Events) avec Structural Context.
@@ -84,7 +82,6 @@ async def chat_stream(
        narrative_entity=narrative_entity,
        game_system_context=game_system_context,
        session_context=session_context,
        language=language,
    )
    # Dernier message = "current" (souvent user), le reste = historique accumulé.
    current_msg = messages[-1] if messages else None
@@ -112,7 +109,6 @@ async def chat_stream(
                narrative_entity=narrative_entity,
                game_system_context=game_system_context,
                session_context=session_context,
                language=language,
            ):
                # json.dumps avec ensure_ascii=False pour préserver les accents
                yield f"data: {json.dumps({'token': token}, ensure_ascii=False)}\n\n"
--- a/brain/app/api/routers/generation.py
+++ b/brain/app/api/routers/generation.py
@@ -6,9 +6,7 @@ from pydantic import BaseModel, Field
 from app.api.deps import get_generate_page_use_case, get_llm_provider
 from app.application.generate_page import GeneratePageUseCase
 from app.application.prompts import conversation_title as title_prompts
 from app.core.config import Settings, get_settings
 from app.core.language import get_user_language
 from app.domain.models import PageGenerationContext
 from app.domain.ports import LLMProvider, LLMProviderError
@@ -62,7 +60,6 @@ async def generate_page(
    use_case: Annotated[
        GeneratePageUseCase, Depends(get_generate_page_use_case)
    ],
    language: Annotated[str, Depends(get_user_language)],
 ) -> GeneratePageResponseDTO:
    """Endpoint métier : contexte LoreMind → valeurs structurées par champ.
@@ -79,7 +76,7 @@ async def generate_page(
    )
    try:
-        result = await use_case.execute(context, language=language)
+        result = await use_case.execute(context)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
@@ -104,11 +101,18 @@ class SummarizeTitleResponseDTO(BaseModel):
    title: str
 _TITLE_SYSTEM_PROMPT = (
    "Tu generes un titre court (4 a 7 mots max) qui resume le sujet de la "
    "conversation ci-dessous. Reponds UNIQUEMENT par le titre, sans guillemets, "
    "sans ponctuation finale, sans prefixe type 'Titre :'. Le titre doit etre "
    "en francais et capturer le sujet metier (pas 'Conversation IA')."
 )
@router.post("/summarize/conversation-title", response_model=SummarizeTitleResponseDTO)
 async def summarize_conversation_title(
    body: SummarizeTitleRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> SummarizeTitleResponseDTO:
    """Genere un titre court a partir des premiers echanges de la conversation.
@@ -119,7 +123,7 @@ async def summarize_conversation_title(
        raise HTTPException(status_code=422, detail="Au moins un message requis")
    transcript = "\n".join(f"{m.role.upper()}: {m.content}" for m in body.messages[:6])
-    prompt = f"{title_prompts.title_system_prompt(language)}\n\nConversation :\n{transcript}\n\nTitre :"
+    prompt = f"{_TITLE_SYSTEM_PROMPT}\n\nConversation :\n{transcript}\n\nTitre :"
    try:
        raw = await llm.generate(prompt)
    except LLMProviderError as exc:
@@ -129,5 +133,5 @@ async def summarize_conversation_title(
    if len(title) > 80:
        title = title[:80].rstrip()
    if not title:
-        title = title_prompts.TITLE_FALLBACK.get(language, title_prompts.TITLE_FALLBACK["fr"])
+        title = "Nouvelle conversation"
    return SummarizeTitleResponseDTO(title=title)
--- a/brain/app/api/routers/imports.py
+++ b/brain/app/api/routers/imports.py
@@ -16,7 +16,6 @@ from app.api.deps import (
 from app.application.adapt_campaign import AdaptCampaignUseCase
 from app.application.import_campaign import ImportCampaignUseCase
 from app.application.import_rules import ImportRulesUseCase
 from app.core.language import get_user_language
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError, PdfExtractionError
@@ -41,7 +40,6 @@ class RulesImportResponseDTO(BaseModel):
@router.post("/import/rules", response_model=RulesImportResponseDTO)
 async def import_rules(
    use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
    language: Annotated[str, Depends(get_user_language)],
    file: UploadFile = File(...),
 ) -> RulesImportResponseDTO:
    """Import d'un PDF de règles → sections markdown structurées (proposition).
@@ -60,7 +58,7 @@ async def import_rules(
        )
    try:
-        result = await use_case.execute(content, language=language)
+        result = await use_case.execute(content)
    except PdfExtractionError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    except LLMProviderError as exc:
@@ -76,7 +74,6 @@ async def import_rules(
@router.post("/import/rules/stream")
 async def import_rules_stream(
    use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
    language: Annotated[str, Depends(get_user_language)],
    file: UploadFile = File(...),
 ) -> StreamingResponse:
    """Import streamé : émet l'avancement (SSE) puis le résultat final.
@@ -96,7 +93,7 @@ async def import_rules_stream(
            yield sse_event("error", {"message": upload_error})
            return
        try:
-            async for ev in use_case.stream(content, language=language):
+            async for ev in use_case.stream(content):
                event_type = ev.pop("type")
                yield sse_event(event_type, ev)
        except PdfExtractionError as exc:
@@ -149,7 +146,6 @@ async def import_campaign_stream(
@router.post("/adapt/campaign/stream")
 async def adapt_campaign_stream(
    use_case: Annotated[AdaptCampaignUseCase, Depends(get_adapt_campaign_use_case)],
    language: Annotated[str, Depends(get_user_language)],
    file: UploadFile = File(...),
    brief: str = Form(""),
    messages: str = Form("[]"),
@@ -177,7 +173,7 @@ async def adapt_campaign_stream(
            yield sse_event("error", {"message": upload_error})
            return
        try:
-            async for token in use_case.stream(content, brief, convo, language=language):
+            async for token in use_case.stream(content, brief, convo):
                yield sse_event("token", {"token": token})
            yield sse_event("done", {})
        except PdfExtractionError as exc:
--- a/brain/app/api/routers/notebooks.py
+++ b/brain/app/api/routers/notebooks.py
@@ -17,7 +17,6 @@ from app.application.notebook_chat import NotebookChatUseCase
 from app.application.notebook_deep import NotebookDeepUseCase
 from app.application.notebook_rag import NotebookRagUseCase
 from app.core.config import Settings, get_settings
 from app.core.language import get_user_language
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError, PdfExtractionError
 from app.infrastructure import vector_store
@@ -78,7 +77,6 @@ async def chat_notebook_stream(
    body: NotebookChatRequestDTO,
    use_case: Annotated[NotebookChatUseCase, Depends(get_notebook_chat_use_case)],
    settings: Annotated[Settings, Depends(get_settings)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> StreamingResponse:
    """Chat ANCRÉ sur les sources (RAG) : récupère les passages pertinents puis
    streame la réponse. Évènements SSE : `token` {token}, `done` {}, `error` {message}."""
@@ -87,7 +85,7 @@ async def chat_notebook_stream(
    async def event_stream() -> AsyncIterator[str]:
        try:
-            async for ev in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k, language=language):
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k):
                if ev["type"] == "token":
                    if ev.get("token"):
                        yield sse_event("token", {"token": ev["token"]})
@@ -109,7 +107,6 @@ async def chat_notebook_stream(
 async def chat_notebook_deep_stream(
    body: NotebookChatRequestDTO,
    use_case: Annotated[NotebookDeepUseCase, Depends(get_notebook_deep_use_case)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> StreamingResponse:
    """Analyse APPROFONDIE (map-reduce sur tout le document). Évènements SSE :
    `progress` {current,total} pendant la lecture, puis `token` {token}, puis `done`."""
@@ -121,7 +118,7 @@ async def chat_notebook_deep_stream(
            yield sse_event("error", {"message": "Question vide."})
            return
        try:
-            async for ev in use_case.stream(body.source_ids, messages, context=body.context, language=language):
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context):
                ev_type = ev.pop("type")
                yield sse_event(ev_type, ev)
        except (LLMProviderError, EmbeddingError) as exc:
--- a/brain/app/api/routers/tables.py
+++ b/brain/app/api/routers/tables.py
@@ -8,8 +8,6 @@ from pydantic import BaseModel, Field
 from app.api.deps import get_llm_provider
 from app.application.llm_json import load_json_object
 from app.application.llm_retry import generate_with_retry
 from app.application.prompts import tables as prompts
 from app.core.language import get_user_language
 from app.domain.ports import LLMProvider, LLMProviderError
 router = APIRouter()
@@ -53,15 +51,28 @@ class GenerateTableResponseDTO(BaseModel):
 async def generate_random_table(
    body: GenerateTableRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> GenerateTableResponseDTO:
    """Génère une table aléatoire (entrées par plage) couvrant la formule de dé."""
    rng = _dice_total_range(body.dice_formula)
    if rng is None:
        raise HTTPException(status_code=422, detail="Formule de dé invalide (ex. 1d20, 2d6, d100).")
    lo, hi = rng
-    prompt = prompts.random_table_prompt(
+    context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
-        body.description, body.dice_formula, lo, hi, body.context, language)
+    prompt = (
        "Tu es un assistant de jeu de rôle. Génère une TABLE ALÉATOIRE évocatrice.\n"
        f"Dé : {body.dice_formula} (résultats possibles de {lo} à {hi}).\n"
        f"Sujet : {body.description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "entries": '
        '[{"min_roll": N, "max_roll": M, "label": "résultat court", "detail": "1-2 phrases"}]}\n'
        f"- Les plages (min_roll..max_roll) doivent COUVRIR EXACTEMENT {lo}..{hi}, "
        "sans trou ni chevauchement, dans l'ordre croissant.\n"
        "- Des résultats variés, cohérents avec le sujet (et le contexte s'il est fourni).\n"
        "- En français. 'label' = résultat bref ; 'detail' = description/effet concret.\n"
        "Renvoie maintenant le JSON."
    )
    try:
        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
    except LLMProviderError as exc:
@@ -113,11 +124,17 @@ class ImproviseRollResponseDTO(BaseModel):
 async def improvise_table_roll(
    body: ImproviseRollRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> ImproviseRollResponseDTO:
    """Brode un court récit (2-3 phrases) sur un résultat tiré, pour lancer la scène."""
-    prompt = prompts.improvise_roll_prompt(
+    detail = f" ({body.result_detail.strip()})" if body.result_detail.strip() else ""
-        body.table_name, body.result_label, body.result_detail, body.context, language)
+    context_block = f"\nContexte : {body.context.strip()}" if body.context.strip() else ""
    prompt = (
        "Tu es le Maître du Jeu. Les joueurs viennent de tirer sur la table "
        f"« {body.table_name.strip()} » et ont obtenu : « {body.result_label.strip()} »{detail}."
        f"{context_block}\n\n"
        "Décris en 2-3 phrases vivantes et immédiates ce qui se passe, pour lancer la scène. "
        "Pas de méta, pas d'options : juste la narration, en français."
    )
    try:
        raw = await llm.generate(prompt, temperature=0.8)
    except LLMProviderError as exc:
@@ -150,10 +167,22 @@ class GenerateCatalogResponseDTO(BaseModel):
 async def generate_item_catalog(
    body: GenerateCatalogRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    language: Annotated[str, Depends(get_user_language)],
 ) -> GenerateCatalogResponseDTO:
    """Génère un catalogue d'objets (boutique, butin…) — nom, prix, catégorie, description."""
-    prompt = prompts.item_catalog_prompt(body.description, body.context, language)
+    context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
    prompt = (
        "Tu es un assistant de jeu de rôle. Génère un CATALOGUE D'OBJETS (boutique, butin, trésor…).\n"
        f"Sujet : {body.description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "items": '
        '[{"name": "Objet", "price": "ex. 50 po", "category": "ex. Armes", "description": "effet/détails"}]}\n'
        "- Des objets variés et cohérents avec le sujet (et le contexte s'il est fourni).\n"
        "- 'price' = prix court dans la monnaie du jeu ; 'category' = regroupement (Armes, Potions…) ; "
        "'description' = effet/détails en une phrase. En français.\n"
        "Renvoie maintenant le JSON."
    )
    try:
        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
    except LLMProviderError as exc:
--- a/brain/app/application/adapt_campaign.py
+++ b/brain/app/application/adapt_campaign.py
@@ -13,8 +13,6 @@ from __future__ import annotations
 import logging
 from typing import AsyncIterator
 from app.application.prompts import adapt_campaign as prompts
 from app.core.language import DEFAULT as _DEFAULT_LANG
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMChatProvider, PdfExtractionError, PdfTextExtractor
@@ -23,6 +21,27 @@ logger = logging.getLogger(__name__)
 # Plus créatif que l'import (tâche de structuration) : ici on conseille/adapte.
 _TEMPERATURE = 0.7
 _SYSTEM_PREFIX = (
    "Tu es un assistant pour Maître de Jeu de jeu de rôle. L'utilisateur a une "
    "campagne EXISTANTE (décrite plus bas) et souhaite ADAPTER et INTÉGRER le "
    "contenu d'un PDF (aventure, donjon, supplément) à CETTE campagne précise."
 )
 _SYSTEM_SUFFIX = (
    "Produis des CONSEILS D'ADAPTATION concrets, actionnables et en FRANÇAIS, "
    "en markdown structuré (titres ##, listes). Couvre notamment :\n"
    "- **Où l'insérer** : à quel(s) arc(s)/chapitre(s) EXISTANT(s) rattacher ce "
    "contenu, dans quel ordre, et — si l'arc est un hub — sous quelles conditions de déblocage.\n"
    "- **Reskins / liens PNJ** : quels PNJ EXISTANTS de la campagne peuvent incarner "
    "ou remplacer les personnages clés du PDF.\n"
    "- **Adaptation à l'univers** : comment transposer lieux, factions, noms propres et "
    "ton vers l'univers de l'utilisateur plutôt que le cadre d'origine du PDF.\n"
    "- **Doublons / conflits** : ce qui recoupe l'existant et comment le réconcilier.\n"
    "- **Ajustements de ton et de difficulté**.\n\n"
    "Réfère-toi TOUJOURS aux éléments existants par leur NOM. Ne réécris PAS le PDF en "
    "entier : donne des recommandations. Si une information manque, propose des options."
 )
 class AdaptCampaignUseCase:
    """Génère (en streaming) des conseils d'adaptation d'un PDF à une campagne."""
@@ -45,7 +64,6 @@ class AdaptCampaignUseCase:
        pdf_bytes: bytes,
        brief: str,
        messages: list[ChatMessage],
        language: str = _DEFAULT_LANG,
    ) -> AsyncIterator[str]:
        """Conversationnel : le PDF + la campagne sont le CONTEXTE (system prompt),
        `messages` est l'échange (demande initiale, puis feedbacks de l'utilisateur)."""
@@ -69,12 +87,12 @@ class AdaptCampaignUseCase:
        )
        # Concaténation (pas .format) : brief/PDF peuvent contenir des { } littéraux.
        system_prompt = (
-            f"{prompts.SYSTEM_PREFIX}\n\n"
+            f"{_SYSTEM_PREFIX}\n\n"
            "--- CAMPAGNE EXISTANTE DE L'UTILISATEUR ---\n"
            f"{brief.strip() or '(campagne encore vide)'}\n\n"
            "--- CONTENU DU PDF À ADAPTER ---\n"
            f"{pdf_text}{trunc_note}\n\n"
-            f"{prompts.system_suffix(language)}\n\n"
+            f"{_SYSTEM_SUFFIX}\n\n"
            "Tu es en CONVERSATION : à chaque message de l'utilisateur, ajuste, corrige "
            "ou propose des alternatives en gardant tout ce contexte à l'esprit."
        )
--- a/brain/app/application/chat.py
+++ b/brain/app/application/chat.py
@@ -31,8 +31,6 @@ from app.domain.models import (
    QuestSummary,
    SessionContext,
 )
 from app.application.prompts import chat as prompts
 from app.core.language import DEFAULT as _DEFAULT_LANG
 from app.domain.ports import LLMChatProvider
@@ -42,6 +40,21 @@ from app.domain.ports import LLMChatProvider
 _DEFAULT_TEMPERATURE = 0.7
 _BASE_SYSTEM = """Tu es un assistant d'écriture pour un Maître de Jeu de JDR.
 Tu dialogues avec le MJ pour l'aider à enrichir son univers et ses campagnes.
 Règles de ton :
 - Réponds en français, ton chaleureux et créatif.
 - Sois concis : listes à puces courtes plutôt que longs paragraphes.
 - Propose des idées qui s'intègrent dans le contexte existant ci-dessous.
 Règles de cohérence (IMPORTANT) :
 - Tu PEUX et DOIS inventer des éléments originaux (personnages, lieux, objets, intrigues, créatures, scènes) — c'est ton rôle d'assistant créatif.
 - Tu ne peux PAS faire référence à un élément du MJ (du Lore, des arcs, chapitres ou scènes) comme s'il existait déjà, SAUF s'il apparaît EXACTEMENT (même orthographe) dans l'une des sections de contexte ci-dessous.
 - Si l'utilisateur mentionne un nom que tu ne vois pas dans le contexte, ne fais surtout pas semblant de le connaître : dis clairement "Je ne vois pas [nom] dans le contexte actuel, veux-tu qu'on le crée ?" plutôt que d'inventer des détails à son sujet.
 - Évite les précisions inventées qu'on ne peut pas vérifier : dates exactes, chiffres de population, hiérarchies politiques complexes, généalogies détaillées. Préfère des formulations ouvertes que le MJ validera ("il y a longtemps", "de nombreux", "la haute noblesse")."""
 class ChatUseCase:
    """Orchestre un tour de conversation avec le LLM + contextes structurels."""
@@ -58,18 +71,16 @@ class ChatUseCase:
        narrative_entity: NarrativeEntityContext | None = None,
        game_system_context: GameSystemContext | None = None,
        session_context: SessionContext | None = None,
        language: str = _DEFAULT_LANG,
    ) -> AsyncIterator[str]:
        """Streame les tokens de la réponse assistant pour le dernier message user.
        Les contextes sont tous optionnels, mais au moins l'un des deux
        "niveaux haut" (lore_context ou campaign_context) doit être fourni
        pour que le prompt ait du sens. Le controller (main.py) applique
-        cette règle à la frontière HTTP. `language` pilote la langue de réponse.
+        cette règle à la frontière HTTP.
        """
        system_prompt = self._build_system_prompt(
-            lore_context, page_context, campaign_context, narrative_entity,
+            lore_context, page_context, campaign_context, narrative_entity, game_system_context, session_context
            game_system_context, session_context, language,
        )
        async for token in self._llm.stream_chat(
            messages,
@@ -86,14 +97,12 @@ class ChatUseCase:
        narrative_entity: NarrativeEntityContext | None = None,
        game_system_context: GameSystemContext | None = None,
        session_context: SessionContext | None = None,
        language: str = _DEFAULT_LANG,
    ) -> str:
        """Version publique — utilisée par le controller HTTP pour compter
        les tokens du system prompt avant de streamer (jauge de contexte).
        """
        return self._build_system_prompt(
-            lore_context, page_context, campaign_context, narrative_entity,
+            lore_context, page_context, campaign_context, narrative_entity, game_system_context, session_context
            game_system_context, session_context, language,
        )
    # --- Construction du system prompt --------------------------------------
@@ -106,9 +115,8 @@ class ChatUseCase:
        narrative: NarrativeEntityContext | None,
        game_system: GameSystemContext | None = None,
        session: SessionContext | None = None,
        language: str = _DEFAULT_LANG,
    ) -> str:
-        sections = [prompts.base_system(language)]
+        sections = [_BASE_SYSTEM]
        if lore is not None:
            sections.append(self._format_lore(lore))
        if campaign is not None:
--- a/brain/app/application/generate_page.py
+++ b/brain/app/application/generate_page.py
@@ -8,13 +8,9 @@ permet de tester ce use case avec un FakeLLMProvider, sans Ollama qui tourne.
 """
 import json
 from app.application.prompts import generate_page as prompts
 from app.domain.models import PageGenerationContext, PageGenerationResult
 from app.domain.ports import LLMProvider, LLMProviderError
 # Langue de repli quand le router n'en fournit pas (appel direct / vieux client).
 from app.core.language import DEFAULT as _DEFAULT_LANG
 # Température basse : remplissage de champs = tâche factuelle, peu créative.
 # Une valeur trop haute (par défaut Ollama = 0.8) encourage l'IA à broder
@@ -22,6 +18,21 @@ from app.core.language import DEFAULT as _DEFAULT_LANG
 _DEFAULT_TEMPERATURE = 0.4
 _SYSTEM_INSTRUCTIONS = """Tu es un assistant d'écriture pour un Maître de Jeu de JDR.
 Tu vas générer le contenu d'une page appartenant à un univers fictionnel.
 Règles impératives de ta réponse :
 - Tu réponds UNIQUEMENT par un objet JSON valide.
 - Les clés du JSON correspondent EXACTEMENT aux noms de champs demandés.
 - Les valeurs sont des chaînes de texte en français, riches et évocatrices.
 - Aucun markdown, aucune explication, aucun commentaire autour du JSON.
 Règles de cohérence (IMPORTANT) :
 - Tu PEUX inventer des détails originaux pour CETTE page : apparence, traits de caractère, anecdotes, histoire personnelle.
 - Tu ne dois PAS faire référence à d'autres personnages, lieux, organisations ou événements comme s'ils existaient déjà dans l'univers, sauf si le contexte ci-dessous les mentionne explicitement.
 - Si un champ appelle une précision externe (date, nom d'un roi, ville voisine, guerre passée), reste volontairement vague : "il y a de nombreuses années", "un bourg voisin", "une époque troublée". Le MJ préfère combler lui-même les blancs plutôt que trouver des faits inventés contradictoires avec son univers."""
 class GeneratePageUseCase:
    """Orchestre la génération d'une page LoreMind via un LLM."""
@@ -31,9 +42,8 @@ class GeneratePageUseCase:
    async def execute(
        self,
        context: PageGenerationContext,
        language: str = _DEFAULT_LANG,
    ) -> PageGenerationResult:
-        prompt = self._build_prompt(context, language)
+        prompt = self._build_prompt(context)
        raw = await self._llm.generate(
            prompt,
            output_format="json",
@@ -43,7 +53,7 @@ class GeneratePageUseCase:
        return PageGenerationResult(values=values)
    @staticmethod
-    def _build_prompt(context: PageGenerationContext, language: str = _DEFAULT_LANG) -> str:
+    def _build_prompt(context: PageGenerationContext) -> str:
        fields_block = "\n".join(f'- "{field}"' for field in context.template_fields)
        lore_desc_line = (
            f"\nDescription de l'univers : {context.lore_description}"
@@ -52,7 +62,7 @@ class GeneratePageUseCase:
        )
        return (
-            f"{prompts.system_instructions(language)}\n\n"
+            f"{_SYSTEM_INSTRUCTIONS}\n\n"
            f"Univers : {context.lore_name}"
            f"{lore_desc_line}\n"
            f"Catégorie (dossier) : {context.folder_name}\n"
--- a/brain/app/application/import_campaign.py
+++ b/brain/app/application/import_campaign.py
@@ -21,7 +21,6 @@ from app.application.import_status import (
 )
 from app.application.llm_json import load_json_object, looks_like_truncated_json
 from app.application.llm_retry import generate_with_retry
 from app.application.prompts import import_campaign as prompts
 from app.application.streaming import with_heartbeat
 # Repli anti-troncature : si la sortie d'un morceau est coupée, on le retraite en
@@ -48,11 +47,76 @@ logger = logging.getLogger(__name__)
 # Plus la valeur est haute, plus le modèle "brode" (invente du contenu absent).
 _TEMPERATURE = 0.1
 # Nom de l'arc unique quand le livre n'est pas découpé en actes/parties.
 _DEFAULT_ARC_NAME = "Aventure principale"
 # Morceaux PLUS GROS que pour les règles : l'IA voit une quête/un chapitre entier
 # d'un coup et le structure de façon cohérente (1 scène par lieu) au lieu de le
 # fragmenter en dizaines de scènes. Adapté aux providers à grand contexte (1min.ai).
 _CHUNK_TARGET_TOKENS = 10000
 _MAP_SYSTEM = """Tu es un assistant qui structure un livre de campagne de jeu de rôle.
 On te donne un EXTRAIT brut d'un PDF de campagne (texte parfois mal coupé par la mise en page).
 Ta tâche : en dégager une ARBORESCENCE narrative à GROS GRAIN : arcs → chapitres → scènes,
 et — pour les lieux explorables — leurs PIÈCES (rooms).
  - Un ARC = un acte / une grande partie de la campagne (souvent un seul pour une aventure courte).
  - Un CHAPITRE = une étape majeure du récit : un chapitre du livre, OU — dans une
    campagne "hub" / bac-à-sable — UNE QUÊTE ou UN LIEU principal débloqué depuis le
    point central (ex : Dragon of Icespire Peak → chaque quête/lieu = un chapitre).
  - Une SCÈNE = un temps fort jouable du chapitre : un lieu, une rencontre clé, un moment pivot.
  - Une PIÈCE (room) = une salle d'un lieu explorable (donjon, crypte, manoir...).
 TYPE D'ARC ("type") :
 - "HUB" si la campagne est un bac-à-sable : des quêtes/lieux optionnels, parallèles,
  débloqués depuis un point central, SANS ordre fixe imposé (ex : Dragon of Icespire Peak).
 - "LINEAR" si les chapitres se jouent dans un ordre séquentiel imposé.
 - Dans le doute : "LINEAR".
 GRANULARITÉ (évite la sur-détection) :
 - Vise PEU de scènes : typiquement 1 à 6 par chapitre. PAS des dizaines.
 - Un LIEU EXPLORABLE (donjon, crypte, manoir, grotte à plusieurs salles) = UNE SEULE
  scène. Ses salles vont dans le tableau "rooms" de cette scène — JAMAIS en scènes séparées.
 - NE crée PAS une scène par rencontre isolée, par PNJ, par monstre ou par paragraphe.
 - IGNORE : blocs de stats, listes de monstres, encarts de règles, légendes de cartes,
  pieds de page, sommaires, crédits.
 CONTENU D'UNE SCÈNE (fidélité au livre — important) :
 - `description` = synopsis de la scène, 2 à 4 phrases (plus que 1 ligne, mais pas le texte intégral).
 - `player_narration` = le texte d'AMBIANCE « à lire aux joueurs » (encadrés / boxed text /
  « lecture à voix haute »), recopié FIDÈLEMENT s'il existe dans l'extrait. Vide sinon.
 - `gm_notes` = les informations pour le MJ : secrets, développement, ce qui se passe,
  conséquences, indices cachés. Vide si rien de tel.
 - Ne RÉSUME pas abusivement player_narration et gm_notes : recopie le contenu utile du livre.
 PIÈCES (rooms) — uniquement pour les scènes qui sont des lieux explorables :
 - Une entrée par salle numérotée/nommée du donjon (ex : "1. Entrée", "2. Salle des gardes").
 - `enemies` = créatures/boss de la salle (vide si aucune). `loot` = trésor/récompense (vide si aucun).
 - Pour une scène narrative classique (pas un donjon), "rooms" est un tableau vide [].
 PNJ ET CRÉATURES NOTABLES ("npcs", tableau au niveau racine) :
 - Recense les PNJ NOMMÉS (alliés, marchands, antagonistes) et les créatures UNIQUES
  (boss, monstre récurrent) présents dans l'extrait.
 - `description` = courte fiche utile au MJ : rôle dans l'histoire, apparence,
  motivations, où on le rencontre. 2 à 4 phrases, fidèles au livre.
 - N'inclus PAS les monstres génériques sans nom (« 3 gobelins », « un loup »).
 - Aucun PNJ nommé dans l'extrait → "npcs": [].
 Format de réponse :
 - Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
 - Schéma EXACT :
  {{"arcs": [{{"name": "...", "description": "...", "type": "LINEAR",
     "chapters": [{{"name": "...", "description": "...", "scenes": [
        {{"name": "...", "description": "...", "player_narration": "...", "gm_notes": "...",
          "rooms": [{{"name": "...", "description": "...", "enemies": "...", "loot": "..."}}]}}
     ]}}]}}
  ],
   "npcs": [{{"name": "...", "description": "..."}}]}}
 - Utilise les VRAIS titres du livre pour les noms (pas de paraphrase).
 - Si le livre n'est PAS découpé en actes/parties, regroupe tout sous un seul arc nommé "{default_arc}".
 - N'invente pas de contenu : tu réorganises et recopies ce qui est présent dans l'extrait.
 - Si l'extrait ne contient aucune matière narrative, renvoie {{"arcs": []}}."""
 # Schéma de l'arbre attendu, passé aux providers à sorties structurées (Ollama
 # contraint la grammaire : un modèle local ne PEUT plus produire de clés
 # inventées, d'objets bavards type "thought" ni de texte hors JSON). Les
@@ -131,12 +195,47 @@ _TREE_SCHEMA: dict = {
    "additionalProperties": False,
 }
 # Bloc TOC injecté quand le PDF a des bookmarks : les morceaux étant traités
 # séparément, c'est CE référentiel commun qui garantit que tous nomment les
 # mêmes chapitres à l'identique → la fusion par nom du _TreeMerger recolle
 # les chapitres coupés au lieu de créer des doublons.
 _TOC_BLOCK = """
 --- STRUCTURE OFFICIELLE DU LIVRE (table des matières du PDF) ---
 {toc}
 --- FIN DE LA STRUCTURE ---
 IMPORTANT : pour nommer les arcs et chapitres, reprends EXACTEMENT les titres
 de cette structure (caractère pour caractère). Rattache le contenu de l'extrait
 au bon chapitre de la structure, même si son titre n'apparaît pas dans l'extrait."""
 # Garde-fou prompt : une TOC de gros livre peut compter des centaines d'entrées
 # (sous-sous-sections). On la limite aux niveaux hauts et à un nombre raisonnable.
 _TOC_MAX_LEVEL = 2
 _TOC_MAX_ENTRIES = 80
 # Consolidation finale : le squelette (noms seuls) est minuscule, donc l'appel
 # est quasi gratuit comparé aux MAP. Température 0 et consigne CONSERVATRICE :
 # ne fusionner que les doublons évidents, jamais des entités distinctes.
 _CONSOLIDATE_PROMPT = """Voici le squelette d'une arborescence arc → chapitre → scène issue d'une
 fusion AUTOMATIQUE de morceaux d'un livre de campagne de jeu de rôle. La fusion par nom exact
 peut avoir laissé des QUASI-DOUBLONS : le même chapitre ou la même scène sous deux libellés
 légèrement différents (ex: "La Crypte" et "Crypte de Karrak", "3. Salle des gardes" et
 "Salle des gardes").
 {skeleton}
 Identifie UNIQUEMENT les fusions ÉVIDENTES (même entité du livre sous deux noms). Sois
 CONSERVATEUR : dans le doute, ne fusionne PAS. Deux lieux/évènements distincts ne doivent
 JAMAIS être fusionnés.
 Réponds UNIQUEMENT par un objet JSON valide :
 {{"chapter_merges": [{{"into": "nom du chapitre à garder", "merge": ["nom à fusionner", ...]}}],
  "scene_merges": [{{"chapter": "nom du chapitre", "into": "nom de la scène à garder",
                     "merge": ["nom à fusionner", ...]}}]}}
 S'il n'y a RIEN à fusionner (cas le plus fréquent) : {{"chapter_merges": [], "scene_merges": []}}"""
 def _format_toc(toc) -> str:
    """Formate la TOC du PDF en liste indentée, bornée (niveaux hauts d'abord)."""
    entries = [e for e in toc if e.level <= _TOC_MAX_LEVEL][:_TOC_MAX_ENTRIES]
@@ -527,7 +626,7 @@ class ImportCampaignUseCase:
        skeleton = merger.skeleton_text()
        try:
            raw = await generate_with_retry(
-                self._llm, prompts.CONSOLIDATE_PROMPT.format(skeleton=skeleton),
+                self._llm, _CONSOLIDATE_PROMPT.format(skeleton=skeleton),
                output_format="json", temperature=0.0)
        except Exception as exc:  # noqa: BLE001 — best-effort STRICT : une erreur ici
            # (LLM, réseau, bug) ne doit JAMAIS faire perdre un import terminé.
@@ -565,9 +664,9 @@ class ImportCampaignUseCase:
        """Extrait l'arborescence + les PNJ d'un texte. Si la SORTIE est tronquée,
        retraite le texte en DEUX moitiés et concatène — le `_TreeMerger` final
        dédoublonne par nom (un arc/chapitre coupé entre les moitiés est recollé)."""
-        toc_section = prompts.TOC_BLOCK.format(toc=toc_block) if toc_block else ""
+        toc_section = _TOC_BLOCK.format(toc=toc_block) if toc_block else ""
        prompt = (
-            prompts.MAP_SYSTEM.format(default_arc=prompts.DEFAULT_ARC_NAME)
+            _MAP_SYSTEM.format(default_arc=_DEFAULT_ARC_NAME)
            + toc_section
            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
            "Renvoie maintenant le JSON de l'arborescence."
--- a/brain/app/application/import_rules.py
+++ b/brain/app/application/import_rules.py
@@ -25,9 +25,7 @@ from app.application.import_status import (
 )
 from app.application.llm_json import load_json_object, looks_like_truncated_json
 from app.application.llm_retry import generate_with_retry
 from app.application.prompts import import_rules as prompts
 from app.application.streaming import with_heartbeat
 from app.core.language import DEFAULT as _DEFAULT_LANG, language_name
 # Repli anti-troncature : si la SORTIE d'un morceau est coupée (le modèle ne peut
 # pas tout réécrire en une réponse), on retraite ce morceau en 2 moitiés. Borné en
@@ -59,6 +57,43 @@ _SECTIONS_SCHEMA: dict = {
    "additionalProperties": {"type": "string"},
 }
 # Taxonomie canonique suggérée au modèle pour homogénéiser les titres entre
 # morceaux (sinon "Combat" / "Le combat" / "Règles de combat" se dispersent).
 # Le modèle reste libre d'en créer d'autres si rien ne correspond.
 _CANONICAL_SECTIONS = [
    "Règles générales",
    "Création de personnage",
    "Caractéristiques et tests",
    "Compétences",
    "Combat",
    "Magie et sorts",
    "Équipement et objets",
    "États et conditions",
    "Repos et récupération",
    "Progression et niveaux",
    "Conseils au Maître de Jeu",
 ]
 _MAP_SYSTEM = """Tu es un assistant qui réorganise un livre de règles de jeu de rôle.
 On te donne un EXTRAIT brut d'un PDF de règles (texte parfois mal coupé par la mise en page).
 Ta tâche : répartir le contenu de cet extrait dans des SECTIONS THÉMATIQUES.
 Format EXACT attendu — un objet JSON plat {{titre de section: contenu markdown}} :
 {{"Combat": "## Initiative\\n\\nChaque participant lance 1d20...", "Magie et sorts": "## Sorts\\n\\n..."}}
 Règles impératives :
 - Tu réponds UNIQUEMENT par cet objet JSON, sans texte avant ni après.
 - Les CLÉS sont des titres de section (texte court). Les VALEURS sont le contenu de la règle en markdown (chaîne de caractères, jamais un objet ou une liste).
 - INTERDIT : des clés génériques comme "title", "content", "sections", "thought" ou "notes" ; des objets imbriqués ; tout commentaire sur ta démarche ou ton raisonnement.
 - Utilise EN PRIORITÉ ces titres canoniques quand le contenu y correspond :
 {canonical}
 - Si un contenu ne rentre dans aucun, crée un titre clair et concis (en français).
 - Reproduis FIDÈLEMENT les règles : tu peux nettoyer la coupure des lignes, recoller les mots coupés
  par un tiret en fin de ligne, retirer les en-têtes/pieds de page et numéros de page parasites.
 - N'INVENTE AUCUNE règle, ne résume pas abusivement : tu réorganises, tu ne réécris pas le fond.
 - Ignore les pages de garde, sommaires, crédits, pages vides (renvoie {{}} si l'extrait n'a aucune règle)."""
 # --- Mode SEGMENTATION (modèles locaux) --------------------------------------
 # Réécrire tout le texte en JSON impose une SORTIE ≈ taille de l'ENTRÉE : à
 # ~100 tokens/s en local, un livre = des dizaines de minutes et des troncatures
@@ -67,6 +102,25 @@ _SECTIONS_SCHEMA: dict = {
 # qui découpons le texte original. ~50× plus rapide, fidélité parfaite du
 # contenu (texte source intact), plus de troncature possible.
 _SEGMENT_SYSTEM = """Tu analyses un EXTRAIT brut d'un livre de règles de jeu de rôle.
 Ta tâche : repérer où COMMENCENT les sections thématiques. Tu ne réécris RIEN.
 Format EXACT attendu :
 {{"sections": [{{"titre": "Combat", "debut": "Le combat se déroule en tours de"}}, ...]}}
 Règles impératives :
 - "debut" = les 5 à 10 PREMIERS MOTS du passage où la section commence, COPIÉS À L'IDENTIQUE
  depuis l'extrait (même orthographe, même ponctuation, même langue). JAMAIS un résumé.
 - La PREMIÈRE entrée commence aux tout premiers mots de l'extrait (même si le contenu
  poursuit une section entamée avant cet extrait).
 - Les entrées suivent l'ordre du texte. Vise des sections LARGES (un thème), pas un titre
  par paragraphe : un extrait contient typiquement 1 à 6 sections.
 - Titres : EN PRIORITÉ parmi :
 {canonical}
  sinon un titre court et clair en français.
 - Pages de garde, sommaires, crédits : n'en fais pas des sections. Si l'extrait n'est que ça,
  renvoie {{"sections": []}}."""
 # Schéma passé à Ollama (structured outputs) : un objet {"sections": [...]}.
 # Racine objet (pas tableau) car l'extraction côté Brain repère le premier {…}.
 _ANCHORS_SCHEMA: dict = {
@@ -239,7 +293,7 @@ class ImportRulesUseCase:
        self._chunk_target_tokens = chunk_target_tokens
        self._segment_only = segment_only
-    async def execute(self, pdf_bytes: bytes, language: str = _DEFAULT_LANG) -> RulesImportResult:
+    async def execute(self, pdf_bytes: bytes) -> RulesImportResult:
        """Variante non-streamée : traite tout puis renvoie le résultat complet."""
        doc = self._extractor.extract(pdf_bytes)
        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
@@ -249,14 +303,14 @@ class ImportRulesUseCase:
        )
        merger = _SectionMerger()
        for i, chunk in enumerate(chunks):
-            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks), language=language))
+            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
        return RulesImportResult(
            sections=merger.result(),
            page_count=doc.page_count,
            ocr_page_count=doc.ocr_page_count,
        )
-    async def stream(self, pdf_bytes: bytes, language: str = _DEFAULT_LANG):
+    async def stream(self, pdf_bytes: bytes):
        """Variante streamée : yield des évènements d'avancement au fil de l'eau.
        Évènements (dicts) : {"type": "extracting"}, puis
@@ -299,7 +353,7 @@ class ImportRulesUseCase:
                try:
                    sections: dict[str, str] | None = None
                    async for kind, payload in with_heartbeat(
-                        self._map_chunk(chunk, index=i, total=total, language=language),
+                        self._map_chunk(chunk, index=i, total=total),
                        status_queue=status_queue,
                    ):
                        if kind == "heartbeat":
@@ -354,24 +408,20 @@ class ImportRulesUseCase:
    # --- MAP : un morceau → sections -----------------------------------------
-    async def _map_chunk(self, chunk: str, *, index: int, total: int,
+    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> dict[str, str]:
-                         language: str = _DEFAULT_LANG) -> dict[str, str]:
+        return await self._extract_sections(chunk, index=index, total=total, depth=0)
        return await self._extract_sections(
            chunk, index=index, total=total, depth=0, language=language)
    async def _extract_sections(
-        self, text: str, *, index: int, total: int, depth: int,
+        self, text: str, *, index: int, total: int, depth: int
        language: str = _DEFAULT_LANG,
    ) -> dict[str, str]:
        """Extrait les sections d'un texte. Si la SORTIE est tronquée, retraite le
        texte en DEUX moitiés (chacune produit une réponse complète) et fusionne —
        ainsi aucune section n'est perdue, quel que soit le plafond de sortie."""
-        system = prompts.SEGMENT_SYSTEM if self._segment_only else prompts.MAP_SYSTEM
+        system = _SEGMENT_SYSTEM if self._segment_only else _MAP_SYSTEM
        schema = _ANCHORS_SCHEMA if self._segment_only else _SECTIONS_SCHEMA
        prompt = (
            system.format(
-                canonical="\n".join(f"  - {s}" for s in prompts.CANONICAL_SECTIONS),
+                canonical="\n".join(f"  - {s}" for s in _CANONICAL_SECTIONS)
                language_name=language_name(language),
            )
            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
            "Renvoie maintenant le JSON des sections."
@@ -394,8 +444,8 @@ class ImportRulesUseCase:
            notify_status(
                f"Le modèle est trop lent sur le morceau {index + 1} : "
                "re-découpage en 2 moitiés plus digestes…")
-            a = await self._extract_sections(left, index=index, total=total, depth=depth + 1, language=language)
+            a = await self._extract_sections(left, index=index, total=total, depth=depth + 1)
-            b = await self._extract_sections(right, index=index, total=total, depth=depth + 1, language=language)
+            b = await self._extract_sections(right, index=index, total=total, depth=depth + 1)
            return _combine_sections(a, b)
        if self._segment_only:
            sections, truncated = self._parse_anchors(raw, text, index=index)
@@ -411,8 +461,8 @@ class ImportRulesUseCase:
                notify_status(
                    f"Réponse du modèle coupée sur le morceau {index + 1} : "
                    "re-découpage en 2 moitiés plus digestes…")
-                a = await self._extract_sections(left, index=index, total=total, depth=depth + 1, language=language)
+                a = await self._extract_sections(left, index=index, total=total, depth=depth + 1)
-                b = await self._extract_sections(right, index=index, total=total, depth=depth + 1, language=language)
+                b = await self._extract_sections(right, index=index, total=total, depth=depth + 1)
                return _combine_sections(a, b)
        if truncated:
            logger.warning(
--- a/brain/app/application/notebook_chat.py
+++ b/brain/app/application/notebook_chat.py
@@ -9,13 +9,90 @@ from __future__ import annotations
 from typing import AsyncIterator
 from app.application.notebook_rag import NotebookRagUseCase
 from app.application.prompts import notebook as prompts
 from app.application.query_rewrite import standalone_question
 from app.application.rerank import pool_size, rerank
 from app.core.language import DEFAULT as _DEFAULT_LANG, language_name
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMChatProvider
 _SYSTEM_PROMPT = """Tu es un assistant de jeu de rôle qui aide à ADAPTER une source (PDF) à la CAMPAGNE de l'utilisateur.
 Tu disposes de DEUX connaissances, toutes deux ci-dessous :
 1) LA CAMPAGNE de l'utilisateur (sa structure arcs/chapitres/scènes, ses PNJ, son univers) ;
 2) LA SOURCE (extraits pertinents du PDF).
 Règles :
 - Pour une question sur SA CAMPAGNE (ex. « mon chapitre 3 », « mes PNJ »), appuie-toi sur la section CAMPAGNE.
 - Pour une question sur le livre, appuie-toi sur les EXTRAITS DE LA SOURCE.
 - CROISE les deux pour proposer des adaptations cohérentes avec sa campagne existante.
 - N'invente pas ce qui ne figure ni dans la campagne ni dans la source ; si tu ne sais pas, dis-le.
 - Quand un extrait porte un numéro de page (« (p. 12) »), cite-le (« d'après la p. 12 »).
 {context_block}
 --- EXTRAITS PERTINENTS DE LA SOURCE ---
 {sources_block}
 --- FIN DES EXTRAITS ---
 PROPOSITIONS D'INTÉGRATION (IMPORTANT) :
 Quand l'utilisateur veut CRÉER ou ADAPTER un élément concret pour sa campagne (un PNJ,
 une scène, un chapitre, une quête, un arc, une table aléatoire), termine ta réponse par
 un ou plusieurs BLOCS D'ACTION — un objet JSON par bloc, dans une clôture
 ```loremind-action. L'interface les transformera en boutons « Créer dans la campagne ».
 Si l'utilisateur demande PLUSIEURS éléments (« propose-moi 3 quêtes »), produis UN bloc
 par élément. N'en mets pas si l'utilisateur pose une simple question.
 VOCABULAIRE DE LA CAMPAGNE : une « quête » n'est PAS un type à part — c'est un CHAPITRE
 rangé dans un arc de type HUB (quêtes parallèles, sans ordre imposé), tandis qu'un arc
 LINEAR contient des chapitres joués en séquence. Donc :
 - demande de QUÊTE → action "chapter" (l'utilisateur la placera dans son arc HUB) ;
  s'il n'a aucun arc HUB dans sa campagne, propose AUSSI une action "arc" avec
  "arcType": "HUB" pour les accueillir.
 - demande de CHAPITRE → action "chapter" (destinée plutôt à un arc LINEAR).
 RÈGLE CLÉ : remplis TOUS les champs pour lesquels tu as de la matière — pas seulement
 le résumé ou les notes MJ. Chaque champ rempli atterrit au bon endroit de la fiche ;
 un champ laissé vide est une fiche que l'utilisateur devra compléter à la main. Vise
 2 à 5 phrases concrètes par champ narratif, tirées de la source et de la campagne.
 Omets simplement un champ si tu n'as rien de précis à y mettre. Formats acceptés :
 ```loremind-action
 {{"type": "npc", "name": "Nom",
  "description": "Résumé du PNJ (rôle, apparence, motivation).",
  "values": {{"<champ de la fiche PNJ>": "contenu", "<autre champ>": "contenu"}}}}
 ```
 (`values` : utilise comme clés les CHAMPS DE LA FICHE PNJ listés dans le contexte
 campagne s'ils y figurent — ex. "Histoire", "Apparence" — sinon omets `values`.)
 ```loremind-action
 {{"type": "scene", "name": "Nom",
  "description": "Résumé court de la scène.",
  "location": "Lieu précis", "timing": "Quand elle survient",
  "atmosphere": "Ambiance sensorielle (sons, odeurs, lumière…)",
  "playerNarration": "Texte d'ambiance À LIRE AUX JOUEURS, immersif, à la 2e personne.",
  "gmSecretNotes": "Secrets, vérités cachées, notes pour le MJ uniquement.",
  "choicesConsequences": "Choix offerts aux joueurs et leurs conséquences.",
  "combatDifficulty": "Difficulté du combat éventuel", "enemies": "Ennemis présents (effectifs, tactiques)"}}
 ```
 ```loremind-action
 {{"type": "chapter", "name": "Nom",
  "description": "Résumé du chapitre (ou de la quête).",
  "playerObjectives": "Objectifs tels que les joueurs les perçoivent.",
  "narrativeStakes": "Enjeux narratifs (ce qui se joue vraiment).",
  "gmNotes": "Notes MJ : fils à tirer, points d'attention."}}
 ```
 ```loremind-action
 {{"type": "arc", "name": "Nom", "description": "Résumé", "arcType": "LINEAR",
  "themes": "Thèmes de l'arc", "stakes": "Enjeux",
  "rewards": "Récompenses attendues", "resolution": "Issues possibles",
  "gmNotes": "Notes MJ."}}
 ```
 (`arcType` : "LINEAR" pour des chapitres en séquence, "HUB" pour un recueil de
 quêtes parallèles.)
 ```loremind-action
 {{"type": "table", "name": "Nom", "diceFormula": "1d8", "entries": [{{"minRoll":1,"maxRoll":4,"label":"...","detail":"..."}}]}}
 ```
 Réponds en français, de façon utile et concise. Mets le texte explicatif AVANT les blocs d'action."""
 class NotebookChatUseCase:
    def __init__(
@@ -32,7 +109,6 @@ class NotebookChatUseCase:
        messages: list[ChatMessage],
        context: str = "",
        top_k: int = 6,
        language: str = _DEFAULT_LANG,
    ) -> AsyncIterator[dict]:
        """Yield des évènements : {type:'sources', sources:[…]} (une fois, avant la
        réponse — transparence sur les passages utilisés), puis {type:'token', token}."""
@@ -67,9 +143,8 @@ class NotebookChatUseCase:
            f"--- TA CAMPAGNE ---\n{context.strip()}\n--- FIN CAMPAGNE ---\n\n"
            if context.strip() else "--- TA CAMPAGNE ---\n(aucune donnée de campagne)\n--- FIN CAMPAGNE ---\n\n"
        )
-        system_prompt = prompts.CHAT_SYSTEM.format(
+        system_prompt = _SYSTEM_PROMPT.format(
-            context_block=context_block, sources_block=sources_block,
+            context_block=context_block, sources_block=sources_block)
            language_name=language_name(language))
        async for token in self._llm.stream_chat(messages, system_prompt=system_prompt):
            yield {"type": "token", "token": token}
--- a/brain/app/application/notebook_deep.py
+++ b/brain/app/application/notebook_deep.py
@@ -20,9 +20,7 @@ from typing import AsyncIterator
 import tiktoken
 from app.application.llm_retry import generate_with_retry
 from app.application.prompts import notebook as prompts
 from app.application.query_rewrite import standalone_question
 from app.core.language import DEFAULT as _DEFAULT_LANG, language_name
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMChatProvider, LLMProvider, LLMProviderError
 from app.infrastructure import vector_store
@@ -38,6 +36,15 @@ _MAP_TEMPERATURE = 0.2
 # à la question par embedding, et seuls les lots plausiblement pertinents sont
 # relus. Sélection volontairement CONSERVATRICE (on préfère relire un lot de
 # trop que rater une mention) ; désactivable via deep_summary_filter=False.
 _SUMMARY_PROMPT = """Résume l'EXTRAIT ci-dessous en 4 à 8 puces factuelles : lieux, PNJ et
 créatures nommés, objets notables, évènements, règles particulières. Pas d'analyse, pas
 d'introduction — uniquement les puces, pour servir d'index de recherche.
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Résumé :"""
 # Un lot est gardé si son score est proche du meilleur (marge) OU bon dans
 # l'absolu ; et on garde toujours au moins _MIN_KEPT lots.
@@ -45,6 +52,38 @@ _SELECT_MARGIN = 0.10
 _SELECT_FLOOR = 0.5
 _MIN_KEPT = 3
 _MAP_PROMPT = """Voici un EXTRAIT d'un document. Extrais UNIQUEMENT les informations
 pertinentes pour répondre à la question ci-dessous. Conserve les détails utiles et
 indique les numéros de page (format « p. X »). Si l'extrait ne contient RIEN de
 pertinent, réponds EXACTEMENT « {no_match} » et rien d'autre.
 QUESTION : {question}
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Informations pertinentes (ou « {no_match} ») :"""
 _REDUCE_SYSTEM = """Tu es l'assistant-MJ d'un jeu de rôle. Tu réponds à la demande du MJ en
 t'appuyant sur TROIS sources : (1) des NOTES extraites de l'ENSEMBLE du document source (vue
 complète — mais POSSIBLEMENT VIDE si rien d'utile n'y figure), (2) le contexte de sa CAMPAGNE,
 (3) la conversation ci-dessous.
 - Si les notes contiennent des éléments utiles : exploite-les et CITE les pages (« p. X »).
 - Si les notes sont VIDES ou pauvres (cas fréquent d'une demande CRÉATIVE portant sur des
  éléments INVENTÉS par le MJ) : ne te bloque surtout PAS. Aide-le quand même en t'appuyant
  sur sa CAMPAGNE, la CONVERSATION et ta connaissance du genre — propose des adaptations
  concrètes (arcs, chapitres, scènes, PNJ), structurées et jouables.
 - Sois concret et utile. N'affirme rien de FAUX sur le contenu du document.
 {context_block}
 --- NOTES EXTRAITES DE TOUT LE DOCUMENT ---
 {notes_block}
 --- FIN DES NOTES ---
 Réponds en français."""
 class NotebookDeepUseCase:
    def __init__(
@@ -70,7 +109,6 @@ class NotebookDeepUseCase:
        messages: list[ChatMessage],
        context: str = "",
        history_limit: int = 8,
        language: str = _DEFAULT_LANG,
    ) -> AsyncIterator[dict]:
        """Yield des évènements : {type:'progress',current,total}, {type:'token',token},
        {type:'done'}. (Les erreurs LLM des lots sont tolérées : lot ignoré.)
@@ -137,9 +175,7 @@ class NotebookDeepUseCase:
            f"--- TA CAMPAGNE (structure, PNJ, univers) ---\n{context.strip()}\n--- FIN CAMPAGNE ---\n\n"
            if context.strip() else ""
        )
-        system_prompt = prompts.REDUCE_SYSTEM.format(
+        system_prompt = _REDUCE_SYSTEM.format(context_block=context_block, notes_block=notes_block)
            context_block=context_block, notes_block=notes_block,
            language_name=language_name(language))
        # Historique récent pour la cohérence des relances ; on garantit que le
        # dernier message est bien la question courante.
        reduce_messages = messages[-history_limit:] if messages else [ChatMessage(role="user", content=question)]
@@ -215,7 +251,7 @@ class NotebookDeepUseCase:
    async def _summarize_batch(self, batch: list[dict]) -> str:
        excerpt = "\n\n".join(c.get("text", "").strip() for c in batch)
        raw = await generate_with_retry(
-            self._llm, prompts.SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
+            self._llm, _SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
        return (raw or "").strip()
    async def _map_batch(self, question: str, batch: list[dict]) -> str:
@@ -224,7 +260,7 @@ class NotebookDeepUseCase:
            f"(p. {c['page']}) {c['text'].strip()}" if c.get("page") else c["text"].strip()
            for c in batch
        )
-        prompt = prompts.MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
+        prompt = _MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
        raw = await generate_with_retry(self._llm, prompt, temperature=_MAP_TEMPERATURE)
        answer = raw.strip()
        if answer and answer.upper().rstrip(".") != _NO_MATCH:
--- a/brain/app/application/prompts/init.py
+++ b/brain/app/application/prompts/init.py
@@ -1,12 +0,0 @@
 """Prompts LLM, regroupés hors de la logique des use cases.
 Un prompt est du code (couplé à son schéma de sortie et à son parsing), mais
 le mêler à la logique d'orchestration rend les use cases illisibles. Ce package
 isole le TEXTE des prompts : un module par domaine fonctionnel, miroir des
 modules de `app.application` / des routers.
 Convention : les use cases importent depuis ici et gardent la logique (chunking,
 parsing, fusion, schémas de sortie JSON, températures, sentinelles). Les prompts
 restent en français (langue de travail) — seule la langue de SORTIE est
 paramétrée, cf. `app.core.language`.
 """
--- a/brain/app/application/prompts/adapt_campaign.py
+++ b/brain/app/application/prompts/adapt_campaign.py
@@ -1,26 +0,0 @@
 """Prompts des conseils d'adaptation d'un PDF à une campagne (cf. adapt_campaign.py)."""
 from app.core.language import language_name
 SYSTEM_PREFIX = (
    "Tu es un assistant pour Maître de Jeu de jeu de rôle. L'utilisateur a une "
    "campagne EXISTANTE (décrite plus bas) et souhaite ADAPTER et INTÉGRER le "
    "contenu d'un PDF (aventure, donjon, supplément) à CETTE campagne précise."
 )
 def system_suffix(language: str) -> str:
    """Consignes de sortie, avec la langue des conseils pilotée par l'utilisateur."""
    return (
    f"Produis des CONSEILS D'ADAPTATION concrets, actionnables et en {language_name(language).upper()}, "
    "en markdown structuré (titres ##, listes). Couvre notamment :\n"
    "- **Où l'insérer** : à quel(s) arc(s)/chapitre(s) EXISTANT(s) rattacher ce "
    "contenu, dans quel ordre, et — si l'arc est un hub — sous quelles conditions de déblocage.\n"
    "- **Reskins / liens PNJ** : quels PNJ EXISTANTS de la campagne peuvent incarner "
    "ou remplacer les personnages clés du PDF.\n"
    "- **Adaptation à l'univers** : comment transposer lieux, factions, noms propres et "
    "ton vers l'univers de l'utilisateur plutôt que le cadre d'origine du PDF.\n"
    "- **Doublons / conflits** : ce qui recoupe l'existant et comment le réconcilier.\n"
    "- **Ajustements de ton et de difficulté**.\n\n"
    "Réfère-toi TOUJOURS aux éléments existants par leur NOM. Ne réécris PAS le PDF en "
    "entier : donne des recommandations. Si une information manque, propose des options."
    )
--- a/brain/app/application/prompts/chat.py
+++ b/brain/app/application/prompts/chat.py
@@ -1,23 +0,0 @@
 """Prompt système de base du chat contextuel (cf. chat.py).
 Les blocs de contexte (Lore, page, campagne, session…) sont sérialisés par les
 méthodes `_format_*` du use case ; seul le SYSTEM de base vit ici.
 """
 from app.core.language import language_name
 def base_system(language: str) -> str:
    """System prompt de base, avec la langue de réponse pilotée par l'utilisateur."""
    return f"""Tu es un assistant d'écriture pour un Maître de Jeu de JDR.
 Tu dialogues avec le MJ pour l'aider à enrichir son univers et ses campagnes.
 Règles de ton :
 - Réponds en {language_name(language)}, ton chaleureux et créatif.
 - Sois concis : listes à puces courtes plutôt que longs paragraphes.
 - Propose des idées qui s'intègrent dans le contexte existant ci-dessous.
 Règles de cohérence (IMPORTANT) :
 - Tu PEUX et DOIS inventer des éléments originaux (personnages, lieux, objets, intrigues, créatures, scènes) — c'est ton rôle d'assistant créatif.
 - Tu ne peux PAS faire référence à un élément du MJ (du Lore, des arcs, chapitres ou scènes) comme s'il existait déjà, SAUF s'il apparaît EXACTEMENT (même orthographe) dans l'une des sections de contexte ci-dessous.
 - Si l'utilisateur mentionne un nom que tu ne vois pas dans le contexte, ne fais surtout pas semblant de le connaître : dis clairement "Je ne vois pas [nom] dans le contexte actuel, veux-tu qu'on le crée ?" plutôt que d'inventer des détails à son sujet.
 - Évite les précisions inventées qu'on ne peut pas vérifier : dates exactes, chiffres de population, hiérarchies politiques complexes, généalogies détaillées. Préfère des formulations ouvertes que le MJ validera ("il y a longtemps", "de nombreux", "la haute noblesse")."""
--- a/brain/app/application/prompts/conversation_title.py
+++ b/brain/app/application/prompts/conversation_title.py
@@ -1,15 +0,0 @@
 """Prompt & repli de l'auto-titre de conversation (cf. router generation.py)."""
 from app.core.language import language_name
 # Titre de repli (LLM injoignable / réponse vide), localisé selon la langue UI.
 TITLE_FALLBACK = {"fr": "Nouvelle conversation", "en": "New conversation"}
 def title_system_prompt(language: str) -> str:
    """Consigne d'auto-titre, avec la langue du titre pilotée par l'utilisateur."""
    return (
        "Tu generes un titre court (4 a 7 mots max) qui resume le sujet de la "
        "conversation ci-dessous. Reponds UNIQUEMENT par le titre, sans guillemets, "
        "sans ponctuation finale, sans prefixe type 'Titre :'. Le titre doit etre "
        f"en {language_name(language)} et capturer le sujet metier (pas 'Conversation IA')."
    )
--- a/brain/app/application/prompts/generate_page.py
+++ b/brain/app/application/prompts/generate_page.py
@@ -1,19 +0,0 @@
 """Consignes système de la génération de page (cf. generate_page.py)."""
 from app.core.language import language_name
 def system_instructions(language: str) -> str:
    """Consignes système, avec la langue des valeurs générées pilotée par l'utilisateur."""
    return f"""Tu es un assistant d'écriture pour un Maître de Jeu de JDR.
 Tu vas générer le contenu d'une page appartenant à un univers fictionnel.
 Règles impératives de ta réponse :
 - Tu réponds UNIQUEMENT par un objet JSON valide.
 - Les clés du JSON correspondent EXACTEMENT aux noms de champs demandés.
 - Les valeurs sont des chaînes de texte en {language_name(language)}, riches et évocatrices.
 - Aucun markdown, aucune explication, aucun commentaire autour du JSON.
 Règles de cohérence (IMPORTANT) :
 - Tu PEUX inventer des détails originaux pour CETTE page : apparence, traits de caractère, anecdotes, histoire personnelle.
 - Tu ne dois PAS faire référence à d'autres personnages, lieux, organisations ou événements comme s'ils existaient déjà dans l'univers, sauf si le contexte ci-dessous les mentionne explicitement.
 - Si un champ appelle une précision externe (date, nom d'un roi, ville voisine, guerre passée), reste volontairement vague : "il y a de nombreuses années", "un bourg voisin", "une époque troublée". Le MJ préfère combler lui-même les blancs plutôt que trouver des faits inventés contradictoires avec son univers."""
--- a/brain/app/application/prompts/import_campaign.py
+++ b/brain/app/application/prompts/import_campaign.py
@@ -1,100 +0,0 @@
 """Prompts de l'import de campagne PDF (cf. import_campaign.py)."""
 # Nom de l'arc unique quand le livre n'est pas découpé en actes/parties.
 DEFAULT_ARC_NAME = "Aventure principale"
 MAP_SYSTEM = """Tu es un assistant qui structure un livre de campagne de jeu de rôle.
 On te donne un EXTRAIT brut d'un PDF de campagne (texte parfois mal coupé par la mise en page).
 Ta tâche : en dégager une ARBORESCENCE narrative à GROS GRAIN : arcs → chapitres → scènes,
 et — pour les lieux explorables — leurs PIÈCES (rooms).
  - Un ARC = un acte / une grande partie de la campagne (souvent un seul pour une aventure courte).
  - Un CHAPITRE = une étape majeure du récit : un chapitre du livre, OU — dans une
    campagne "hub" / bac-à-sable — UNE QUÊTE ou UN LIEU principal débloqué depuis le
    point central (ex : Dragon of Icespire Peak → chaque quête/lieu = un chapitre).
  - Une SCÈNE = un temps fort jouable du chapitre : un lieu, une rencontre clé, un moment pivot.
  - Une PIÈCE (room) = une salle d'un lieu explorable (donjon, crypte, manoir...).
 TYPE D'ARC ("type") :
 - "HUB" si la campagne est un bac-à-sable : des quêtes/lieux optionnels, parallèles,
  débloqués depuis un point central, SANS ordre fixe imposé (ex : Dragon of Icespire Peak).
 - "LINEAR" si les chapitres se jouent dans un ordre séquentiel imposé.
 - Dans le doute : "LINEAR".
 GRANULARITÉ (évite la sur-détection) :
 - Vise PEU de scènes : typiquement 1 à 6 par chapitre. PAS des dizaines.
 - Un LIEU EXPLORABLE (donjon, crypte, manoir, grotte à plusieurs salles) = UNE SEULE
  scène. Ses salles vont dans le tableau "rooms" de cette scène — JAMAIS en scènes séparées.
 - NE crée PAS une scène par rencontre isolée, par PNJ, par monstre ou par paragraphe.
 - IGNORE : blocs de stats, listes de monstres, encarts de règles, légendes de cartes,
  pieds de page, sommaires, crédits.
 CONTENU D'UNE SCÈNE (fidélité au livre — important) :
 - `description` = synopsis de la scène, 2 à 4 phrases (plus que 1 ligne, mais pas le texte intégral).
 - `player_narration` = le texte d'AMBIANCE « à lire aux joueurs » (encadrés / boxed text /
  « lecture à voix haute »), recopié FIDÈLEMENT s'il existe dans l'extrait. Vide sinon.
 - `gm_notes` = les informations pour le MJ : secrets, développement, ce qui se passe,
  conséquences, indices cachés. Vide si rien de tel.
 - Ne RÉSUME pas abusivement player_narration et gm_notes : recopie le contenu utile du livre.
 PIÈCES (rooms) — uniquement pour les scènes qui sont des lieux explorables :
 - Une entrée par salle numérotée/nommée du donjon (ex : "1. Entrée", "2. Salle des gardes").
 - `enemies` = créatures/boss de la salle (vide si aucune). `loot` = trésor/récompense (vide si aucun).
 - Pour une scène narrative classique (pas un donjon), "rooms" est un tableau vide [].
 PNJ ET CRÉATURES NOTABLES ("npcs", tableau au niveau racine) :
 - Recense les PNJ NOMMÉS (alliés, marchands, antagonistes) et les créatures UNIQUES
  (boss, monstre récurrent) présents dans l'extrait.
 - `description` = courte fiche utile au MJ : rôle dans l'histoire, apparence,
  motivations, où on le rencontre. 2 à 4 phrases, fidèles au livre.
 - N'inclus PAS les monstres génériques sans nom (« 3 gobelins », « un loup »).
 - Aucun PNJ nommé dans l'extrait → "npcs": [].
 Format de réponse :
 - Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
 - Schéma EXACT :
  {{"arcs": [{{"name": "...", "description": "...", "type": "LINEAR",
     "chapters": [{{"name": "...", "description": "...", "scenes": [
        {{"name": "...", "description": "...", "player_narration": "...", "gm_notes": "...",
          "rooms": [{{"name": "...", "description": "...", "enemies": "...", "loot": "..."}}]}}
     ]}}]}}
  ],
   "npcs": [{{"name": "...", "description": "..."}}]}}
 - Utilise les VRAIS titres du livre pour les noms (pas de paraphrase).
 - Si le livre n'est PAS découpé en actes/parties, regroupe tout sous un seul arc nommé "{default_arc}".
 - N'invente pas de contenu : tu réorganises et recopies ce qui est présent dans l'extrait.
 - Si l'extrait ne contient aucune matière narrative, renvoie {{"arcs": []}}."""
 # Bloc TOC injecté quand le PDF a des bookmarks : les morceaux étant traités
 # séparément, c'est CE référentiel commun qui garantit que tous nomment les
 # mêmes chapitres à l'identique → la fusion par nom du _TreeMerger recolle
 # les chapitres coupés au lieu de créer des doublons.
 TOC_BLOCK = """
 --- STRUCTURE OFFICIELLE DU LIVRE (table des matières du PDF) ---
 {toc}
 --- FIN DE LA STRUCTURE ---
 IMPORTANT : pour nommer les arcs et chapitres, reprends EXACTEMENT les titres
 de cette structure (caractère pour caractère). Rattache le contenu de l'extrait
 au bon chapitre de la structure, même si son titre n'apparaît pas dans l'extrait."""
 # Consolidation finale : le squelette (noms seuls) est minuscule, donc l'appel
 # est quasi gratuit comparé aux MAP. Température 0 et consigne CONSERVATRICE :
 # ne fusionner que les doublons évidents, jamais des entités distinctes.
 CONSOLIDATE_PROMPT = """Voici le squelette d'une arborescence arc → chapitre → scène issue d'une
 fusion AUTOMATIQUE de morceaux d'un livre de campagne de jeu de rôle. La fusion par nom exact
 peut avoir laissé des QUASI-DOUBLONS : le même chapitre ou la même scène sous deux libellés
 légèrement différents (ex: "La Crypte" et "Crypte de Karrak", "3. Salle des gardes" et
 "Salle des gardes").
 {skeleton}
 Identifie UNIQUEMENT les fusions ÉVIDENTES (même entité du livre sous deux noms). Sois
 CONSERVATEUR : dans le doute, ne fusionne PAS. Deux lieux/évènements distincts ne doivent
 JAMAIS être fusionnés.
 Réponds UNIQUEMENT par un objet JSON valide :
 {{"chapter_merges": [{{"into": "nom du chapitre à garder", "merge": ["nom à fusionner", ...]}}],
  "scene_merges": [{{"chapter": "nom du chapitre", "into": "nom de la scène à garder",
                     "merge": ["nom à fusionner", ...]}}]}}
 S'il n'y a RIEN à fusionner (cas le plus fréquent) : {{"chapter_merges": [], "scene_merges": []}}"""
--- a/brain/app/application/prompts/import_rules.py
+++ b/brain/app/application/prompts/import_rules.py
@@ -1,62 +0,0 @@
 """Prompts de l'import de règles PDF (cf. import_rules.py).
 Deux modes : MAP_SYSTEM (cloud, réécrit le contenu en sections markdown) et
 SEGMENT_SYSTEM (local, ne renvoie que les frontières des sections). Les deux
 templates attendent `.format(canonical=..., language_name=...)`.
 """
 # Taxonomie canonique suggérée au modèle pour homogénéiser les titres entre
 # morceaux (sinon "Combat" / "Le combat" / "Règles de combat" se dispersent).
 # Le modèle reste libre d'en créer d'autres si rien ne correspond.
 CANONICAL_SECTIONS = [
    "Règles générales",
    "Création de personnage",
    "Caractéristiques et tests",
    "Compétences",
    "Combat",
    "Magie et sorts",
    "Équipement et objets",
    "États et conditions",
    "Repos et récupération",
    "Progression et niveaux",
    "Conseils au Maître de Jeu",
 ]
 MAP_SYSTEM = """Tu es un assistant qui réorganise un livre de règles de jeu de rôle.
 On te donne un EXTRAIT brut d'un PDF de règles (texte parfois mal coupé par la mise en page).
 Ta tâche : répartir le contenu de cet extrait dans des SECTIONS THÉMATIQUES.
 Format EXACT attendu — un objet JSON plat {{titre de section: contenu markdown}} :
 {{"Combat": "## Initiative\\n\\nChaque participant lance 1d20...", "Magie et sorts": "## Sorts\\n\\n..."}}
 Règles impératives :
 - Tu réponds UNIQUEMENT par cet objet JSON, sans texte avant ni après.
 - Les CLÉS sont des titres de section (texte court). Les VALEURS sont le contenu de la règle en markdown (chaîne de caractères, jamais un objet ou une liste).
 - INTERDIT : des clés génériques comme "title", "content", "sections", "thought" ou "notes" ; des objets imbriqués ; tout commentaire sur ta démarche ou ton raisonnement.
 - Utilise EN PRIORITÉ ces titres canoniques quand le contenu y correspond :
 {canonical}
 - Si un contenu ne rentre dans aucun, crée un titre clair et concis (en {language_name}).
 - Reproduis FIDÈLEMENT les règles : tu peux nettoyer la coupure des lignes, recoller les mots coupés
  par un tiret en fin de ligne, retirer les en-têtes/pieds de page et numéros de page parasites.
 - N'INVENTE AUCUNE règle, ne résume pas abusivement : tu réorganises, tu ne réécris pas le fond.
 - Ignore les pages de garde, sommaires, crédits, pages vides (renvoie {{}} si l'extrait n'a aucune règle)."""
 SEGMENT_SYSTEM = """Tu analyses un EXTRAIT brut d'un livre de règles de jeu de rôle.
 Ta tâche : repérer où COMMENCENT les sections thématiques. Tu ne réécris RIEN.
 Format EXACT attendu :
 {{"sections": [{{"titre": "Combat", "debut": "Le combat se déroule en tours de"}}, ...]}}
 Règles impératives :
 - "debut" = les 5 à 10 PREMIERS MOTS du passage où la section commence, COPIÉS À L'IDENTIQUE
  depuis l'extrait (même orthographe, même ponctuation, même langue). JAMAIS un résumé.
 - La PREMIÈRE entrée commence aux tout premiers mots de l'extrait (même si le contenu
  poursuit une section entamée avant cet extrait).
 - Les entrées suivent l'ordre du texte. Vise des sections LARGES (un thème), pas un titre
  par paragraphe : un extrait contient typiquement 1 à 6 sections.
 - Titres : EN PRIORITÉ parmi :
 {canonical}
  sinon un titre court et clair en {language_name}.
 - Pages de garde, sommaires, crédits : n'en fais pas des sections. Si l'extrait n'est que ça,
  renvoie {{"sections": []}}."""
--- a/brain/app/application/prompts/notebook.py
+++ b/brain/app/application/prompts/notebook.py
@@ -1,134 +0,0 @@
 """Prompts des notebooks (atelier RAG) : chat ancré (cf. notebook_chat.py) et
 analyse approfondie map-reduce (cf. notebook_deep.py).
 CHAT_SYSTEM attend `.format(context_block=..., sources_block=..., language_name=...)`.
 REDUCE_SYSTEM attend `.format(context_block=..., notes_block=..., language_name=...)`.
 MAP_PROMPT attend `.format(no_match=..., question=..., excerpt=...)`.
 SUMMARY_PROMPT attend `.format(excerpt=...)`.
 """
 # --- Chat ancré (RAG) --------------------------------------------------------
 CHAT_SYSTEM = """Tu es un assistant de jeu de rôle qui aide à ADAPTER une source (PDF) à la CAMPAGNE de l'utilisateur.
 Tu disposes de DEUX connaissances, toutes deux ci-dessous :
 1) LA CAMPAGNE de l'utilisateur (sa structure arcs/chapitres/scènes, ses PNJ, son univers) ;
 2) LA SOURCE (extraits pertinents du PDF).
 Règles :
 - Pour une question sur SA CAMPAGNE (ex. « mon chapitre 3 », « mes PNJ »), appuie-toi sur la section CAMPAGNE.
 - Pour une question sur le livre, appuie-toi sur les EXTRAITS DE LA SOURCE.
 - CROISE les deux pour proposer des adaptations cohérentes avec sa campagne existante.
 - N'invente pas ce qui ne figure ni dans la campagne ni dans la source ; si tu ne sais pas, dis-le.
 - Quand un extrait porte un numéro de page (« (p. 12) »), cite-le (« d'après la p. 12 »).
 {context_block}
 --- EXTRAITS PERTINENTS DE LA SOURCE ---
 {sources_block}
 --- FIN DES EXTRAITS ---
 PROPOSITIONS D'INTÉGRATION (IMPORTANT) :
 Quand l'utilisateur veut CRÉER ou ADAPTER un élément concret pour sa campagne (un PNJ,
 une scène, un chapitre, une quête, un arc, une table aléatoire), termine ta réponse par
 un ou plusieurs BLOCS D'ACTION — un objet JSON par bloc, dans une clôture
 ```loremind-action. L'interface les transformera en boutons « Créer dans la campagne ».
 Si l'utilisateur demande PLUSIEURS éléments (« propose-moi 3 quêtes »), produis UN bloc
 par élément. N'en mets pas si l'utilisateur pose une simple question.
 VOCABULAIRE DE LA CAMPAGNE : une « quête » n'est PAS un type à part — c'est un CHAPITRE
 rangé dans un arc de type HUB (quêtes parallèles, sans ordre imposé), tandis qu'un arc
 LINEAR contient des chapitres joués en séquence. Donc :
 - demande de QUÊTE → action "chapter" (l'utilisateur la placera dans son arc HUB) ;
  s'il n'a aucun arc HUB dans sa campagne, propose AUSSI une action "arc" avec
  "arcType": "HUB" pour les accueillir.
 - demande de CHAPITRE → action "chapter" (destinée plutôt à un arc LINEAR).
 RÈGLE CLÉ : remplis TOUS les champs pour lesquels tu as de la matière — pas seulement
 le résumé ou les notes MJ. Chaque champ rempli atterrit au bon endroit de la fiche ;
 un champ laissé vide est une fiche que l'utilisateur devra compléter à la main. Vise
 2 à 5 phrases concrètes par champ narratif, tirées de la source et de la campagne.
 Omets simplement un champ si tu n'as rien de précis à y mettre. Formats acceptés :
 ```loremind-action
 {{"type": "npc", "name": "Nom",
  "description": "Résumé du PNJ (rôle, apparence, motivation).",
  "values": {{"<champ de la fiche PNJ>": "contenu", "<autre champ>": "contenu"}}}}
 ```
 (`values` : utilise comme clés les CHAMPS DE LA FICHE PNJ listés dans le contexte
 campagne s'ils y figurent — ex. "Histoire", "Apparence" — sinon omets `values`.)
 ```loremind-action
 {{"type": "scene", "name": "Nom",
  "description": "Résumé court de la scène.",
  "location": "Lieu précis", "timing": "Quand elle survient",
  "atmosphere": "Ambiance sensorielle (sons, odeurs, lumière…)",
  "playerNarration": "Texte d'ambiance À LIRE AUX JOUEURS, immersif, à la 2e personne.",
  "gmSecretNotes": "Secrets, vérités cachées, notes pour le MJ uniquement.",
  "choicesConsequences": "Choix offerts aux joueurs et leurs conséquences.",
  "combatDifficulty": "Difficulté du combat éventuel", "enemies": "Ennemis présents (effectifs, tactiques)"}}
 ```
 ```loremind-action
 {{"type": "chapter", "name": "Nom",
  "description": "Résumé du chapitre (ou de la quête).",
  "playerObjectives": "Objectifs tels que les joueurs les perçoivent.",
  "narrativeStakes": "Enjeux narratifs (ce qui se joue vraiment).",
  "gmNotes": "Notes MJ : fils à tirer, points d'attention."}}
 ```
 ```loremind-action
 {{"type": "arc", "name": "Nom", "description": "Résumé", "arcType": "LINEAR",
  "themes": "Thèmes de l'arc", "stakes": "Enjeux",
  "rewards": "Récompenses attendues", "resolution": "Issues possibles",
  "gmNotes": "Notes MJ."}}
 ```
 (`arcType` : "LINEAR" pour des chapitres en séquence, "HUB" pour un recueil de
 quêtes parallèles.)
 ```loremind-action
 {{"type": "table", "name": "Nom", "diceFormula": "1d8", "entries": [{{"minRoll":1,"maxRoll":4,"label":"...","detail":"..."}}]}}
 ```
 Réponds en {language_name}, de façon utile et concise. Mets le texte explicatif AVANT les blocs d'action."""
 # --- Analyse approfondie (map-reduce) ----------------------------------------
 SUMMARY_PROMPT = """Résume l'EXTRAIT ci-dessous en 4 à 8 puces factuelles : lieux, PNJ et
 créatures nommés, objets notables, évènements, règles particulières. Pas d'analyse, pas
 d'introduction — uniquement les puces, pour servir d'index de recherche.
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Résumé :"""
 MAP_PROMPT = """Voici un EXTRAIT d'un document. Extrais UNIQUEMENT les informations
 pertinentes pour répondre à la question ci-dessous. Conserve les détails utiles et
 indique les numéros de page (format « p. X »). Si l'extrait ne contient RIEN de
 pertinent, réponds EXACTEMENT « {no_match} » et rien d'autre.
 QUESTION : {question}
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Informations pertinentes (ou « {no_match} ») :"""
 REDUCE_SYSTEM = """Tu es l'assistant-MJ d'un jeu de rôle. Tu réponds à la demande du MJ en
 t'appuyant sur TROIS sources : (1) des NOTES extraites de l'ENSEMBLE du document source (vue
 complète — mais POSSIBLEMENT VIDE si rien d'utile n'y figure), (2) le contexte de sa CAMPAGNE,
 (3) la conversation ci-dessous.
 - Si les notes contiennent des éléments utiles : exploite-les et CITE les pages (« p. X »).
 - Si les notes sont VIDES ou pauvres (cas fréquent d'une demande CRÉATIVE portant sur des
  éléments INVENTÉS par le MJ) : ne te bloque surtout PAS. Aide-le quand même en t'appuyant
  sur sa CAMPAGNE, la CONVERSATION et ta connaissance du genre — propose des adaptations
  concrètes (arcs, chapitres, scènes, PNJ), structurées et jouables.
 - Sois concret et utile. N'affirme rien de FAUX sur le contenu du document.
 {context_block}
 --- NOTES EXTRAITES DE TOUT LE DOCUMENT ---
 {notes_block}
 --- FIN DES NOTES ---
 Réponds en {language_name}."""
--- a/brain/app/application/prompts/query_rewrite.py
+++ b/brain/app/application/prompts/query_rewrite.py
@@ -1,20 +0,0 @@
 """Prompt de réécriture en question autonome (cf. query_rewrite.py).
 Attend `.format(conversation=...)`.
 """
 REWRITE_PROMPT = """Voici la fin d'une conversation entre un Maître de Jeu et son assistant.
 Réécris le DERNIER message de l'utilisateur en une question AUTONOME et complète :
 remplace les pronoms et références implicites (« il », « ses », « ce lieu », « et pour
 les autres ? ») par ce qu'ils désignent dans la conversation.
 Règles :
 - Réponds UNIQUEMENT par la question réécrite, sans guillemets ni préfixe.
 - Conserve la langue et l'intention d'origine. N'ajoute RIEN qui n'est pas demandé.
 - Si le dernier message est déjà autonome, recopie-le tel quel.
 --- CONVERSATION ---
 {conversation}
 --- FIN ---
 Question autonome :"""
--- a/brain/app/application/prompts/rerank.py
+++ b/brain/app/application/prompts/rerank.py
@@ -1,14 +0,0 @@
 """Prompt de reranking LLM des passages RAG (cf. rerank.py).
 Attend `.format(question=..., passages=..., count=...)`.
 """
 RERANK_PROMPT = """Tu évalues la PERTINENCE d'extraits d'un document pour répondre à une question.
 Note chaque extrait de 0 (sans rapport) à 10 (répond directement), indépendamment des autres.
 QUESTION : {question}
 {passages}
 Réponds UNIQUEMENT par un objet JSON : {{"scores": [note_extrait_1, note_extrait_2, ...]}}
 Le tableau doit contenir EXACTEMENT {count} notes, dans l'ordre des extraits."""
--- a/brain/app/application/prompts/tables.py
+++ b/brain/app/application/prompts/tables.py
@@ -1,60 +0,0 @@
 """Prompts des outils de table (tables aléatoires, improvisation, catalogues).
 Ces prompts étaient auparavant construits en ligne dans le router `tables.py` ;
 isolés ici pour garder la frontière HTTP fine. Le router calcule les plages de
 dés et passe les champs bruts ; ces fonctions façonnent le texte.
 """
 from app.core.language import language_name
 def random_table_prompt(description: str, dice_formula: str, lo: int, hi: int,
                        context: str, language: str) -> str:
    """Prompt de génération d'une table aléatoire couvrant lo..hi."""
    context_block = f"\nContexte de la campagne :\n{context.strip()}\n" if context.strip() else ""
    return (
        "Tu es un assistant de jeu de rôle. Génère une TABLE ALÉATOIRE évocatrice.\n"
        f"Dé : {dice_formula} (résultats possibles de {lo} à {hi}).\n"
        f"Sujet : {description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "entries": '
        '[{"min_roll": N, "max_roll": M, "label": "résultat court", "detail": "1-2 phrases"}]}\n'
        f"- Les plages (min_roll..max_roll) doivent COUVRIR EXACTEMENT {lo}..{hi}, "
        "sans trou ni chevauchement, dans l'ordre croissant.\n"
        "- Des résultats variés, cohérents avec le sujet (et le contexte s'il est fourni).\n"
        f"- En {language_name(language)}. 'label' = résultat bref ; 'detail' = description/effet concret.\n"
        "Renvoie maintenant le JSON."
    )
 def improvise_roll_prompt(table_name: str, result_label: str, result_detail: str,
                         context: str, language: str) -> str:
    """Prompt de narration brodée sur un résultat tiré."""
    detail = f" ({result_detail.strip()})" if result_detail.strip() else ""
    context_block = f"\nContexte : {context.strip()}" if context.strip() else ""
    return (
        "Tu es le Maître du Jeu. Les joueurs viennent de tirer sur la table "
        f"« {table_name.strip()} » et ont obtenu : « {result_label.strip()} »{detail}."
        f"{context_block}\n\n"
        "Décris en 2-3 phrases vivantes et immédiates ce qui se passe, pour lancer la scène. "
        f"Pas de méta, pas d'options : juste la narration, en {language_name(language)}."
    )
 def item_catalog_prompt(description: str, context: str, language: str) -> str:
    """Prompt de génération d'un catalogue d'objets (boutique, butin…)."""
    context_block = f"\nContexte de la campagne :\n{context.strip()}\n" if context.strip() else ""
    return (
        "Tu es un assistant de jeu de rôle. Génère un CATALOGUE D'OBJETS (boutique, butin, trésor…).\n"
        f"Sujet : {description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "items": '
        '[{"name": "Objet", "price": "ex. 50 po", "category": "ex. Armes", "description": "effet/détails"}]}\n'
        "- Des objets variés et cohérents avec le sujet (et le contexte s'il est fourni).\n"
        "- 'price' = prix court dans la monnaie du jeu ; 'category' = regroupement (Armes, Potions…) ; "
        f"'description' = effet/détails en une phrase. En {language_name(language)}.\n"
        "Renvoie maintenant le JSON."
    )
--- a/brain/app/application/query_rewrite.py
+++ b/brain/app/application/query_rewrite.py
@@ -11,7 +11,6 @@ from __future__ import annotations
 import logging
 from app.application.prompts import query_rewrite as prompts
 from app.domain.models import ChatMessage
 logger = logging.getLogger(__name__)
@@ -24,6 +23,22 @@ _MAX_HISTORY = 6
 # modèle a divagué) → on retombe sur la question brute.
 _MAX_REWRITE_CHARS = 400
 _REWRITE_PROMPT = """Voici la fin d'une conversation entre un Maître de Jeu et son assistant.
 Réécris le DERNIER message de l'utilisateur en une question AUTONOME et complète :
 remplace les pronoms et références implicites (« il », « ses », « ce lieu », « et pour
 les autres ? ») par ce qu'ils désignent dans la conversation.
 Règles :
 - Réponds UNIQUEMENT par la question réécrite, sans guillemets ni préfixe.
 - Conserve la langue et l'intention d'origine. N'ajoute RIEN qui n'est pas demandé.
 - Si le dernier message est déjà autonome, recopie-le tel quel.
 --- CONVERSATION ---
 {conversation}
 --- FIN ---
 Question autonome :"""
 async def standalone_question(llm, messages: list[ChatMessage]) -> str:
    """Condense `messages` en une question autonome pour la RECHERCHE.
@@ -41,7 +56,7 @@ async def standalone_question(llm, messages: list[ChatMessage]) -> str:
    conversation = "\n".join(f"{m.role.upper()}: {m.content.strip()}" for m in recent)
    try:
        raw = await llm.generate(
-            prompts.REWRITE_PROMPT.format(conversation=conversation), temperature=0.0)
+            _REWRITE_PROMPT.format(conversation=conversation), temperature=0.0)
    except Exception as exc:  # noqa: BLE001 — la recherche dégradée vaut mieux que pas de réponse
        logger.warning("Réécriture de question ignorée (échec LLM) : %s", exc)
        return last_user
--- a/brain/app/application/rerank.py
+++ b/brain/app/application/rerank.py
@@ -11,7 +11,6 @@ from __future__ import annotations
 import logging
 from app.application.llm_json import load_json_object
 from app.application.prompts import rerank as prompts
 logger = logging.getLogger(__name__)
@@ -24,6 +23,16 @@ POOL_MAX = 24
 # prompt sans changer le jugement de pertinence.
 _EXCERPT_CHARS = 600
 _RERANK_PROMPT = """Tu évalues la PERTINENCE d'extraits d'un document pour répondre à une question.
 Note chaque extrait de 0 (sans rapport) à 10 (répond directement), indépendamment des autres.
 QUESTION : {question}
 {passages}
 Réponds UNIQUEMENT par un objet JSON : {{"scores": [note_extrait_1, note_extrait_2, ...]}}
 Le tableau doit contenir EXACTEMENT {count} notes, dans l'ordre des extraits."""
 def pool_size(top_k: int) -> int:
    """Taille du pool à récupérer avant reranking."""
@@ -43,7 +52,7 @@ async def rerank(llm, question: str, passages: list[dict], top_k: int) -> list[d
        f"--- EXTRAIT {i + 1} ---\n{(p.get('text') or '')[:_EXCERPT_CHARS]}"
        for i, p in enumerate(passages)
    )
-    prompt = prompts.RERANK_PROMPT.format(
+    prompt = _RERANK_PROMPT.format(
        question=question, passages=numbered, count=len(passages))
    try:
        raw = await llm.generate(prompt, temperature=0.0)
--- a/brain/app/core/language.py
+++ b/brain/app/core/language.py
@@ -1,61 +0,0 @@
 """Langue de sortie de l'IA, pilotée par l'utilisateur (et non plus figée en FR).
 Le Core relaie la langue choisie dans l'UI via l'entête HTTP `X-User-Language`
 (`fr`/`en`). Ce module centralise :
  - la normalisation du code reçu (tolérante : `en-US`, `EN`, un `Accept-Language`
    brut… → `en`) avec repli sur le français ;
  - la fabrique de la directive de langue injectée dans les prompts ;
  - la dépendance FastAPI qui lit l'entête côté router.
 Ajouter une langue = une entrée dans `NAMES`. Aucun autre branchement n'est requis.
 """
 from typing import Annotated
 from fastapi import Header
 # Nom (en français, langue de travail des prompts) de chaque langue supportée.
 # La clé est le code court ISO 639-1 utilisé par l'UI (cf. LanguageService Angular).
 NAMES: dict[str, str] = {
    "fr": "français",
    "en": "anglais",
 }
 DEFAULT = "fr"
 def normalize(raw: str | None) -> str:
    """Réduit un code/entête langue arbitraire à un code supporté (`fr`/`en`).
    Tolère les variantes régionales (`en-GB`), la casse, et un `Accept-Language`
    complet (`fr-FR,fr;q=0.9,en;q=0.8`) dont on ne garde que la 1re préférence.
    Repli systématique sur `DEFAULT` si rien ne matche.
    """
    if not raw:
        return DEFAULT
    # 1re préférence d'un éventuel Accept-Language, puis base avant le tiret régional.
    primary = raw.split(",")[0].split(";")[0].strip().lower()
    base = primary.split("-")[0]
    return base if base in NAMES else DEFAULT
 def language_name(lang: str) -> str:
    """Nom de la langue (pour insertion inline dans un prompt)."""
    return NAMES.get(lang, NAMES[DEFAULT])
 def instruction(lang: str) -> str:
    """Directive forte à injecter dans un prompt pour imposer la langue de sortie."""
    return (
        f"IMPORTANT : rédige l'INTÉGRALITÉ de ta réponse en {language_name(lang)}, "
        "quelle que soit la langue du contexte ou des documents fournis."
    )
 def get_user_language(
    x_user_language: Annotated[str | None, Header()] = None,
 ) -> str:
    """Dépendance FastAPI : langue de l'utilisateur lue depuis l'entête `X-User-Language`.
    Absente (appel direct, vieux client) → français par défaut.
    """
    return normalize(x_user_language)
--- a/core/src/main/java/com/loremind/domain/conversationcontext/ports/ConversationTitleGenerator.java
+++ b/core/src/main/java/com/loremind/domain/conversationcontext/ports/ConversationTitleGenerator.java
@@ -10,9 +10,6 @@ import java.util.List;
 */
 public interface ConversationTitleGenerator {
-    /**
+    /** Renvoie un titre en francais (4-7 mots max). Jamais null ni vide. */
     * Renvoie un titre court (4-7 mots max), dans la langue de l'utilisateur
     * (relayee au Brain via l'entete X-User-Language). Jamais null ni vide.
     */
    String generate(List<ConversationMessage> firstMessages);
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainAiChatClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainAiChatClient.java
@@ -4,7 +4,6 @@ import com.loremind.domain.generationcontext.ChatRequest;
 import com.loremind.domain.generationcontext.ChatUsage;
 import com.loremind.domain.generationcontext.ports.AiChatProvider;
 import com.loremind.domain.generationcontext.ports.AiProviderException;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.MediaType;
@@ -65,7 +64,6 @@ public class BrainAiChatClient implements AiChatProvider {
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(CHAT_STREAM_PATH)
                .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                .contentType(MediaType.APPLICATION_JSON)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .bodyValue(payload)
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignAdaptClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignAdaptClient.java
@@ -3,7 +3,6 @@ package com.loremind.infrastructure.ai;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.loremind.domain.campaigncontext.ports.CampaignPdfAdvisor;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.core.io.ByteArrayResource;
@@ -66,7 +65,6 @@ public class BrainCampaignAdaptClient implements CampaignPdfAdvisor {
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(ADAPT_PATH)
                .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                .contentType(MediaType.MULTIPART_FORM_DATA)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .body(BodyInserters.fromMultipartData(parts.build()))
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignImportClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignImportClient.java
@@ -11,7 +11,6 @@ import com.loremind.domain.campaigncontext.CampaignImportProposal.RoomProposal;
 import com.loremind.domain.campaigncontext.CampaignImportProposal.SceneProposal;
 import com.loremind.domain.campaigncontext.ports.CampaignImportException;
 import com.loremind.domain.campaigncontext.ports.CampaignPdfImporter;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.core.io.ByteArrayResource;
@@ -72,7 +71,6 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(IMPORT_CAMPAIGN_STREAM_PATH)
                .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                .contentType(MediaType.MULTIPART_FORM_DATA)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .body(BodyInserters.fromMultipartData(parts.build()))
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainConversationTitleClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainConversationTitleClient.java
@@ -2,7 +2,6 @@ package com.loremind.infrastructure.ai;
 import com.loremind.domain.conversationcontext.ConversationMessage;
 import com.loremind.domain.conversationcontext.ports.ConversationTitleGenerator;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
@@ -51,7 +50,6 @@ public class BrainConversationTitleClient implements ConversationTitleGenerator
            @SuppressWarnings("unchecked")
            Map<String, Object> resp = webClient.post()
                    .uri(PATH)
                    .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                    .contentType(MediaType.APPLICATION_JSON)
                    .bodyValue(payload)
                    .retrieve()
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookChatClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookChatClient.java
@@ -4,7 +4,6 @@ import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.loremind.domain.campaigncontext.ports.NotebookChatStreamer;
 import com.loremind.domain.campaigncontext.ports.NotebookException;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.MediaType;
@@ -67,7 +66,6 @@ public class BrainNotebookChatClient implements NotebookChatStreamer {
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(deep ? DEEP_PATH : PATH)
                .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                .contentType(MediaType.APPLICATION_JSON)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .bodyValue(payload)
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainRulesImportClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainRulesImportClient.java
@@ -6,7 +6,6 @@ import com.loremind.domain.gamesystemcontext.RulesImportProgress;
 import com.loremind.domain.gamesystemcontext.RulesImportResult;
 import com.loremind.domain.gamesystemcontext.ports.RulesImportException;
 import com.loremind.domain.gamesystemcontext.ports.RulesPdfImporter;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
@@ -126,7 +125,6 @@ public class BrainRulesImportClient implements RulesPdfImporter {
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(IMPORT_RULES_STREAM_PATH)
                .header(UserLanguageHolder.HEADER, UserLanguageHolder.get())
                .contentType(MediaType.MULTIPART_FORM_DATA)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .body(BodyInserters.fromMultipartData(parts.build()))
--- a/core/src/main/java/com/loremind/infrastructure/ai/RestTemplateConfig.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/RestTemplateConfig.java
@@ -1,6 +1,5 @@
 package com.loremind.infrastructure.ai;
 import com.loremind.infrastructure.web.config.UserLanguageHolder;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.web.client.RestTemplateBuilder;
 import org.springframework.boot.web.reactive.function.client.WebClientCustomizer;
@@ -18,12 +17,6 @@ import java.time.Duration;
 * <p>
 * Sans cette entete, le Brain refuse la requete (401) — defense contre
 * l'acces direct au Brain depuis un attaquant qui atteindrait son port.
 * <p>
 * Relaie aussi l'entete X-User-Language (langue choisie dans l'UI, capturee par
 * {@link com.loremind.infrastructure.web.config.UserLanguageFilter}) pour que le
 * Brain redige ses reponses IA dans la langue de l'utilisateur. Lu depuis le
 * ThreadLocal au moment de l'execution de la requete (thread servlet) — d'ou
 * l'usage d'un interceptor (et non d'un defaultHeader fige au demarrage).
 */
@Configuration
 public class RestTemplateConfig {
@@ -43,7 +36,6 @@ public class RestTemplateConfig {
                    if (internalSecret != null && !internalSecret.isBlank()) {
                        request.getHeaders().set(INTERNAL_SECRET_HEADER, internalSecret);
                    }
                    request.getHeaders().set(UserLanguageHolder.HEADER, UserLanguageHolder.get());
                    return execution.execute(request, body);
                })
                .build();
@@ -67,7 +59,6 @@ public class RestTemplateConfig {
                    if (internalSecret != null && !internalSecret.isBlank()) {
                        request.getHeaders().set(INTERNAL_SECRET_HEADER, internalSecret);
                    }
                    request.getHeaders().set(UserLanguageHolder.HEADER, UserLanguageHolder.get());
                    return execution.execute(request, body);
                })
                .build();
--- a/core/src/main/java/com/loremind/infrastructure/web/config/UserLanguageFilter.java
+++ b/core/src/main/java/com/loremind/infrastructure/web/config/UserLanguageFilter.java
@@ -1,40 +0,0 @@
 package com.loremind.infrastructure.web.config;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 import org.springframework.web.filter.OncePerRequestFilter;
 import java.io.IOException;
 /**
 * Capture la langue de l'utilisateur (entête {@code X-User-Language} envoyé par le
 * frontend) dans {@link UserLanguageHolder} pour la durée de la requête, puis la
 * nettoie systématiquement.
 * <p>
 * Les clients du Brain liront ce ThreadLocal au moment de construire leur appel
 * (sur ce même thread servlet) pour relayer la langue au Brain. Indispensable de
 * {@code clear()} en {@code finally} : les threads servlet sont recyclés dans un
 * pool, une valeur oubliée fuiterait sur la requête suivante.
 */
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
 public class UserLanguageFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        try {
            UserLanguageHolder.set(request.getHeader(UserLanguageHolder.HEADER));
            filterChain.doFilter(request, response);
        } finally {
            UserLanguageHolder.clear();
        }
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/web/config/UserLanguageHolder.java
+++ b/core/src/main/java/com/loremind/infrastructure/web/config/UserLanguageHolder.java
@@ -1,58 +0,0 @@
 package com.loremind.infrastructure.web.config;
 import java.util.Set;
 /**
 * Langue de l'utilisateur courant, portée par un ThreadLocal le temps d'une
 * requête HTTP entrante.
 * <p>
 * Le frontend Angular envoie son choix de langue (code court {@code fr}/{@code en})
 * via l'entête {@code X-User-Language}. {@link UserLanguageFilter} la capture ici,
 * et les clients du Brain ({@code RestTemplateConfig} pour les appels bloquants,
 * les clients WebClient pour le streaming) la relaient au Brain — qui rédige alors
 * ses réponses IA dans cette langue.
 * <p>
 * Repli systématique sur le français si rien n'est fourni (vieux client, appel interne).
 */
 public final class UserLanguageHolder {
    /** Nom de l'entête HTTP relayant la langue, du frontend jusqu'au Brain. */
    public static final String HEADER = "X-User-Language";
    /** Langue par défaut quand l'entête est absent ou non reconnu. */
    public static final String DEFAULT = "fr";
    /** Langues supportées (alignées sur LanguageService Angular et NAMES côté Brain). */
    private static final Set<String> SUPPORTED = Set.of("fr", "en");
    private static final ThreadLocal<String> CURRENT = ThreadLocal.withInitial(() -> DEFAULT);
    private UserLanguageHolder() {
    }
    /**
     * Normalise un code/entête langue arbitraire vers un code supporté.
     * Tolère la casse, les variantes régionales ({@code en-US}) et un
     * {@code Accept-Language} complet ({@code fr-FR,fr;q=0.9}). Repli {@code DEFAULT}.
     */
    public static String normalize(String raw) {
        if (raw == null || raw.isBlank()) {
            return DEFAULT;
        }
        String primary = raw.split(",")[0].split(";")[0].trim().toLowerCase();
        String base = primary.split("-")[0];
        return SUPPORTED.contains(base) ? base : DEFAULT;
    }
    public static void set(String language) {
        CURRENT.set(normalize(language));
    }
    public static String get() {
        return CURRENT.get();
    }
    public static void clear() {
        CURRENT.remove();
    }
 }
--- a/web/Dockerfile
+++ b/web/Dockerfile
@@ -5,6 +5,11 @@ COPY package*.json ./
 RUN npm ci --include=dev --ignore-scripts --no-audit --no-fund --no-progress
 COPY . .
 # Neutralise les URLs absolues hardcodees dans les services (dette assumee :
 # une refacto propre passerait par src/environments/*.ts + fileReplacements).
 # Le reverse proxy nginx route /api/ vers core:8080, donc chemin relatif OK.
 RUN find src -type f -name "*.ts" -exec sed -i "s|http://localhost:8080||g" {} +
 RUN npm run build -- --configuration production
 FROM nginx:alpine
--- a/web/src/app/interceptors/language.interceptor.ts
+++ b/web/src/app/interceptors/language.interceptor.ts
@@ -1,18 +0,0 @@
 import { HttpInterceptorFn } from '@angular/common/http';
 import { inject } from '@angular/core';
 import { LanguageService } from '../services/language.service';
 /**
 * Ajoute l'entête `X-User-Language` (langue choisie dans l'UI : `fr`/`en`) à
 * toutes les requêtes HttpClient. Le Core la relaie au Brain, qui rédige alors
 * ses réponses IA dans cette langue.
 *
 * NB : les appels SSE en `fetch()` (chat, imports, notebooks) ne passent PAS par
 * les intercepteurs Angular — ils ajoutent l'entête manuellement de leur côté.
 */
 export const languageInterceptor: HttpInterceptorFn = (req, next) => {
  const language = inject(LanguageService);
  return next(
    req.clone({ setHeaders: { 'X-User-Language': language.current } })
  );
 };
--- a/web/src/app/services/ai-chat.service.ts
+++ b/web/src/app/services/ai-chat.service.ts
@@ -1,7 +1,6 @@
 import { Injectable, inject } from '@angular/core';
 import { Observable } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
 import { LanguageService } from './language.service';
 /**
 * Un message d'une conversation IA (vue front).
@@ -48,7 +47,6 @@ export type NarrativeEntityType = 'arc' | 'chapter' | 'scene' | 'character' | 'n
@Injectable({ providedIn: 'root' })
 export class AiChatService {
  private readonly translate = inject(TranslateService);
  private readonly language = inject(LanguageService);
  private readonly loreEndpoint = '/api/ai/chat/stream';
  private readonly campaignEndpoint = '/api/ai/chat/stream-campaign';
  private readonly sessionEndpoint = '/api/ai/chat/stream-session';
@@ -112,8 +110,7 @@ export class AiChatService {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
-          'Accept': 'text/event-stream',
+          'Accept': 'text/event-stream'
          'X-User-Language': this.language.current
        },
        body: JSON.stringify(body),
        signal: controller.signal
--- a/web/src/app/services/campaign-import.service.ts
+++ b/web/src/app/services/campaign-import.service.ts
@@ -7,7 +7,6 @@ import {
  CampaignImportProposal,
  CampaignImportStreamEvent
 } from './campaign-import.model';
 import { LanguageService } from './language.service';
 /**
 * Service HTTP pour l'import d'un PDF de campagne.
@@ -18,7 +17,7 @@ import { LanguageService } from './language.service';
 */
@Injectable({ providedIn: 'root' })
 export class CampaignImportService {
-  constructor(private http: HttpClient, private translate: TranslateService, private language: LanguageService) {}
+  constructor(private http: HttpClient, private translate: TranslateService) {}
  importStructureStream(campaignId: string, file: File): Observable<CampaignImportStreamEvent> {
    return new Observable<CampaignImportStreamEvent>((subscriber) => {
@@ -28,7 +27,7 @@ export class CampaignImportService {
      fetch(`/api/campaigns/${campaignId}/import-structure/stream`, {
        method: 'POST',
-        headers: { 'Accept': 'text/event-stream', 'X-User-Language': this.language.current },
+        headers: { 'Accept': 'text/event-stream' },
        body: form,
        signal: controller.signal
      })
--- a/web/src/app/services/game-system.service.ts
+++ b/web/src/app/services/game-system.service.ts
@@ -3,7 +3,6 @@ import { HttpClient, HttpParams } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
 import { GameSystem, GameSystemCreate, RulesImportResponse, RulesImportStreamEvent } from './game-system.model';
 import { LanguageService } from './language.service';
 /**
 * Service HTTP pour les GameSystems (systèmes de JDR).
@@ -12,7 +11,7 @@ import { LanguageService } from './language.service';
 export class GameSystemService {
  private apiUrl = '/api/game-systems';
-  constructor(private http: HttpClient, private translate: TranslateService, private language: LanguageService) {}
+  constructor(private http: HttpClient, private translate: TranslateService) {}
  getAll(): Observable<GameSystem[]> {
    return this.http.get<GameSystem[]>(this.apiUrl);
@@ -64,7 +63,7 @@ export class GameSystemService {
      fetch(`${this.apiUrl}/import-rules/stream`, {
        method: 'POST',
-        headers: { 'Accept': 'text/event-stream', 'X-User-Language': this.language.current },
+        headers: { 'Accept': 'text/event-stream' },
        body: form,
        signal: controller.signal
      })
--- a/web/src/app/services/notebook.service.ts
+++ b/web/src/app/services/notebook.service.ts
@@ -3,7 +3,6 @@ import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
 import { Notebook, NotebookArchive, NotebookDetail, NotebookSource, NotebookChatEvent } from './notebook.model';
 import { LanguageService } from './language.service';
 /**
 * Service des notebooks (atelier RAG) : CRUD, upload/indexation de sources,
@@ -13,7 +12,7 @@ import { LanguageService } from './language.service';
 export class NotebookService {
  private readonly apiUrl = '/api/notebooks';
-  constructor(private http: HttpClient, private zone: NgZone, private translate: TranslateService, private language: LanguageService) {}
+  constructor(private http: HttpClient, private zone: NgZone, private translate: TranslateService) {}
  listByCampaign(campaignId: string): Observable<Notebook[]> {
    return this.http.get<Notebook[]>(`${this.apiUrl}/campaign/${campaignId}`);
@@ -74,7 +73,7 @@ export class NotebookService {
        try {
          const response = await fetch(`${this.apiUrl}/${notebookId}/chat/stream`, {
            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Accept': 'text/event-stream', 'X-User-Language': this.language.current },
+            headers: { 'Content-Type': 'application/json', 'Accept': 'text/event-stream' },
            credentials: 'include',
            body: JSON.stringify({
              message, deep,
--- a/web/src/main.ts
+++ b/web/src/main.ts
@@ -9,7 +9,6 @@ import { provideTranslateHttpLoader } from '@ngx-translate/http-loader';
 import { ConfigService } from './app/services/config.service';
 import { LanguageService } from './app/services/language.service';
 import { sessionExpiredInterceptor } from './app/interceptors/session-expired.interceptor';
 import { languageInterceptor } from './app/interceptors/language.interceptor';
 // withPreloading(PreloadAllModules) : une fois l'app initiale rendue, Angular
 // telecharge en arriere-plan tous les chunks lazy-loades. Consequence : la
@@ -19,7 +18,7 @@ import { languageInterceptor } from './app/interceptors/language.interceptor';
 bootstrapApplication(AppComponent, {
  providers: [
    provideZoneChangeDetection(),provideRouter(routes, withPreloading(PreloadAllModules)),
-    provideHttpClient(withInterceptors([sessionExpiredInterceptor, languageInterceptor])),
+    provideHttpClient(withInterceptors([sessionExpiredInterceptor])),
    provideTranslateService({
      loader: provideTranslateHttpLoader({
        prefix: 'assets/i18n/',