Mise à jour v0.15.1

Permet d'utiliser Loremind sans passer par Docker et sans lancer tous les conteneurs
Passage en v0.15.0

.github/workflows/desktop-release.yml

@@ -0,0 +1,120 @@
+name: Desktop installers
+
+# Produit les installeurs de BUREAU (.msi Windows pour l'instant) et les publie
+# en tant qu'assets d'une GitHub Release, sur tag `v*`.
+#
+# Complementaire au pipeline Gitea Actions (.gitea/workflows/release.yml) qui,
+# lui, build et pousse les IMAGES Docker. Ici on est sur GitHub car jpackage et
+# PyInstaller ne savent PAS cross-compiler : le .msi DOIT etre construit sur un
+# runner Windows, et GitHub en fournit gratuitement (windows-latest).
+#
+# Prerequis : le depot Gitea doit etre mirrore vers GitHub (push mirror, tags
+# inclus) pour que le tag declenche ce workflow.
+#
+# Tag stable  vX.Y.Z       -> GitHub Release PUBLIQUE avec le .msi attache.
+# Tag beta    vX.Y.Z-beta* -> AUCUNE publication publique. Le .msi est depose en
+#                             ARTEFACT PRIVE du run (telechargeable seulement par
+#                             toi via l'onglet Actions) ; tu le joins ensuite a un
+#                             post Patreon reserve a un palier. Patreon = la
+#                             barriere d'acces (equivalent du registry prive +
+#                             relais pour les images Docker beta).
+
+on:
+  push:
+    tags: ['v*']
+  # Declenchement MANUEL depuis l'onglet Actions ("Run workflow"). Utile quand un
+  # tag a ete pousse AVANT que le workflow existe sur GitHub (ne se redeclenche
+  # pas tout seul), ou pour rejouer un build. Saisir la version SANS le "v".
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version a builder (doit correspondre a un tag existant, ex: 0.15.0 ou 0.15.0-beta)"
+        required: true
+
+permissions:
+  contents: write   # requis pour creer la Release et y attacher le .msi
+
+jobs:
+  windows:
+    runs-on: windows-latest
+    steps:
+      # En declenchement manuel, on checkout le TAG correspondant a la version
+      # saisie (sinon checkout prendrait la branche par defaut). En push de tag,
+      # on prend la ref poussee.
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('v{0}', inputs.version) || github.ref }}
+
+      # Apporte jpackage (lanceur d'empaquetage natif) dans le PATH.
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '21'
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      # Python 3.12 = meme version que l'image Docker du Brain (coherence runtime).
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      # jpackage genere le MSI via WiX Toolset v3 (candle.exe/light.exe). WiX 4+
+      # ne convient pas (outils renommes). Le paquet choco `wixtoolset` est la
+      # ligne 3.x et s'ajoute au PATH.
+      - name: Install WiX Toolset 3
+        shell: pwsh
+        run: choco install wixtoolset -y --no-progress
+
+      # Version de l'installeur = version du tag (push) OU de l'input (manuel).
+      # Sorties : version (numerique X.Y.Z pour le MSI), tag (vX.Y.Z[-beta]),
+      # isbeta (true/false) — independant du nom de ref (qui est une branche en manuel).
+      - name: Derive version
+        id: ver
+        shell: pwsh
+        run: |
+          if ('${{ github.event_name }}' -eq 'workflow_dispatch') {
+            $raw = '${{ inputs.version }}'
+          } else {
+            $raw = '${{ github.ref_name }}'
+          }
+          $raw = $raw -replace '^v',''            # 0.15.0  ou  0.15.0-beta
+          $num = ($raw -split '-')[0]             # 0.15.0
+          $isbeta = if ($raw -like '*-beta*') { 'true' } else { 'false' }
+          "version=$num"   >> $env:GITHUB_OUTPUT
+          "tag=v$raw"      >> $env:GITHUB_OUTPUT
+          "isbeta=$isbeta" >> $env:GITHUB_OUTPUT
+
+      - name: Build Windows installer
+        shell: pwsh
+        run: .\installers\desktop\build-windows.ps1 -Version ${{ steps.ver.outputs.version }}
+
+      # STABLE uniquement : Release GitHub publique avec le .msi.
+      # tag_name explicite : en declenchement manuel, github.ref est une branche,
+      # donc on cible le tag derive (la release est attachee au bon tag).
+      - name: Publish installer to GitHub Release (stable)
+        if: ${{ steps.ver.outputs.isbeta == 'false' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.ver.outputs.tag }}
+          files: core/target/dist-out/*.msi
+          fail_on_unmatched_files: true
+          generate_release_notes: true
+
+      # BETA uniquement : artefact PRIVE (pas de release publique). A recuperer
+      # via l'onglet Actions puis a joindre a un post Patreon gate par palier.
+      - name: Upload installer as private artifact (beta)
+        if: ${{ steps.ver.outputs.isbeta == 'true' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: loremind-beta-${{ steps.ver.outputs.version }}-msi
+          path: core/target/dist-out/*.msi
+          retention-days: 90
+
+  # TODO (plus tard) : job `linux` sur ubuntu-latest produisant un AppImage
+  # (jpackage --type app-image + appimagetool) + PyInstaller Linux du Brain,
+  # attache a la MEME release. Reutilise la meme matrice / les memes etapes.

.gitignore

@@ -45,6 +45,12 @@ env/
 .coverage
 htmlcov/
 
+# Artefacts du build bureau (cf. installers/desktop)
+.venv-build/
+brain/build/
+brain/dist-embed/
+*.spec
+
 # ============================================================================
 # Angular / Node (Web)
 # ============================================================================
@@ -109,3 +115,11 @@ 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/
+installers/desktop/README.md

README.fr.md

@@ -0,0 +1,68 @@
+# 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.

README.md

@@ -1,66 +1,68 @@
 # LoreMind
 
-> Application web auto-hébergeable pour MJ qui veulent centraliser leur univers, leurs campagnes et leurs personnages — avec un assistant IA contextuel.
+**English** · [Français](README.fr.md)
 
-[![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)
+> A self-hostable web app for game masters who want to centralize their world, campaigns and characters — with a context-aware AI assistant.
 
-## Découvrir LoreMind en vidéo
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](LICENSE)
+[![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)
 
-[![Présentation LoreMind](https://img.youtube.com/vi/llJkmlotbB8/maxresdefault.jpg)](https://www.youtube.com/watch?v=llJkmlotbB8)
+## See LoreMind in action
 
-![Tableau de bord](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
+[![LoreMind overview](https://img.youtube.com/vi/llJkmlotbB8/maxresdefault.jpg)](https://www.youtube.com/watch?v=llJkmlotbB8)
 
-## Ce que ça fait
+![Dashboard](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
 
-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.
+## What it does
+
+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
 
-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.
+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.
 
 ### 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.
+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.
 
 ### 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.
+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.
 
-### Assistant IA
+### AI Assistant
 
-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.
+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.
 
-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.
+The AI runs **locally via [Ollama](https://ollama.com/)** or via **[1min.ai](https://1min.ai/)**. More engines will be supported in the future.
 
 ## Documentation
 
-Toute la documentation (installation, configuration, prise en main) est sur **[loremind-docs.igmlcreation.fr](https://loremind-docs.igmlcreation.fr/)**.
+The full documentation (installation, configuration, getting started) lives at **[loremind-docs.igmlcreation.fr/en](https://loremind-docs.igmlcreation.fr/en/)**.
 
-## Démo en ligne
+## Live demo
 
-Une instance de démonstration est disponible sur **[loremind-demo.igmlcreation.fr](https://loremind-demo.igmlcreation.fr/)**.
+A demo instance is available at **[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)
+A few limitations to be aware of:
+- 10 concurrent users maximum (isolated instances)
+- Sessions limited to 20 minutes before reset
+- The AI part is not included in the demo (requires Ollama or 1min.ai server-side)
 
-## Soutenir le projet
+## Support the project
 
-LoreMind est **et restera gratuit en auto-hébergement**. Le développement avance plus vite avec votre soutien :
+LoreMind is **and will remain free when self-hosted**. Development moves faster with your support:
 
-- **[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
+- **[Patreon](https://www.patreon.com/c/IGMLCreation)** — early access to features, roadmap voting, exclusive devlogs
+- **[Discord](https://discord.gg/cPpFzCjEzQ)** — announcements, support, user feedback
 
-## Licence
+## License
 
-LoreMind est distribué sous licence **[GNU AGPL v3](LICENSE)**.
+LoreMind is distributed under the **[GNU AGPL v3](LICENSE)** 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.
+In practice:
+- You can use it for free, host it, modify it, and redistribute it.
+- 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.
+- The worlds (Lore) and campaigns you create with LoreMind **belong entirely to you** — the license only covers the application's code.

brain/app/api/deps.py

@@ -5,6 +5,7 @@ port (LLM, embeddings, extracteur PDF), en fonction des Settings — modifiables
 à chaud depuis l'écran Paramètres de l'UI. Les routers ne connaissent que les
 ports et les use cases, jamais Ollama/Mistral/etc.
 """
+import logging
 from typing import Annotated
 
 from fastapi import Depends, HTTPException
@@ -29,11 +30,39 @@ from app.infrastructure.onemin_adapter import OneMinAiLLMProvider
 from app.infrastructure.openrouter_adapter import OpenRouterLLMProvider
 from app.infrastructure.pdf_extractor import PyMuPdfTextExtractor
 
+logger = logging.getLogger(__name__)
+
 # Extracteur PDF partagé : la détection OCR (version Tesseract) a un coût
 # (subprocess) qu'on ne veut pas payer à chaque requête → singleton module.
 _PDF_EXTRACTOR = PyMuPdfTextExtractor()
 
 
+def _effective_import_chunk_tokens(settings: Settings) -> int:
+    """Taille de morceau réellement utilisable pour l'import.
+
+    Avec Ollama, le morceau (entrée) ET sa réécriture en sections (sortie ≈ même
+    taille) doivent tenir ensemble dans `num_ctx` — sinon Ollama remplit la fenêtre
+    avec le prompt et la génération s'arrête après quelques tokens (JSON coupé net,
+    morceau perdu). Budget : entrée×~1.3 (les morceaux sont mesurés en tokens
+    cl100k, plus compacts que les tokenizers locaux) + consignes + sortie×~1.4
+    ≤ num_ctx  →  morceau ≤ (num_ctx − 800) / 2.7. On plafonne, avec un log pour
+    rester transparent. Les providers cloud (gros contexte) ne sont pas plafonnés.
+    """
+    requested = settings.import_chunk_tokens
+    if settings.llm_provider != "ollama":
+        return requested
+    cap = max(1000, int((settings.llm_num_ctx - 800) / 2.7))
+    if requested > cap:
+        logger.warning(
+            "Taille de morceau d'import réduite de %s à %s tokens : avec num_ctx=%s, "
+            "un morceau plus gros ne laisserait pas la place à la sortie du modèle "
+            "(génération coupée). Augmentez num_ctx pour utiliser de plus gros morceaux.",
+            requested, cap, settings.llm_num_ctx,
+        )
+        return cap
+    return requested
+
+
 def get_llm_provider(
     settings: Annotated[Settings, Depends(get_settings)],
 ) -> LLMProvider:
@@ -82,8 +111,14 @@ def get_import_rules_use_case(
     settings: Annotated[Settings, Depends(get_settings)],
 ) -> ImportRulesUseCase:
     """Factory du use case d'import de règles PDF (extraction + structuration)."""
+    # Modèle LOCAL → mode segmentation : le LLM ne renvoie que les frontières des
+    # sections (~200 tokens) et le texte original est découpé localement. Réécrire
+    # tout le contenu à ~100 tokens/s prendrait des dizaines de minutes par livre.
+    # Les providers cloud (rapides, grand contexte) gardent la réécriture nettoyée.
     return ImportRulesUseCase(
-        llm=llm, extractor=_PDF_EXTRACTOR, chunk_target_tokens=settings.import_chunk_tokens)
+        llm=llm, extractor=_PDF_EXTRACTOR,
+        chunk_target_tokens=_effective_import_chunk_tokens(settings),
+        segment_only=settings.llm_provider == "ollama")
 
 
 def get_import_campaign_use_case(
@@ -94,7 +129,7 @@ def get_import_campaign_use_case(
     return ImportCampaignUseCase(
         llm=llm,
         extractor=_PDF_EXTRACTOR,
-        chunk_target_tokens=settings.import_chunk_tokens,
+        chunk_target_tokens=_effective_import_chunk_tokens(settings),
         map_concurrency=settings.llm_map_concurrency,
     )
 

brain/app/api/routers/chat.py

@@ -18,6 +18,7 @@ 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
 
@@ -44,6 +45,7 @@ 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.
 
@@ -82,6 +84,7 @@ 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
@@ -109,6 +112,7 @@ 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"

brain/app/api/routers/generation.py

@@ -6,7 +6,9 @@ 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
 
@@ -60,6 +62,7 @@ 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.
 
@@ -76,7 +79,7 @@ async def generate_page(
     )
 
     try:
-        result = await use_case.execute(context)
+        result = await use_case.execute(context, language=language)
     except LLMProviderError as exc:
         raise HTTPException(status_code=502, detail=str(exc)) from exc
 
@@ -101,18 +104,11 @@ 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.
 
@@ -123,7 +119,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_SYSTEM_PROMPT}\n\nConversation :\n{transcript}\n\nTitre :"
+    prompt = f"{title_prompts.title_system_prompt(language)}\n\nConversation :\n{transcript}\n\nTitre :"
     try:
         raw = await llm.generate(prompt)
     except LLMProviderError as exc:
@@ -133,5 +129,5 @@ async def summarize_conversation_title(
     if len(title) > 80:
         title = title[:80].rstrip()
     if not title:
-        title = "Nouvelle conversation"
+        title = title_prompts.TITLE_FALLBACK.get(language, title_prompts.TITLE_FALLBACK["fr"])
     return SummarizeTitleResponseDTO(title=title)

brain/app/api/routers/imports.py

@@ -16,6 +16,7 @@ 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
 
@@ -40,6 +41,7 @@ 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).
@@ -58,7 +60,7 @@ async def import_rules(
         )
 
     try:
-        result = await use_case.execute(content)
+        result = await use_case.execute(content, language=language)
     except PdfExtractionError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
     except LLMProviderError as exc:
@@ -74,6 +76,7 @@ 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.
@@ -93,7 +96,7 @@ async def import_rules_stream(
             yield sse_event("error", {"message": upload_error})
             return
         try:
-            async for ev in use_case.stream(content):
+            async for ev in use_case.stream(content, language=language):
                 event_type = ev.pop("type")
                 yield sse_event(event_type, ev)
         except PdfExtractionError as exc:
@@ -146,6 +149,7 @@ 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("[]"),
@@ -173,7 +177,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):
+            async for token in use_case.stream(content, brief, convo, language=language):
                 yield sse_event("token", {"token": token})
             yield sse_event("done", {})
         except PdfExtractionError as exc:

brain/app/api/routers/notebooks.py

@@ -17,6 +17,7 @@ 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
@@ -77,6 +78,7 @@ 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}."""
@@ -85,7 +87,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):
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k, language=language):
                 if ev["type"] == "token":
                     if ev.get("token"):
                         yield sse_event("token", {"token": ev["token"]})
@@ -107,6 +109,7 @@ 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`."""
@@ -118,7 +121,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):
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context, language=language):
                 ev_type = ev.pop("type")
                 yield sse_event(ev_type, ev)
         except (LLMProviderError, EmbeddingError) as exc:

brain/app/api/routers/tables.py

@@ -8,6 +8,8 @@ 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()
@@ -51,28 +53,15 @@ 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
-    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 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."
-    )
+    prompt = prompts.random_table_prompt(
+        body.description, body.dice_formula, lo, hi, body.context, language)
     try:
         raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
     except LLMProviderError as exc:
@@ -124,17 +113,11 @@ 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."""
-    detail = f" ({body.result_detail.strip()})" if body.result_detail.strip() else ""
-    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."
-    )
+    prompt = prompts.improvise_roll_prompt(
+        body.table_name, body.result_label, body.result_detail, body.context, language)
     try:
         raw = await llm.generate(prompt, temperature=0.8)
     except LLMProviderError as exc:
@@ -167,22 +150,10 @@ 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."""
-    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."
-    )
+    prompt = prompts.item_catalog_prompt(body.description, body.context, language)
     try:
         raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
     except LLMProviderError as exc:

brain/app/application/adapt_campaign.py

@@ -13,6 +13,8 @@ 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
 
@@ -21,27 +23,6 @@ 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."""
@@ -64,6 +45,7 @@ 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)."""
@@ -87,12 +69,12 @@ class AdaptCampaignUseCase:
         )
         # Concaténation (pas .format) : brief/PDF peuvent contenir des { } littéraux.
         system_prompt = (
-            f"{_SYSTEM_PREFIX}\n\n"
+            f"{prompts.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"{_SYSTEM_SUFFIX}\n\n"
+            f"{prompts.system_suffix(language)}\n\n"
             "Tu es en CONVERSATION : à chaque message de l'utilisateur, ajuste, corrige "
             "ou propose des alternatives en gardant tout ce contexte à l'esprit."
         )

brain/app/application/chat.py

@@ -31,6 +31,8 @@ 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
 
 
@@ -40,21 +42,6 @@ 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."""
 
@@ -71,16 +58,18 @@ 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.
+        cette règle à la frontière HTTP. `language` pilote la langue de réponse.
         """
         system_prompt = self._build_system_prompt(
-            lore_context, page_context, campaign_context, narrative_entity, game_system_context, session_context
+            lore_context, page_context, campaign_context, narrative_entity,
+            game_system_context, session_context, language,
         )
         async for token in self._llm.stream_chat(
             messages,
@@ -97,12 +86,14 @@ 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, game_system_context, session_context
+            lore_context, page_context, campaign_context, narrative_entity,
+            game_system_context, session_context, language,
         )
 
     # --- Construction du system prompt --------------------------------------
@@ -115,8 +106,9 @@ class ChatUseCase:
         narrative: NarrativeEntityContext | None,
         game_system: GameSystemContext | None = None,
         session: SessionContext | None = None,
+        language: str = _DEFAULT_LANG,
     ) -> str:
-        sections = [_BASE_SYSTEM]
+        sections = [prompts.base_system(language)]
         if lore is not None:
             sections.append(self._format_lore(lore))
         if campaign is not None:

brain/app/application/generate_page.py

@@ -8,9 +8,13 @@ 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
@@ -18,21 +22,6 @@ from app.domain.ports import LLMProvider, LLMProviderError
 _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."""
 
@@ -42,8 +31,9 @@ class GeneratePageUseCase:
     async def execute(
         self,
         context: PageGenerationContext,
+        language: str = _DEFAULT_LANG,
     ) -> PageGenerationResult:
-        prompt = self._build_prompt(context)
+        prompt = self._build_prompt(context, language)
         raw = await self._llm.generate(
             prompt,
             output_format="json",
@@ -53,7 +43,7 @@ class GeneratePageUseCase:
         return PageGenerationResult(values=values)
 
     @staticmethod
-    def _build_prompt(context: PageGenerationContext) -> str:
+    def _build_prompt(context: PageGenerationContext, language: str = _DEFAULT_LANG) -> str:
         fields_block = "\n".join(f'- "{field}"' for field in context.template_fields)
         lore_desc_line = (
             f"\nDescription de l'univers : {context.lore_description}"
@@ -62,7 +52,7 @@ class GeneratePageUseCase:
         )
 
         return (
-            f"{_SYSTEM_INSTRUCTIONS}\n\n"
+            f"{prompts.system_instructions(language)}\n\n"
             f"Univers : {context.lore_name}"
             f"{lore_desc_line}\n"
             f"Catégorie (dossier) : {context.folder_name}\n"

brain/app/application/import_campaign.py

@@ -14,8 +14,14 @@ import asyncio
 import logging
 
 from app.application.chunking import chunk_text, split_in_half
+from app.application.import_status import (
+    notify_status,
+    reset_status_queue,
+    set_status_queue,
+)
 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
@@ -29,7 +35,12 @@ from app.domain.models import (
     RoomProposal,
     SceneProposal,
 )
-from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
+from app.domain.ports import (
+    LLMGenerationTimeout,
+    LLMProvider,
+    LLMProviderError,
+    PdfTextExtractor,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -37,88 +48,88 @@ 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": []}}."""
-
-# 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."""
+# 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
+# adapters cloud le traduisent en mode JSON natif. Seuls les "name" sont
+# requis : le _TreeMerger tolère déjà tous les champs absents.
+_TREE_SCHEMA: dict = {
+    "type": "object",
+    "properties": {
+        "arcs": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "description": {"type": "string"},
+                    "type": {"type": "string", "enum": ["LINEAR", "HUB"]},
+                    "chapters": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string"},
+                                "description": {"type": "string"},
+                                "scenes": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "name": {"type": "string"},
+                                            "description": {"type": "string"},
+                                            "player_narration": {"type": "string"},
+                                            "gm_notes": {"type": "string"},
+                                            "rooms": {
+                                                "type": "array",
+                                                "items": {
+                                                    "type": "object",
+                                                    "properties": {
+                                                        "name": {"type": "string"},
+                                                        "description": {"type": "string"},
+                                                        "enemies": {"type": "string"},
+                                                        "loot": {"type": "string"},
+                                                    },
+                                                    "required": ["name"],
+                                                    "additionalProperties": False,
+                                                },
+                                            },
+                                        },
+                                        "required": ["name"],
+                                        "additionalProperties": False,
+                                    },
+                                },
+                            },
+                            "required": ["name"],
+                            "additionalProperties": False,
+                        },
+                    },
+                },
+                "required": ["name"],
+                "additionalProperties": False,
+            },
+        },
+        "npcs": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "description": {"type": "string"},
+                },
+                "required": ["name"],
+                "additionalProperties": False,
+            },
+        },
+    },
+    "required": ["arcs"],
+    "additionalProperties": False,
+}
 
 # 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.
@@ -126,28 +137,6 @@ _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]
@@ -427,75 +416,101 @@ class ImportCampaignUseCase:
         skipped = 0
         last_error: str | None = None
         done_count = 0
-        # PARALLÉLISME : les morceaux sont traités par VAGUES de `map_concurrency`
-        # appels simultanés. L'ordre narratif est préservé : la fusion se fait
-        # vague par vague, dans l'ordre du livre.
-        # RÉSILIENCE : un morceau qui échoue (provider saturé, quota, etc.) est
-        # SAUTÉ — on ne perd pas tout l'import pour autant. On n'abandonne que
-        # si AUCUN morceau ne passe (cf. après la boucle).
-        # HEARTBEAT : keep-alive pendant la vague d'appels LLM pour ne jamais
-        # laisser le flux SSE silencieux (sinon le Core coupe sur inactivité).
-        for start in range(0, total, self._map_concurrency):
-            wave = list(enumerate(chunks))[start:start + self._map_concurrency]
-            gathered = asyncio.gather(
-                *(self._map_chunk(c, index=i, total=total, toc_block=toc_block)
-                  for i, c in wave),
-                return_exceptions=True,
-            )
-            results: list | None = None
-            async for kind, payload in with_heartbeat(gathered):
-                if kind == "heartbeat":
-                    yield {"type": "heartbeat", "current": done_count + 1, "total": total}
-                else:
-                    results = payload
-            for (i, _), res in zip(wave, results or []):
-                done_count += 1
-                if isinstance(res, LLMProviderError):
-                    skipped += 1
-                    last_error = str(res)
-                    logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, res)
-                    yield {"type": "chunk_failed", "current": i + 1, "total": total,
-                           "message": str(res)[:300]}
-                elif isinstance(res, BaseException):
-                    raise res  # bug inattendu : ne pas l'avaler en silence
-                else:
-                    merger.add((res or {}).get("arcs") or [])
-                    merger.add_npcs((res or {}).get("npcs") or [])
-                arcs, chapters, scenes = merger.counts()
-                yield {
-                    "type": "progress",
-                    "current": done_count,
-                    "total": total,
-                    "arc_count": arcs,
-                    "chapter_count": chapters,
-                    "scene_count": scenes,
-                    "npc_count": len(merger.npcs()),
-                    "skipped": skipped,
-                }
+        # Canal de statut : les couches profondes (retry LLM, re-découpage) y
+        # publient des messages destinés à l'UI — cf. import_status.notify_status.
+        status_queue: asyncio.Queue = asyncio.Queue()
+        status_token = set_status_queue(status_queue)
+        try:
+            # PARALLÉLISME : les morceaux sont traités par VAGUES de `map_concurrency`
+            # appels simultanés. L'ordre narratif est préservé : la fusion se fait
+            # vague par vague, dans l'ordre du livre.
+            # RÉSILIENCE : un morceau qui échoue (provider saturé, quota, etc.) est
+            # SAUTÉ — on ne perd pas tout l'import pour autant. On n'abandonne que
+            # si AUCUN morceau ne passe (cf. après la boucle).
+            # HEARTBEAT : keep-alive pendant la vague d'appels LLM pour ne jamais
+            # laisser le flux SSE silencieux (sinon le Core coupe sur inactivité).
+            for start in range(0, total, self._map_concurrency):
+                wave = list(enumerate(chunks))[start:start + self._map_concurrency]
+                gathered = asyncio.gather(
+                    *(self._map_chunk(c, index=i, total=total, toc_block=toc_block)
+                      for i, c in wave),
+                    return_exceptions=True,
+                )
+                results: list | None = None
+                async for kind, payload in with_heartbeat(gathered, status_queue=status_queue):
+                    if kind == "heartbeat":
+                        yield {"type": "heartbeat", "current": done_count + 1, "total": total}
+                    elif kind == "status":
+                        yield {"type": "status", "message": payload,
+                               "current": done_count + 1, "total": total}
+                    else:
+                        results = payload
+                for (i, _), res in zip(wave, results or []):
+                    done_count += 1
+                    if isinstance(res, LLMProviderError):
+                        skipped += 1
+                        last_error = str(res)
+                        logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, res)
+                        yield {"type": "chunk_failed", "current": i + 1, "total": total,
+                               "message": str(res)[:300]}
+                    elif isinstance(res, BaseException):
+                        raise res  # bug inattendu : ne pas l'avaler en silence
+                    else:
+                        merger.add((res or {}).get("arcs") or [])
+                        merger.add_npcs((res or {}).get("npcs") or [])
+                    arcs, chapters, scenes = merger.counts()
+                    yield {
+                        "type": "progress",
+                        "current": done_count,
+                        "total": total,
+                        "arc_count": arcs,
+                        "chapter_count": chapters,
+                        "scene_count": scenes,
+                        "npc_count": len(merger.npcs()),
+                        "skipped": skipped,
+                    }
 
-        if total > 0 and skipped == total:
-            # Tout a échoué : "done" vide serait trompeur → erreur explicite.
-            yield {"type": "error",
-                   "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
-                              f"Dernier message : {last_error or 'inconnu'}"}
-            return
+            if total > 0 and skipped == total:
+                # Tout a échoué : "done" vide serait trompeur → erreur explicite.
+                yield {"type": "error",
+                       "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
+                                  f"Dernier message : {last_error or 'inconnu'}"}
+                return
 
-        # Consolidation finale : fusion des quasi-doublons inter-morceaux
-        # (best-effort, voir _consolidate). Inutile sur un import mono-morceau.
-        if total > 1:
-            yield {"type": "consolidating", "total": total}
-            async for kind, _ in with_heartbeat(self._consolidate(merger)):
-                if kind == "heartbeat":
-                    yield {"type": "heartbeat", "current": total, "total": total}
+            if total > 0 and merger.counts()[0] == 0 and not merger.npcs():
+                # Le texte a été extrait mais le modèle n'a produit AUCUNE structure
+                # exploitable : sans ce signal, l'UI reçoit un `done` vide et
+                # l'utilisateur conclut à tort que le PDF est illisible.
+                yield {"type": "error",
+                       "message": "Le texte du PDF a été extrait, mais le modèle n'a produit "
+                                  "aucune structure exploitable (réponses JSON vides ou coupées). "
+                                  "Réduisez la taille des morceaux d'import, augmentez la fenêtre "
+                                  "de contexte (num_ctx) ou essayez un autre modèle."}
+                return
 
-        yield {
-            "type": "done",
-            "arcs": _serialize_arcs(merger.result()),
-            "npcs": [{"name": n.name, "description": n.description} for n in merger.npcs()],
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-            "skipped": skipped,
-        }
+            # Consolidation finale : fusion des quasi-doublons inter-morceaux
+            # (best-effort, voir _consolidate). Inutile sur un import mono-morceau.
+            if total > 1:
+                yield {"type": "consolidating", "total": total}
+                async for kind, payload in with_heartbeat(
+                    self._consolidate(merger), status_queue=status_queue
+                ):
+                    if kind == "heartbeat":
+                        yield {"type": "heartbeat", "current": total, "total": total}
+                    elif kind == "status":
+                        yield {"type": "status", "message": payload,
+                               "current": total, "total": total}
+
+            yield {
+                "type": "done",
+                "arcs": _serialize_arcs(merger.result()),
+                "npcs": [{"name": n.name, "description": n.description} for n in merger.npcs()],
+                "page_count": doc.page_count,
+                "ocr_page_count": doc.ocr_page_count,
+                "skipped": skipped,
+            }
+        finally:
+            reset_status_queue(status_token)
 
     # --- Consolidation finale (fusion des quasi-doublons) ---------------------
 
@@ -512,7 +527,7 @@ class ImportCampaignUseCase:
         skeleton = merger.skeleton_text()
         try:
             raw = await generate_with_retry(
-                self._llm, _CONSOLIDATE_PROMPT.format(skeleton=skeleton),
+                self._llm, prompts.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é.
@@ -550,15 +565,36 @@ 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 = _TOC_BLOCK.format(toc=toc_block) if toc_block else ""
+        toc_section = prompts.TOC_BLOCK.format(toc=toc_block) if toc_block else ""
         prompt = (
-            _MAP_SYSTEM.format(default_arc=_DEFAULT_ARC_NAME)
+            prompts.MAP_SYSTEM.format(default_arc=prompts.DEFAULT_ARC_NAME)
             + toc_section
             + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
             "Renvoie maintenant le JSON de l'arborescence."
         )
-        raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
+        try:
+            raw = await generate_with_retry(
+                self._llm, prompt, output_format=_TREE_SCHEMA, temperature=_TEMPERATURE)
+        except LLMGenerationTimeout:
+            # Génération trop lente pour la taille demandée (fréquent en local /
+            # tier gratuit) : même remède que la troncature, deux moitiés →
+            # sortie 2× plus courte. Re-lever si plus découpable.
+            if depth >= _MAX_SPLIT_DEPTH:
+                raise
+            left, right = split_in_half(text)
+            if not left or not right:
+                raise
+            logger.info(
+                "Morceau %s : timeout de génération → re-découpage en 2 moitiés (niveau %s).",
+                index, depth + 1)
+            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_payload(
+                left, index=index, total=total, depth=depth + 1, toc_block=toc_block)
+            b = await self._extract_payload(
+                right, index=index, total=total, depth=depth + 1, toc_block=toc_block)
+            return {"arcs": a["arcs"] + b["arcs"], "npcs": a["npcs"] + b["npcs"]}
         payload, truncated = self._parse_payload(raw, index=index)
 
         if truncated and depth < _MAX_SPLIT_DEPTH:
@@ -567,6 +603,9 @@ class ImportCampaignUseCase:
                 logger.info(
                     "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
                     index, depth + 1)
+                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_payload(
                     left, index=index, total=total, depth=depth + 1, toc_block=toc_block)
                 b = await self._extract_payload(

brain/app/application/import_rules.py

@@ -13,11 +13,21 @@ Ne dépend que des abstractions du domaine (ports LLMProvider + PdfTextExtractor
 from __future__ import annotations
 
 import logging
+import re
+
+import asyncio
 
 from app.application.chunking import CHUNK_TARGET_TOKENS, chunk_text, split_in_half
+from app.application.import_status import (
+    notify_status,
+    reset_status_queue,
+    set_status_queue,
+)
 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
@@ -25,7 +35,12 @@ from app.application.streaming import with_heartbeat
 # 1-2 niveaux suffisent en pratique, le reste est un garde-fou).
 _MAX_SPLIT_DEPTH = 3
 from app.domain.models import RulesImportResult
-from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
+from app.domain.ports import (
+    LLMGenerationTimeout,
+    LLMProvider,
+    LLMProviderError,
+    PdfTextExtractor,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -34,38 +49,45 @@ logger = logging.getLogger(__name__)
 # Plus la valeur est haute, plus le modèle "brode" (invente du contenu absent).
 _TEMPERATURE = 0.1
 
-# 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",
-]
+# Schéma de la sortie attendue : objet PLAT {titre: markdown}. Passé tel quel à
+# Ollama (structured outputs : la grammaire interdit physiquement les objets
+# imbriqués, les clés "thought" à valeur non-string, le bavardage hors JSON…
+# indispensable pour les petits modèles locaux qui ne suivent pas les consignes).
+# Les adapters cloud le traduisent en mode JSON natif (json_object).
+_SECTIONS_SCHEMA: dict = {
+    "type": "object",
+    "additionalProperties": {"type": "string"},
+}
 
-_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).
+# --- 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
+# en cascade. Ici le modèle ne renvoie que les FRONTIÈRES des sections (titre +
+# premiers mots exacts) — ~200 tokens quel que soit le morceau — et c'est NOUS
+# qui découpons le texte original. ~50× plus rapide, fidélité parfaite du
+# contenu (texte source intact), plus de troncature possible.
 
-Ta tâche : répartir le contenu de cet extrait dans des SECTIONS THÉMATIQUES.
-
-Règles impératives :
-- Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
-- Les CLÉS sont des titres de section (texte court). Les VALEURS sont le contenu de la règle en markdown.
-- 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)."""
+# 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 = {
+    "type": "object",
+    "properties": {
+        "sections": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "titre": {"type": "string"},
+                    "debut": {"type": "string"},
+                },
+                "required": ["titre", "debut"],
+                "additionalProperties": False,
+            },
+        },
+    },
+    "required": ["sections"],
+    "additionalProperties": False,
+}
 
 
 class _SectionMerger:
@@ -102,6 +124,84 @@ class _SectionMerger:
         return {title: "\n\n".join(parts) for title, parts in self._merged.items()}
 
 
+# Clés "méta" que certains modèles glissent dans le JSON (fuite de raisonnement,
+# schéma title/content inventé…) : jamais des titres de section voulus.
+_META_KEYS = frozenset({
+    "thought", "thoughts", "thinking", "reasoning", "raisonnement",
+    "comment", "commentaire", "commentaires", "note", "notes", "explanation",
+})
+
+
+def _normalize_sections(parsed: dict) -> dict:
+    """Ramène les formes déviantes courantes au format attendu {titre: contenu}.
+
+    Observé sur les petits modèles locaux (gemma 12b) malgré les consignes :
+      - enveloppe {"sections": {...}} ou {"règles": {...}} autour du vrai contenu ;
+      - schéma inventé {"title": "...", "content": "...", "thought": "..."} →
+        une seule section dont le titre est la valeur de "title" ;
+      - clés méta ("thought", "notes"…) mêlées aux vraies sections → retirées.
+    """
+    by_lower = {str(k).strip().lower(): k for k in parsed}
+    # Enveloppe : un unique conteneur connu dont la valeur est l'objet attendu.
+    if len(parsed) == 1:
+        only_key, only_val = next(iter(parsed.items()))
+        if (isinstance(only_val, dict)
+                and str(only_key).strip().lower() in {"sections", "règles", "regles", "rules"}):
+            return _normalize_sections(only_val)
+    # Schéma {"title": ..., "content": ...} : le titre est une VALEUR, pas une clé.
+    if "title" in by_lower and "content" in by_lower:
+        title = str(parsed[by_lower["title"]]).strip()
+        content = parsed[by_lower["content"]]
+        if title and not isinstance(content, dict):
+            return {title: content}
+    return {k: v for k, v in parsed.items()
+            if str(k).strip().lower() not in _META_KEYS}
+
+
+def _coerce_markdown(value: object) -> str:
+    """Convertit une valeur de section renvoyée par le LLM en markdown plat.
+
+    Malgré la consigne « valeurs = markdown », certains modèles nichent des
+    sous-sections ({titre: {sous-titre: contenu}}) ou des listes. Un `str(v)`
+    naïf produirait du repr Python ({'k': 'v'}) ; on aplatit récursivement à la
+    place pour ne perdre aucun contenu.
+    """
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        parts = []
+        for k, v in value.items():
+            content = _coerce_markdown(v)
+            # Clé = sous-titre (cas normal) ; si la "valeur" est vide, la clé
+            # elle-même porte le contenu (dérive observée sur certains modèles).
+            parts.append(f"{k}\n\n{content}".strip() if content else str(k))
+        return "\n\n".join(parts)
+    if isinstance(value, list):
+        return "\n\n".join(_coerce_markdown(v) for v in value)
+    return "" if value is None else str(value)
+
+
+def _find_anchor(text: str, anchor: str, start: int) -> int | None:
+    """Position de `anchor` dans `text` à partir de `start`, ou None.
+
+    Le modèle recopie les premiers mots d'un passage, mais le texte extrait du
+    PDF contient des sauts de ligne/espaces multiples au même endroit, et le
+    modèle normalise parfois la casse. Trois passes, de la plus stricte à la
+    plus tolérante : exacte → espaces≈\\s+ → idem insensible à la casse."""
+    pos = text.find(anchor, start)
+    if pos != -1:
+        return pos
+    words = anchor.split()
+    if not words:
+        return None
+    pattern = r"\s+".join(re.escape(w) for w in words)
+    match = re.compile(pattern).search(text, start)
+    if match:
+        return match.start()
+    match = re.compile(pattern, re.IGNORECASE).search(text, start)
+    return match.start() if match else None
+
+
 def _combine_sections(a: dict[str, str], b: dict[str, str]) -> dict[str, str]:
     """Fusionne deux dicts de sections (issus des 2 moitiés d'un morceau re-découpé).
 
@@ -128,12 +228,18 @@ class ImportRulesUseCase:
         llm: LLMProvider,
         extractor: PdfTextExtractor,
         chunk_target_tokens: int = CHUNK_TARGET_TOKENS,
+        segment_only: bool = False,
     ) -> None:
+        """`segment_only=True` (modèles locaux) : le LLM ne renvoie que les
+        frontières des sections (titre + premiers mots) et le texte original est
+        découpé localement — sortie minuscule, pas de réécriture. False (cloud) :
+        le LLM réécrit le contenu en sections markdown nettoyées."""
         self._llm = llm
         self._extractor = extractor
         self._chunk_target_tokens = chunk_target_tokens
+        self._segment_only = segment_only
 
-    async def execute(self, pdf_bytes: bytes) -> RulesImportResult:
+    async def execute(self, pdf_bytes: bytes, language: str = _DEFAULT_LANG) -> 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)
@@ -143,14 +249,14 @@ class ImportRulesUseCase:
         )
         merger = _SectionMerger()
         for i, chunk in enumerate(chunks):
-            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
+            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks), language=language))
         return RulesImportResult(
             sections=merger.result(),
             page_count=doc.page_count,
             ocr_page_count=doc.ocr_page_count,
         )
 
-    async def stream(self, pdf_bytes: bytes):
+    async def stream(self, pdf_bytes: bytes, language: str = _DEFAULT_LANG):
         """Variante streamée : yield des évènements d'avancement au fil de l'eau.
 
         Évènements (dicts) : {"type": "extracting"}, puis
@@ -179,35 +285,46 @@ class ImportRulesUseCase:
         merger = _SectionMerger()
         skipped = 0
         last_error: str | None = None
-        for i, chunk in enumerate(chunks):
-            # RÉSILIENCE : un morceau qui échoue est SAUTÉ, l'import continue.
-            # Abandon seulement si AUCUN morceau ne passe (cf. après la boucle).
-            # HEARTBEAT : on émet des keep-alive pendant l'appel LLM (long sur un
-            # provider lent) pour que le flux SSE ne soit jamais coupé par le Core.
-            new_titles: list[str] = []
-            try:
-                sections: dict[str, str] | None = None
-                async for kind, payload in with_heartbeat(
-                    self._map_chunk(chunk, index=i, total=total)
-                ):
-                    if kind == "heartbeat":
-                        yield {"type": "heartbeat", "current": i + 1, "total": total}
-                    else:
-                        sections = payload
-                new_titles = merger.add(sections or {})
-            except LLMProviderError as exc:
-                skipped += 1
-                last_error = str(exc)
-                logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
-                yield {"type": "chunk_failed", "current": i + 1, "total": total,
-                       "message": str(exc)[:300]}
-            yield {
-                "type": "progress",
-                "current": i + 1,
-                "total": total,
-                "new_sections": new_titles,
-                "skipped": skipped,
-            }
+        # Canal de statut : les couches profondes (retry LLM, re-découpage) y
+        # publient des messages destinés à l'UI — cf. import_status.notify_status.
+        status_queue: asyncio.Queue = asyncio.Queue()
+        status_token = set_status_queue(status_queue)
+        try:
+            for i, chunk in enumerate(chunks):
+                # RÉSILIENCE : un morceau qui échoue est SAUTÉ, l'import continue.
+                # Abandon seulement si AUCUN morceau ne passe (cf. après la boucle).
+                # HEARTBEAT : on émet des keep-alive pendant l'appel LLM (long sur un
+                # provider lent) pour que le flux SSE ne soit jamais coupé par le Core.
+                new_titles: list[str] = []
+                try:
+                    sections: dict[str, str] | None = None
+                    async for kind, payload in with_heartbeat(
+                        self._map_chunk(chunk, index=i, total=total, language=language),
+                        status_queue=status_queue,
+                    ):
+                        if kind == "heartbeat":
+                            yield {"type": "heartbeat", "current": i + 1, "total": total}
+                        elif kind == "status":
+                            yield {"type": "status", "message": payload,
+                                   "current": i + 1, "total": total}
+                        else:
+                            sections = payload
+                    new_titles = merger.add(sections or {})
+                except LLMProviderError as exc:
+                    skipped += 1
+                    last_error = str(exc)
+                    logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
+                    yield {"type": "chunk_failed", "current": i + 1, "total": total,
+                           "message": str(exc)[:300]}
+                yield {
+                    "type": "progress",
+                    "current": i + 1,
+                    "total": total,
+                    "new_sections": new_titles,
+                    "skipped": skipped,
+                }
+        finally:
+            reset_status_queue(status_token)
 
         if total > 0 and skipped == total:
             yield {"type": "error",
@@ -215,9 +332,21 @@ class ImportRulesUseCase:
                               f"Dernier message : {last_error or 'inconnu'}"}
             return
 
+        sections = merger.result()
+        if total > 0 and not sections:
+            # Le texte a bien été extrait mais AUCUN morceau n'a produit de JSON
+            # exploitable (sorties coupées/illisibles). Sans ce signal, l'UI reçoit
+            # un `done` vide et l'utilisateur conclut à tort que le PDF est illisible.
+            yield {"type": "error",
+                   "message": "Le texte du PDF a été extrait, mais le modèle n'a produit "
+                              "aucune section exploitable (réponses JSON vides ou coupées). "
+                              "Réduisez la taille des morceaux d'import, augmentez la fenêtre "
+                              "de contexte (num_ctx) ou essayez un autre modèle."}
+            return
+
         yield {
             "type": "done",
-            "sections": merger.result(),
+            "sections": sections,
             "page_count": doc.page_count,
             "ocr_page_count": doc.ocr_page_count,
             "skipped": skipped,
@@ -225,25 +354,53 @@ class ImportRulesUseCase:
 
     # --- MAP : un morceau → sections -----------------------------------------
 
-    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> dict[str, str]:
-        return await self._extract_sections(chunk, index=index, total=total, depth=0)
+    async def _map_chunk(self, chunk: str, *, index: int, total: int,
+                         language: str = _DEFAULT_LANG) -> dict[str, str]:
+        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
+        schema = _ANCHORS_SCHEMA if self._segment_only else _SECTIONS_SCHEMA
         prompt = (
-            _MAP_SYSTEM.format(
-                canonical="\n".join(f"  - {s}" for s in _CANONICAL_SECTIONS)
+            system.format(
+                canonical="\n".join(f"  - {s}" for s in prompts.CANONICAL_SECTIONS),
+                language_name=language_name(language),
             )
             + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
             "Renvoie maintenant le JSON des sections."
         )
-        raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-        sections, truncated = self._parse_sections(raw, index=index)
+        try:
+            raw = await generate_with_retry(
+                self._llm, prompt, output_format=schema, temperature=_TEMPERATURE)
+        except LLMGenerationTimeout:
+            # Le modèle générait mais trop lentement pour réécrire tout le morceau
+            # dans le temps imparti (fréquent sur tier gratuit + gros morceaux).
+            # Même remède que la troncature : deux moitiés → sortie 2× plus courte.
+            if depth >= _MAX_SPLIT_DEPTH:
+                raise
+            left, right = split_in_half(text)
+            if not left or not right:
+                raise
+            logger.info(
+                "Morceau %s : timeout de génération → re-découpage en 2 moitiés (niveau %s).",
+                index, depth + 1)
+            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)
+            b = await self._extract_sections(right, index=index, total=total, depth=depth + 1, language=language)
+            return _combine_sections(a, b)
+        if self._segment_only:
+            sections, truncated = self._parse_anchors(raw, text, index=index)
+        else:
+            sections, truncated = self._parse_sections(raw, index=index)
 
         if truncated and depth < _MAX_SPLIT_DEPTH:
             left, right = split_in_half(text)
@@ -251,14 +408,79 @@ class ImportRulesUseCase:
                 logger.info(
                     "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
                     index, depth + 1)
-                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)
+                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)
+                b = await self._extract_sections(right, index=index, total=total, depth=depth + 1, language=language)
                 return _combine_sections(a, b)
         if truncated:
             logger.warning(
                 "Morceau %s : sortie tronquée, profondeur max atteinte — partiel conservé.", index)
         return sections
 
+    @staticmethod
+    def _parse_anchors(raw: str, text: str, *, index: int) -> tuple[dict[str, str], bool]:
+        """Mode segmentation : réponse {"sections": [{titre, debut}, …]} → on localise
+        chaque `debut` dans le texte ORIGINAL et on découpe entre les ancres.
+
+        Une ancre introuvable est abandonnée (son contenu reste dans la section
+        précédente — aucun texte n'est perdu). Le texte avant la première ancre
+        trouvée est rattaché à la première section (le prompt demande au modèle de
+        faire démarrer la première entrée aux premiers mots de l'extrait)."""
+        parsed, recovered = load_json_object(raw)
+        if parsed is None:
+            truncated = looks_like_truncated_json(raw)
+            if not truncated:
+                logger.warning(
+                    "Morceau %s : aucun objet JSON exploitable (segmentation), ignoré. "
+                    "Début de la réponse du modèle : %r",
+                    index, (raw or "").strip()[:300] or "(réponse VIDE)")
+            return {}, truncated
+        entries = parsed.get("sections") if isinstance(parsed, dict) else None
+        if not isinstance(entries, list):
+            logger.warning("Morceau %s : pas de liste 'sections' exploitable, ignoré.", index)
+            return {}, False
+
+        # Localisation séquentielle : chaque ancre est cherchée APRÈS la précédente
+        # (préserve l'ordre du texte, évite qu'une phrase répétée matche trop tôt).
+        located: list[tuple[str, int]] = []
+        cursor = 0
+        dropped = 0
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            title = str(entry.get("titre") or "").strip()
+            anchor = str(entry.get("debut") or "").strip()
+            if not title or not anchor:
+                continue
+            pos = _find_anchor(text, anchor, cursor)
+            if pos is None:
+                dropped += 1
+                continue
+            located.append((title, pos))
+            cursor = pos + 1
+        if dropped:
+            logger.info(
+                "Morceau %s : %s ancre(s) de section introuvable(s) — contenu rattaché "
+                "à la section précédente.", index, dropped)
+        if not located:
+            return {}, False
+
+        # Découpe entre ancres ; le préambule éventuel rejoint la première section.
+        located[0] = (located[0][0], 0)
+        sections: dict[str, str] = {}
+        for i, (title, start) in enumerate(located):
+            end = located[i + 1][1] if i + 1 < len(located) else len(text)
+            content = text[start:end].strip()
+            if not content:
+                continue
+            if title in sections:
+                sections[title] = f"{sections[title]}\n\n{content}"
+            else:
+                sections[title] = content
+        return sections, recovered
+
     @staticmethod
     def _parse_sections(raw: str, *, index: int) -> tuple[dict[str, str], bool]:
         """Parse robuste → (sections, tronqué). `tronqué`=True si récupération partielle."""
@@ -276,4 +498,5 @@ class ImportRulesUseCase:
         if not isinstance(parsed, dict):
             logger.warning("Morceau %s : le LLM n'a pas renvoyé un objet, ignoré.", index)
             return {}, False
-        return {str(k): str(v) for k, v in parsed.items()}, recovered
+        normalized = _normalize_sections(parsed)
+        return {str(k): _coerce_markdown(v) for k, v in normalized.items()}, recovered

brain/app/application/import_status.py

@@ -0,0 +1,39 @@
+"""Canal de statut des imports : remonte à l'UI ce qui n'existait qu'en logs.
+
+Problème résolu : pendant un import, les événements internes (retry parce que
+le fournisseur IA est saturé, re-découpage d'un morceau trop gros…) n'étaient
+visibles que dans les logs Docker. L'utilisateur voyait une barre de
+progression figée sans explication.
+
+Mécanisme : le flux d'import (use case `stream()`) installe une Queue dans une
+ContextVar ; les couches profondes (retry LLM, re-découpage) y publient des
+messages via `notify_status()` sans connaître le flux SSE. La ContextVar est
+propagée automatiquement aux tâches asyncio enfants → chaque import concurrent
+a SA queue, sans couplage ni paramètre à faire transiter partout.
+"""
+from __future__ import annotations
+
+import asyncio
+from contextvars import ContextVar, Token
+
+_QUEUE: ContextVar[asyncio.Queue | None] = ContextVar("import_status_queue", default=None)
+
+
+def set_status_queue(queue: asyncio.Queue | None) -> Token:
+    """Installe la queue de statut pour le contexte courant (et ses tâches filles).
+
+    Renvoie le token à passer à `reset_status_queue` en fin d'import.
+    """
+    return _QUEUE.set(queue)
+
+
+def reset_status_queue(token: Token) -> None:
+    _QUEUE.reset(token)
+
+
+def notify_status(message: str) -> None:
+    """Publie un message de statut si un import écoute. No-op sinon (appels
+    LLM hors import : chat, génération de page…)."""
+    queue = _QUEUE.get()
+    if queue is not None:
+        queue.put_nowait(message)

brain/app/application/llm_json.py

@@ -38,13 +38,16 @@ def load_json_object(raw: str) -> tuple[object | None, bool]:
     obj = extract_json_object(raw)
     if obj is not None:
         try:
-            return json.loads(obj), False
+            # strict=False : tolère les caractères de contrôle BRUTS (retours à la
+            # ligne non échappés…) dans les chaînes — erreur fréquente des LLM hors
+            # mode JSON natif, qui invalidait toute la réponse.
+            return json.loads(obj, strict=False), False
         except json.JSONDecodeError:
             pass
     repaired = repair_truncated_json(raw)
     if repaired is not None:
         try:
-            return json.loads(repaired), True
+            return json.loads(repaired, strict=False), True
         except json.JSONDecodeError:
             pass
     return None, False
@@ -54,12 +57,20 @@ def looks_like_truncated_json(raw: str) -> bool:
     """La sortie ressemble-t-elle à un JSON COUPÉ (accolades/crochets non refermés)
     plutôt qu'à de la prose ? Sert à déclencher un re-découpage même quand RIEN n'a
     pu être récupéré (cas où le 1er contenu est si long qu'il est coupé avant toute
-    sous-structure complète). On exige un contenu substantiel pour éviter les
-    faux positifs sur une courte réponse non-JSON."""
-    s = (raw or "").strip()
-    if "{" not in s or len(s) < 100:
+    sous-structure complète).
+
+    Une réponse qui COMMENCE par `{` est jugée sur le seul équilibre des accolades,
+    même très courte : en mode JSON un `{"` de 2 caractères est une génération
+    interrompue net (contexte plein, plafond de sortie), pas de la prose — c'est le
+    signal de re-découpage. Pour le reste (prose contenant des accolades), on exige
+    un contenu substantiel pour éviter les faux positifs."""
+    s = _strip_reasoning(raw or "").strip()
+    if "{" not in s:
         return False
-    return s.count("{") > s.count("}") or s.count("[") > s.count("]")
+    unbalanced = s.count("{") > s.count("}") or s.count("[") > s.count("]")
+    if s.startswith("{"):
+        return unbalanced
+    return len(s) >= 100 and unbalanced
 
 
 def extract_json_object(raw: str) -> str | None:

brain/app/application/llm_retry.py

@@ -14,7 +14,8 @@ import asyncio
 import logging
 import re
 
-from app.domain.ports import LLMProvider, LLMProviderError
+from app.application.import_status import notify_status
+from app.domain.ports import LLMGenerationTimeout, LLMProvider, LLMProviderError
 
 logger = logging.getLogger(__name__)
 
@@ -60,7 +61,7 @@ async def generate_with_retry(
     llm: LLMProvider,
     prompt: str,
     *,
-    output_format: str | None = None,
+    output_format: str | dict | None = None,
     temperature: float | None = None,
 ) -> str:
     """Comme `llm.generate`, mais réessaie les erreurs transitoires (backoff).
@@ -74,6 +75,12 @@ async def generate_with_retry(
     for attempt in range(_ATTEMPTS):
         try:
             return await llm.generate(prompt, output_format=output_format, temperature=temperature)
+        except LLMGenerationTimeout:
+            # Timeout de DÉBIT (génération trop lente pour la sortie demandée) :
+            # rejouer le même prompt re-timeoutera à l'identique — on a déjà perdu
+            # `timeout` secondes. On remonte tout de suite : l'appelant (import)
+            # sait re-découper le morceau en deux pour réduire la sortie.
+            raise
         except LLMProviderError as exc:
             last_error = exc
             # Quota JOURNALIER épuisé : inutile d'insister, on remonte tout de suite
@@ -97,6 +104,14 @@ async def generate_with_retry(
                     attempt + 1, _ATTEMPTS, " [rate limit]" if _is_rate_limit(exc) else "",
                     exc, wait,
                 )
+                # Remonte aussi l'info à l'UI (flux d'import) : sans ça l'utilisateur
+                # voit une barre figée sans savoir que le fournisseur est saturé.
+                notify_status(
+                    ("Fournisseur IA saturé (rate limit)" if _is_rate_limit(exc)
+                     else "Appel IA échoué")
+                    + f" — tentative {attempt + 1}/{_ATTEMPTS}, nouvel essai dans {int(wait)}s. "
+                    + str(exc)[:160]
+                )
                 await asyncio.sleep(wait)
     assert last_error is not None
     raise last_error

brain/app/application/notebook_chat.py

@@ -9,54 +9,13 @@ 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, 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 ». N'en mets que si
-c'est pertinent et explicitement souhaité. Formats acceptés :
-
-```loremind-action
-{{"type": "npc", "name": "Nom", "description": "Fiche en quelques phrases."}}
-```
-```loremind-action
-{{"type": "scene", "name": "Nom", "description": "Résumé", "content": "Déroulé détaillé."}}
-```
-```loremind-action
-{{"type": "chapter", "name": "Nom", "description": "Résumé du chapitre."}}
-```
-```loremind-action
-{{"type": "arc", "name": "Nom", "description": "Résumé", "arcType": "LINEAR"}}
-```
-```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__(
@@ -73,6 +32,7 @@ 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}."""
@@ -107,8 +67,9 @@ 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 = _SYSTEM_PROMPT.format(
-            context_block=context_block, sources_block=sources_block)
+        system_prompt = prompts.CHAT_SYSTEM.format(
+            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}
 

brain/app/application/notebook_deep.py

@@ -20,7 +20,9 @@ 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
@@ -36,15 +38,6 @@ _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.
@@ -52,38 +45,6 @@ _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__(
@@ -109,6 +70,7 @@ 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é.)
@@ -175,7 +137,9 @@ class NotebookDeepUseCase:
             f"--- TA CAMPAGNE (structure, PNJ, univers) ---\n{context.strip()}\n--- FIN CAMPAGNE ---\n\n"
             if context.strip() else ""
         )
-        system_prompt = _REDUCE_SYSTEM.format(context_block=context_block, notes_block=notes_block)
+        system_prompt = prompts.REDUCE_SYSTEM.format(
+            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)]
@@ -251,7 +215,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, _SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
+            self._llm, prompts.SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
         return (raw or "").strip()
 
     async def _map_batch(self, question: str, batch: list[dict]) -> str:
@@ -260,7 +224,7 @@ class NotebookDeepUseCase:
             f"(p. {c['page']}) {c['text'].strip()}" if c.get("page") else c["text"].strip()
             for c in batch
         )
-        prompt = _MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
+        prompt = prompts.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:

brain/app/application/prompts/__init__.py

@@ -0,0 +1,12 @@
+"""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`.
+"""

brain/app/application/prompts/adapt_campaign.py

@@ -0,0 +1,26 @@
+"""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."
+    )

brain/app/application/prompts/chat.py

@@ -0,0 +1,23 @@
+"""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")."""

brain/app/application/prompts/conversation_title.py

@@ -0,0 +1,15 @@
+"""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')."
+    )

brain/app/application/prompts/generate_page.py

@@ -0,0 +1,19 @@
+"""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."""

brain/app/application/prompts/import_campaign.py

@@ -0,0 +1,100 @@
+"""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": []}}"""

brain/app/application/prompts/import_rules.py

@@ -0,0 +1,62 @@
+"""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": []}}."""

brain/app/application/prompts/notebook.py

@@ -0,0 +1,134 @@
+"""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}."""

brain/app/application/prompts/query_rewrite.py

@@ -0,0 +1,20 @@
+"""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 :"""

brain/app/application/prompts/rerank.py

@@ -0,0 +1,14 @@
+"""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."""

brain/app/application/prompts/tables.py

@@ -0,0 +1,60 @@
+"""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."
+    )

brain/app/application/query_rewrite.py

@@ -11,6 +11,7 @@ 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__)
@@ -23,22 +24,6 @@ _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.
@@ -56,7 +41,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(
-            _REWRITE_PROMPT.format(conversation=conversation), temperature=0.0)
+            prompts.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

brain/app/application/rerank.py

@@ -11,6 +11,7 @@ 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__)
 
@@ -23,16 +24,6 @@ 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."""
@@ -52,7 +43,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 = _RERANK_PROMPT.format(
+    prompt = prompts.RERANK_PROMPT.format(
         question=question, passages=numbered, count=len(passages))
     try:
         raw = await llm.generate(prompt, temperature=0.0)

brain/app/application/streaming.py

@@ -25,21 +25,43 @@ async def with_heartbeat(
     coro: Awaitable[Any],
     *,
     interval: float = HEARTBEAT_INTERVAL_SECONDS,
+    status_queue: "asyncio.Queue | None" = None,
 ) -> AsyncIterator[tuple[str, Any]]:
     """Exécute `coro` en émettant ('heartbeat', None) toutes les `interval`s tant
     qu'elle n'est pas terminée, puis ('result', valeur).
 
+    Si `status_queue` est fournie, les messages qui y sont publiés pendant
+    l'exécution (cf. import_status.notify_status : retry LLM, re-découpage…)
+    sont émis AU FIL DE L'EAU sous forme ('status', message) — c'est ce qui
+    permet à l'UI d'expliquer une attente au lieu d'une barre figée.
+
     L'exception éventuelle de `coro` est propagée (re-levée par `task.result()`),
     donc l'appelant peut l'attraper normalement. Si l'itération est abandonnée
     (client déconnecté), la tâche sous-jacente est annulée.
     """
     task: asyncio.Task = asyncio.ensure_future(coro)
+    getter: asyncio.Task | None = None
     try:
         while not task.done():
-            done, _ = await asyncio.wait({task}, timeout=interval)
+            waiters: set[asyncio.Task] = {task}
+            if status_queue is not None and getter is None:
+                getter = asyncio.ensure_future(status_queue.get())
+            if getter is not None:
+                waiters.add(getter)
+            done, _ = await asyncio.wait(
+                waiters, timeout=interval, return_when=asyncio.FIRST_COMPLETED)
+            if getter is not None and getter in done:
+                yield ("status", getter.result())
+                getter = None  # un nouveau get() sera créé au tour suivant
             if not done:
                 yield ("heartbeat", None)
+        # Vide les statuts restés en file (publiés juste avant la fin de la tâche).
+        if status_queue is not None:
+            while not status_queue.empty():
+                yield ("status", status_queue.get_nowait())
         yield ("result", task.result())
     finally:
+        if getter is not None and not getter.done():
+            getter.cancel()
         if not task.done():
             task.cancel()

brain/app/core/language.py

@@ -0,0 +1,61 @@
+"""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)

brain/app/domain/ports.py

@@ -24,17 +24,20 @@ class LLMProvider(Protocol):
         self,
         prompt: str,
         *,
-        output_format: str | None = None,
+        output_format: str | dict | None = None,
         temperature: float | None = None,
     ) -> str:
         """Génère une réponse textuelle à partir d'un prompt donné.
 
         Args:
             prompt: le texte envoyé au modèle.
-            output_format: contrainte de format optionnelle. Exemple : "json"
-                pour forcer le modèle à renvoyer du JSON valide. Les
-                fournisseurs qui ne supportent pas une valeur donnée doivent
-                l'ignorer silencieusement ou la traduire au mieux.
+            output_format: contrainte de format optionnelle. "json" pour forcer
+                un JSON valide ; un dict = SCHÉMA JSON décrivant la structure
+                attendue (les fournisseurs qui supportent les sorties
+                structurées — ex. Ollama — contraignent la génération au schéma,
+                les autres retombent sur leur mode JSON natif). Les fournisseurs
+                qui ne supportent pas une valeur donnée doivent l'ignorer
+                silencieusement ou la traduire au mieux.
             temperature: créativité du modèle, 0.0 (déterministe/factuel) à
                 1.0+ (très créatif, hallucine plus facilement). None =
                 valeur par défaut de l'adapter. Recommandation LoreMind :
@@ -113,3 +116,14 @@ class LLMProviderError(Exception):
     Définie dans le domaine (pas dans l'infra) pour que les couches
     supérieures puissent l'attraper sans connaître l'adapter concret.
     """
+
+
+class LLMGenerationTimeout(LLMProviderError):
+    """La génération a démarré mais n'a pas FINI dans le temps imparti.
+
+    Cas distinct d'un échec transitoire (file d'attente, 503) : le modèle
+    produisait des tokens mais trop lentement pour la taille de sortie demandée.
+    Réessayer à l'identique est inutile (même entrée → même lenteur) ; la bonne
+    réaction est de RÉDUIRE la sortie demandée (ex. import : re-découper le
+    morceau en deux moitiés).
+    """

brain/app/infrastructure/gemini_adapter.py

@@ -20,7 +20,7 @@ import httpx
 
 from app.core.config import Settings
 from app.domain.models import ChatMessage
-from app.domain.ports import LLMProviderError
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
 
 logger = logging.getLogger(__name__)
 
@@ -95,7 +95,7 @@ class GeminiLLMProvider:
         try:
             return await asyncio.wait_for(_collect(), timeout=self._timeout)
         except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
+            raise LLMGenerationTimeout(
                 f"Erreur Gemini : génération non terminée en {self._timeout}s. Réduisez la "
                 "taille des morceaux d'import ou augmentez le timeout."
             ) from exc
@@ -130,6 +130,12 @@ class GeminiLLMProvider:
         }
         if temperature is not None:
             body["temperature"] = temperature
+        # Mode JSON natif (supporté par l'endpoint OpenAI-compatible de Gemini) :
+        # supprime fences ```json et JSON invalide, principale cause de morceaux
+        # ignorés. Un SCHÉMA (dict) est traduit en json_object : suffisant, les
+        # grands modèles cloud respectent la structure demandée par le prompt.
+        if output_format is not None:
+            body["response_format"] = {"type": "json_object"}
 
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:
@@ -138,6 +144,16 @@ class GeminiLLMProvider:
                 ) as response:
                     if response.status_code >= 400:
                         detail = (await response.aread()).decode("utf-8", "replace").strip()
+                        # 401/403 = clé rejetée par GOOGLE (pas un problème LoreMind) :
+                        # message actionnable plutôt que le JSON brut de l'API.
+                        if response.status_code in (401, 403):
+                            raise LLMProviderError(
+                                "Erreur Gemini : clé API refusée par Google "
+                                f"(HTTP {response.status_code}). Vérifiez que la clé vient bien "
+                                "de aistudio.google.com (« Get API key ») et qu'elle n'a pas de "
+                                "restrictions (API ou adresse IP) dans la Google Cloud Console. "
+                                f"Détail : {detail[:300]}"
+                            )
                         raise LLMProviderError(
                             f"Erreur Gemini (HTTP {response.status_code})"
                             + (f" : {detail[:500]}" if detail else "")

brain/app/infrastructure/mistral_adapter.py

@@ -20,7 +20,7 @@ import httpx
 
 from app.core.config import Settings
 from app.domain.models import ChatMessage
-from app.domain.ports import LLMProviderError
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
 
 logger = logging.getLogger(__name__)
 
@@ -101,7 +101,7 @@ class MistralLLMProvider:
         try:
             return await asyncio.wait_for(_collect(), timeout=self._timeout)
         except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
+            raise LLMGenerationTimeout(
                 f"Erreur Mistral : génération non terminée en {self._timeout}s. Réduisez la "
                 "taille des morceaux d'import, augmentez le timeout, ou changez de modèle."
             ) from exc
@@ -136,6 +136,13 @@ class MistralLLMProvider:
         }
         if temperature is not None:
             body["temperature"] = temperature
+        # Mode JSON natif : TOUS les modèles Mistral le supportent → plus de fences
+        # ```json ni de JSON invalide (retours à la ligne bruts dans les chaînes),
+        # principale cause de morceaux d'import ignorés. Un SCHÉMA (dict) est
+        # traduit en json_object : suffisant ici, les grands modèles cloud
+        # respectent la structure demandée par le prompt.
+        if output_format is not None:
+            body["response_format"] = {"type": "json_object"}
 
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:

brain/app/infrastructure/ollama_adapter.py

@@ -5,13 +5,16 @@ Isole le reste de l'application des spécificités du protocole Ollama
 demain, on écrit un nouvel adapter sans toucher au reste du code.
 """
 import json
+import logging
 from typing import AsyncIterator
 
 import httpx
 
 from app.core.config import Settings
 from app.domain.models import ChatMessage
-from app.domain.ports import LLMProviderError
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
+
+logger = logging.getLogger(__name__)
 
 
 class OllamaLLMProvider:
@@ -45,7 +48,7 @@ class OllamaLLMProvider:
         self,
         prompt: str,
         *,
-        output_format: str | None = None,
+        output_format: str | dict | None = None,
         temperature: float | None = None,
     ) -> str:
         url = f"{self._base_url}/api/generate"
@@ -55,6 +58,10 @@ class OllamaLLMProvider:
             "stream": False,
             "options": self._build_options(temperature),
         }
+        # "json" (mode JSON simple) ou un SCHÉMA JSON complet (structured outputs) :
+        # Ollama contraint alors la grammaire de génération au schéma — un petit
+        # modèle local ne PEUT physiquement plus produire d'objets imbriqués, de
+        # clés "thought" bavardes ou de texte hors JSON.
         if output_format is not None:
             payload["format"] = output_format
 
@@ -71,12 +78,45 @@ class OllamaLLMProvider:
                     raise LLMProviderError(
                         f"Ollama HTTP {response.status_code} : {err_msg.strip()[:500]}"
                     )
+            except httpx.ConnectTimeout as exc:
+                # Serveur injoignable : erreur d'infrastructure, pas de lenteur.
+                raise LLMProviderError(
+                    f"Erreur lors de l'appel à Ollama : {exc}"
+                ) from exc
+            except httpx.TimeoutException as exc:
+                # `stream: False` → le read-timeout court jusqu'à la réponse COMPLÈTE,
+                # donc le dépasser = génération trop lente pour la sortie demandée
+                # (fréquent : modèle local modeste + gros morceau d'import à réécrire).
+                # Type dédié → pas de retry à l'identique ; l'import re-découpe le
+                # morceau en deux moitiés (sortie 2× plus courte) à la place.
+                raise LLMGenerationTimeout(
+                    f"Erreur Ollama : génération non terminée en {self._timeout}s. Réduisez "
+                    "la taille des morceaux d'import, augmentez le timeout, ou utilisez un "
+                    "modèle plus rapide."
+                ) from exc
             except httpx.HTTPError as exc:
                 raise LLMProviderError(
                     f"Erreur lors de l'appel à Ollama : {exc}"
                 ) from exc
 
-        return response.json()["response"]
+        data = response.json()
+        # Diagnostic crucial pour les imports : `done_reason` != "stop" signifie que
+        # la génération a été INTERROMPUE (fenêtre de contexte pleine, num_predict…)
+        # et non terminée par le modèle. Sans ce log, on ne voit qu'un JSON coupé
+        # en aval, sans la cause. `prompt_eval_count` révèle aussi la VRAIE taille
+        # du prompt en tokens du modèle (les morceaux sont mesurés en tokens
+        # cl100k, ~20-40% plus compacts que les tokenizers locaux).
+        done_reason = data.get("done_reason")
+        if done_reason and done_reason != "stop":
+            logger.warning(
+                "Ollama a interrompu la génération (done_reason=%s) : prompt=%s tokens, "
+                "sortie=%s tokens, num_ctx demandé=%s. Si prompt+sortie ≈ num_ctx, la "
+                "fenêtre de contexte est pleine : réduisez la taille des morceaux "
+                "d'import ou augmentez num_ctx (Paramètres).",
+                done_reason, data.get("prompt_eval_count"),
+                data.get("eval_count"), self._num_ctx,
+            )
+        return data["response"]
 
     async def stream_chat(
         self,

brain/app/infrastructure/openrouter_adapter.py

@@ -22,7 +22,7 @@ from app.core.config import Settings
 from app.domain.models import ChatMessage
 
 logger = logging.getLogger(__name__)
-from app.domain.ports import LLMProviderError
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
 
 _API_URL = "https://openrouter.ai/api/v1/chat/completions"
 
@@ -113,7 +113,7 @@ class OpenRouterLLMProvider:
         try:
             return await asyncio.wait_for(_collect(), timeout=self._timeout)
         except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
+            raise LLMGenerationTimeout(
                 f"Erreur {provider} : génération non terminée en {self._timeout}s. Réduisez la "
                 "taille des morceaux d'import, augmentez le timeout, ou changez de modèle."
             ) from exc

brain/app/main.py

@@ -26,7 +26,7 @@ from app.infrastructure.ollama_model_installer import ensure_ollama_embedding_mo
 app = FastAPI(
     title="LoreMind Brain",
     description="Backend IA pour la génération de contenu narratif.",
-    version="0.12.0-beta",
+    version="0.15.1",
 )
 
 logger = logging.getLogger(__name__)

brain/run_local.py

@@ -0,0 +1,27 @@
+"""Point d'entree LOCAL du Brain (hors Docker).
+
+Lance le serveur uvicorn sur 127.0.0.1:8000 — l'equivalent autonome de la
+commande Docker `uvicorn app.main:app --host 0.0.0.0 --port 8000`, mais en
+n'ecoutant QUE sur la boucle locale (mono-utilisateur, jamais expose au reseau).
+
+Empaquete avec le Python *embeddable* officiel (signe par la PSF) dans
+l'application de bureau : on evite ainsi tout executable "gele" type PyInstaller
+que les antivirus prennent souvent pour un trojan (bootloader packe).
+Le Core le lance via :  python\\python.exe run_local.py
+
+On insere le dossier de CE fichier dans sys.path pour que le package `app`
+soit importable quel que soit le repertoire de travail (le Core fixe le cwd
+ailleurs, sous ~/.loremind/brain, pour y ecrire le dossier data/).
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import uvicorn  # noqa: E402
+
+from app.main import app  # noqa: E402
+
+if __name__ == "__main__":
+    # host 127.0.0.1 : accessible uniquement depuis le Core sur la meme machine.
+    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")

core/pom.xml

@@ -14,7 +14,7 @@
 
     <groupId>com.loremind</groupId>
     <artifactId>loremind-core</artifactId>
-    <version>0.12.0-beta</version>
+    <version>0.15.1</version>
     <name>LoreMind Core</name>
     <description>Backend Core - Architecture Hexagonale</description>
 
@@ -60,11 +60,31 @@
             <scope>runtime</scope>
         </dependency>
 
-        <!-- H2 Database pour les tests -->
+        <!-- Flyway : migrations de schema versionnees (remplace ddl-auto=update).
+             Un SEUL jeu de migrations en SQL PostgreSQL sert les deux bases :
+             - Postgres (Docker/serveur) nativement ;
+             - H2 (mode local-first) via MODE=PostgreSQL dans l'URL JDBC.
+             flyway-database-postgresql : module requis depuis Flyway 10 (DBs
+             externalisees du core). H2 reste supporte par flyway-core. -->
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-database-postgresql</artifactId>
+        </dependency>
+
+        <!-- H2 Database :
+             - tests (toujours) ;
+             - RUNTIME du profil "local" (mode local-first / jpackage) : base
+               fichier embarquee a la place de Postgres, donc le driver doit etre
+               sur le classpath d'execution. Scope runtime (jamais compile contre)
+               => present a l'execution + tests, ~2,5 Mo inutilises cote Docker. -->
         <dependency>
             <groupId>com.h2database</groupId>
             <artifactId>h2</artifactId>
-            <scope>test</scope>
+            <scope>runtime</scope>
         </dependency>
 
         <!-- Lombok (réduit le code boilerplate) -->
@@ -179,4 +199,50 @@
             </plugin>
         </plugins>
     </build>
+
+    <profiles>
+        <!-- =================================================================
+             Profil "desktop" : build local-first (application de bureau).
+             Active avec : mvn -Pdesktop package
+             Embarque le build Angular dans le jar (classpath:/static/) pour que
+             le Core serve lui-meme le front (cf. LocalWebConfig, profil Spring
+             "local"). Le build Docker normal (sans ce profil) reste une API pure :
+             le front y est servi par le conteneur nginx, donc rien n'est copie.
+             ================================================================= -->
+        <profile>
+            <id>desktop</id>
+            <properties>
+                <!-- Sortie du `ng build` (builder browser) : web/dist/web. -->
+                <frontend.dist>${project.basedir}/../web/dist/web</frontend.dist>
+            </properties>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-resources-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>copy-frontend</id>
+                                <!-- Avant le repackage Spring Boot : on injecte le
+                                     front dans les classes compilees -> embarque
+                                     dans le fat jar sous /static. -->
+                                <phase>prepare-package</phase>
+                                <goals>
+                                    <goal>copy-resources</goal>
+                                </goals>
+                                <configuration>
+                                    <outputDirectory>${project.build.outputDirectory}/static</outputDirectory>
+                                    <resources>
+                                        <resource>
+                                            <directory>${frontend.dist}</directory>
+                                        </resource>
+                                    </resources>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
 </project>

core/src/main/java/com/loremind/LoreMindApplication.java

@@ -1,5 +1,6 @@
 package com.loremind;
 
+import com.loremind.infrastructure.desktop.DesktopSingleInstance;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.scheduling.annotation.EnableScheduling;
@@ -13,6 +14,23 @@ import org.springframework.scheduling.annotation.EnableScheduling;
 public class LoreMindApplication {
 
     public static void main(String[] args) {
-        SpringApplication.run(LoreMindApplication.class, args);
+        // Mode bureau (profil "local") : garde-fou instance unique. Si l'app
+        // tourne deja, on ouvre juste le navigateur et on sort proprement (code 0)
+        // au lieu de demarrer un 2e serveur qui echouerait sur le verrou H2 — ce
+        // qui evite le trompeur « Failed to launch JVM » du launcher jpackage.
+        boolean local = DesktopSingleInstance.isLocalProfile(args);
+        if (local && !DesktopSingleInstance.tryAcquire()) {
+            DesktopSingleInstance.openAppInBrowser();
+            return;
+        }
+        SpringApplication app = new SpringApplication(LoreMindApplication.class);
+        if (local) {
+            // Mode bureau : on a besoin d'AWT (icone de la zone de notification,
+            // cf. SystemTrayManager). Spring Boot force headless=true par defaut,
+            // ce qui leverait HeadlessException — on le desactive ici. En mode
+            // serveur/Docker, on reste en headless (defaut), aucun impact.
+            app.setHeadless(false);
+        }
+        app.run(args);
     }
 }

core/src/main/java/com/loremind/application/campaigncontext/CampaignBriefBuilder.java

@@ -42,15 +42,17 @@ public class CampaignBriefBuilder {
         if (notBlank(cc.campaignDescription())) sb.append(cc.campaignDescription()).append("\n");
 
         sb.append("\n## Structure (arcs → chapitres → scènes)\n");
+        sb.append("_Un arc HUB contient des chapitres parallèles appelés « quêtes » ; ")
+                .append("un arc LINEAR contient des chapitres en séquence._\n");
         if (cc.arcs().isEmpty()) {
             sb.append("_(aucun arc pour le moment)_\n");
         }
         for (ArcSummary arc : cc.arcs()) {
-            sb.append("### Arc : ").append(arc.name());
+            sb.append(arc.hub() ? "### Arc HUB (à quêtes) : " : "### Arc : ").append(arc.name());
             if (notBlank(arc.description())) sb.append(" — ").append(arc.description());
             sb.append("\n");
             for (ChapterSummary ch : arc.chapters()) {
-                sb.append("- Chapitre : ").append(ch.name());
+                sb.append(arc.hub() ? "- Quête : " : "- Chapitre : ").append(ch.name());
                 if (notBlank(ch.description())) sb.append(" — ").append(ch.description());
                 sb.append("\n");
                 for (SceneSummary sc : ch.scenes()) {

core/src/main/java/com/loremind/application/campaigncontext/CampaignImportService.java

@@ -64,9 +64,12 @@ public class CampaignImportService {
             byte[] pdfBytes,
             String filename,
             Consumer<CampaignImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<CampaignImportProposal> onDone,
             Consumer<Throwable> onError) {
-        campaignPdfImporter.importCampaignStreaming(pdfBytes, filename, onProgress, onDone, onError);
+        campaignPdfImporter.importCampaignStreaming(
+                pdfBytes, filename, onProgress, onHeartbeat, onStatus, onDone, onError);
     }
 
     /**
@@ -161,7 +164,7 @@ public class CampaignImportService {
                     isBlank(p.description())
                             ? java.util.Map.of()
                             : java.util.Map.of("Description", p.description().trim()),
-                    null, null, campaignId, null, null));
+                    null, null, campaignId, null, null, null));
             created++;
         }
         return created;

core/src/main/java/com/loremind/application/campaigncontext/CharacterService.java

@@ -78,6 +78,11 @@ public class CharacterService {
         characterRepository.deleteById(id);
     }
 
+    public List<Character> searchCharacters(String query) {
+        if (query == null || query.isBlank()) return List.of();
+        return characterRepository.searchByName(query.trim());
+    }
+
     private int nextOrderFor(String playthroughId) {
         return characterRepository.findByPlaythroughId(playthroughId).stream()
                 .mapToInt(Character::getOrder)

core/src/main/java/com/loremind/application/campaigncontext/EnemyService.java

@@ -0,0 +1,102 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Enemy;
+import com.loremind.domain.campaigncontext.ports.EnemyRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Service d'application pour les fiches d'ennemis (bestiaire de campagne).
+ * Miroir de {@link NpcService} : fiche pilotée par le template ENNEMI du GameSystem.
+ */
+@Service
+public class EnemyService {
+
+    private final EnemyRepository enemyRepository;
+
+    public EnemyService(EnemyRepository enemyRepository) {
+        this.enemyRepository = enemyRepository;
+    }
+
+    public record EnemyData(
+            String name,
+            String level,
+            String folder,
+            String portraitImageId,
+            String headerImageId,
+            Map<String, String> values,
+            Map<String, List<String>> imageValues,
+            Map<String, Map<String, String>> keyValueValues,
+            String campaignId,
+            Integer order
+    ) {}
+
+    public Enemy createEnemy(EnemyData data) {
+        int order = data.order() != null ? data.order() : nextOrderFor(data.campaignId());
+        Enemy enemy = Enemy.builder()
+                .name(data.name())
+                .level(normalize(data.level()))
+                .folder(normalize(data.folder()))
+                .portraitImageId(data.portraitImageId())
+                .headerImageId(data.headerImageId())
+                .values(data.values() != null ? new HashMap<>(data.values()) : new HashMap<>())
+                .imageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>())
+                .keyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>())
+                .campaignId(data.campaignId())
+                .order(order)
+                .build();
+        return enemyRepository.save(enemy);
+    }
+
+    public Optional<Enemy> getEnemyById(String id) {
+        return enemyRepository.findById(id);
+    }
+
+    public List<Enemy> getEnemiesByCampaignId(String campaignId) {
+        return enemyRepository.findByCampaignId(campaignId);
+    }
+
+    public Enemy updateEnemy(String id, EnemyData data) {
+        Enemy existing = enemyRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Enemy non trouvé avec l'ID: " + id));
+        existing.setName(data.name());
+        existing.setLevel(normalize(data.level()));
+        existing.setFolder(normalize(data.folder()));
+        existing.setPortraitImageId(data.portraitImageId());
+        existing.setHeaderImageId(data.headerImageId());
+        existing.setValues(data.values() != null ? new HashMap<>(data.values()) : new HashMap<>());
+        existing.setImageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>());
+        existing.setKeyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>());
+        if (data.order() != null) {
+            existing.setOrder(data.order());
+        }
+        return enemyRepository.save(existing);
+    }
+
+    public void deleteEnemy(String id) {
+        enemyRepository.deleteById(id);
+    }
+
+    public List<Enemy> searchEnemies(String query) {
+        if (query == null || query.isBlank()) return List.of();
+        return enemyRepository.searchByName(query.trim());
+    }
+
+    /** Trim ; chaîne vide → null (= non renseigné / non classé). */
+    private static String normalize(String value) {
+        if (value == null) return null;
+        String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    private int nextOrderFor(String campaignId) {
+        return enemyRepository.findByCampaignId(campaignId).stream()
+                .mapToInt(Enemy::getOrder)
+                .max()
+                .orElse(-1) + 1;
+    }
+}

core/src/main/java/com/loremind/application/campaigncontext/ItemCatalogService.java

@@ -82,6 +82,11 @@ public class ItemCatalogService {
         repository.deleteById(id);
     }
 
+    public List<ItemCatalog> searchCatalogs(String query) {
+        if (query == null || query.isBlank()) return List.of();
+        return repository.searchByName(query.trim());
+    }
+
     /** Génère une PROPOSITION de catalogue (non persistée) via l'IA, contextualisée campagne. */
     public ItemCatalog generateProposal(String campaignId, String description) {
         ItemCatalogGenerator.GeneratedCatalog g = generator.generate(description, buildContext(campaignId));

core/src/main/java/com/loremind/application/campaigncontext/NotebookService.java

@@ -22,16 +22,19 @@ public class NotebookService {
     private final NotebookIndexer indexer;
     private final CampaignRepository campaignRepository;
     private final CampaignBriefBuilder briefBuilder;
+    private final com.loremind.domain.gamesystemcontext.ports.GameSystemRepository gameSystemRepository;
 
     public NotebookService(
             NotebookRepository repository,
             NotebookIndexer indexer,
             CampaignRepository campaignRepository,
-            CampaignBriefBuilder briefBuilder) {
+            CampaignBriefBuilder briefBuilder,
+            com.loremind.domain.gamesystemcontext.ports.GameSystemRepository gameSystemRepository) {
         this.repository = repository;
         this.indexer = indexer;
         this.campaignRepository = campaignRepository;
         this.briefBuilder = briefBuilder;
+        this.gameSystemRepository = gameSystemRepository;
     }
 
     // --- Notebooks ---
@@ -119,6 +122,58 @@ public class NotebookService {
                 .notebookId(notebookId).role(role).content(content).build());
     }
 
+    /** « Vider la conversation » : archive le fil actif (rien n'est supprimé). */
+    public void clearChat(String notebookId) {
+        repository.archiveMessagesByNotebookId(notebookId);
+    }
+
+    /** Messages archivés, chronologiques — l'appelant regroupe par {@code archivedAt}. */
+    public List<NotebookMessage> getArchivedMessages(String notebookId) {
+        return repository.findArchivedMessagesByNotebookId(notebookId);
+    }
+
+    // Budget total (caractères ≈ tokens/4) des archives injectées en référence :
+    // borne le prompt même si l'utilisateur coche plusieurs longues conversations.
+    private static final int ARCHIVE_CONTEXT_MAX_CHARS = 16000;
+
+    /**
+     * Bloc de contexte construit à partir des archives COCHÉES par l'utilisateur
+     * (clés = {@code archivedAt.toString()}). Injecté dans le prompt du chat pour
+     * que l'IA puisse s'appuyer sur d'anciennes conversations. Chaîne vide si
+     * aucune clé valide. Chaque archive est tronquée PAR LE DÉBUT au-delà de son
+     * budget : la fin d'une conversation (conclusions) est la partie utile.
+     */
+    public String buildArchiveContext(String notebookId, List<String> archivedAtKeys) {
+        if (archivedAtKeys == null || archivedAtKeys.isEmpty()) return "";
+        var wanted = new java.util.HashSet<>(archivedAtKeys);
+        var groups = new java.util.LinkedHashMap<java.time.LocalDateTime, List<NotebookMessage>>();
+        for (NotebookMessage m : repository.findArchivedMessagesByNotebookId(notebookId)) {
+            if (m.getArchivedAt() != null && wanted.contains(m.getArchivedAt().toString())) {
+                groups.computeIfAbsent(m.getArchivedAt(), k -> new java.util.ArrayList<>()).add(m);
+            }
+        }
+        if (groups.isEmpty()) return "";
+
+        int budgetPerArchive = Math.max(2000, ARCHIVE_CONTEXT_MAX_CHARS / groups.size());
+        StringBuilder out = new StringBuilder(
+                "--- ANCIENNES CONVERSATIONS DE CET ATELIER (références choisies par le MJ : "
+                        + "tu peux t'appuyer sur leurs conclusions) ---\n");
+        groups.forEach((archivedAt, messages) -> {
+            StringBuilder convo = new StringBuilder();
+            for (NotebookMessage m : messages) {
+                convo.append("user".equals(m.getRole()) ? "MJ : " : "IA : ")
+                        .append(m.getContent()).append('\n');
+            }
+            String text = convo.toString();
+            if (text.length() > budgetPerArchive) {
+                text = "[…début tronqué…]\n" + text.substring(text.length() - budgetPerArchive);
+            }
+            out.append("[Archive du ").append(archivedAt).append("]\n").append(text).append('\n');
+        });
+        out.append("--- FIN DES ANCIENNES CONVERSATIONS ---");
+        return out.toString();
+    }
+
     // --- Contexte campagne (oriente l'IA) ---
 
     /** Brief COMPLET de la campagne (structure arcs/chapitres/scènes + PNJ + lore) :
@@ -127,6 +182,25 @@ public class NotebookService {
         if (campaignId == null) return "";
         Campaign campaign = campaignRepository.findById(campaignId).orElse(null);
         if (campaign == null) return "";
-        return briefBuilder.build(campaign);
+        String brief = briefBuilder.build(campaign);
+        // Champs TEXT de la fiche PNJ du système de jeu : permet à l'IA de remplir
+        // `values` des actions "npc" avec les BONS noms de champs (Histoire,
+        // Apparence…) au lieu de tout entasser dans une description générique.
+        String npcFields = npcSheetFields(campaign.getGameSystemId());
+        return npcFields.isEmpty() ? brief : brief + "\n\n" + npcFields;
+    }
+
+    private String npcSheetFields(String gameSystemId) {
+        if (gameSystemId == null || gameSystemId.isBlank()) return "";
+        var gameSystem = gameSystemRepository.findById(gameSystemId).orElse(null);
+        if (gameSystem == null || gameSystem.getNpcTemplate() == null) return "";
+        var names = gameSystem.getNpcTemplate().stream()
+                .filter(f -> f.getType() == com.loremind.domain.shared.template.FieldType.TEXT)
+                .map(com.loremind.domain.shared.template.TemplateField::getName)
+                .filter(n -> n != null && !n.isBlank())
+                .toList();
+        if (names.isEmpty()) return "";
+        return "FICHE PNJ — champs texte disponibles (clés à utiliser dans `values` "
+                + "d'une action npc) : " + String.join(", ", names);
     }
 }

core/src/main/java/com/loremind/application/campaigncontext/NpcService.java

@@ -1,9 +1,12 @@
 package com.loremind.application.campaigncontext;
 
+import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -16,9 +19,11 @@ import java.util.Optional;
 public class NpcService {
 
     private final NpcRepository npcRepository;
+    private final CampaignRepository campaignRepository;
 
-    public NpcService(NpcRepository npcRepository) {
+    public NpcService(NpcRepository npcRepository, CampaignRepository campaignRepository) {
         this.npcRepository = npcRepository;
+        this.campaignRepository = campaignRepository;
     }
 
     public record NpcData(
@@ -29,6 +34,7 @@ public class NpcService {
             Map<String, List<String>> imageValues,
             Map<String, Map<String, String>> keyValueValues,
             String campaignId,
+            List<String> relatedPageIds,
             String folder,
             Integer order
     ) {}
@@ -45,6 +51,7 @@ public class NpcService {
                 .imageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>())
                 .keyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>())
                 .campaignId(data.campaignId())
+                .relatedPageIds(data.relatedPageIds() != null ? new ArrayList<>(data.relatedPageIds()) : new ArrayList<>())
                 .folder(normalizeFolder(data.folder()))
                 .order(order)
                 .build();
@@ -59,6 +66,21 @@ public class NpcService {
         return npcRepository.findByCampaignId(campaignId);
     }
 
+    /**
+     * PNJ de TOUTES les campagnes liées au Lore donné (via {@code campaign.loreId}).
+     * Sert au graphe du Lore : relier les PNJ aux pages qu'ils référencent.
+     * Volume faible (usage mono-utilisateur) → filtrage en mémoire assumé.
+     */
+    public List<Npc> getNpcsByLoreId(String loreId) {
+        List<Npc> out = new ArrayList<>();
+        for (Campaign campaign : campaignRepository.findAll()) {
+            if (campaign.isLinkedToLore() && campaign.getLoreId().equals(loreId)) {
+                out.addAll(npcRepository.findByCampaignId(campaign.getId()));
+            }
+        }
+        return out;
+    }
+
     public Npc updateNpc(String id, NpcData data) {
         Npc existing = npcRepository.findById(id)
                 .orElseThrow(() -> new IllegalArgumentException("Npc non trouvé avec l'ID: " + id));
@@ -68,6 +90,7 @@ public class NpcService {
         existing.setValues(data.values() != null ? new HashMap<>(data.values()) : new HashMap<>());
         existing.setImageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>());
         existing.setKeyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>());
+        existing.setRelatedPageIds(data.relatedPageIds() != null ? new ArrayList<>(data.relatedPageIds()) : new ArrayList<>());
         existing.setFolder(normalizeFolder(data.folder()));
         if (data.order() != null) {
             existing.setOrder(data.order());
@@ -79,6 +102,11 @@ public class NpcService {
         npcRepository.deleteById(id);
     }
 
+    public List<Npc> searchNpcs(String query) {
+        if (query == null || query.isBlank()) return List.of();
+        return npcRepository.searchByName(query.trim());
+    }
+
     /** Trim le dossier ; chaîne vide → null (= non classé). */
     private static String normalizeFolder(String folder) {
         if (folder == null) return null;

core/src/main/java/com/loremind/application/campaigncontext/RandomTableService.java

@@ -85,6 +85,11 @@ public class RandomTableService {
         repository.deleteById(id);
     }
 
+    public List<RandomTable> searchTables(String query) {
+        if (query == null || query.isBlank()) return List.of();
+        return repository.searchByName(query.trim());
+    }
+
     /** Génère une PROPOSITION de table (non persistée) via l'IA, contextualisée campagne. */
     public RandomTable generateProposal(String campaignId, String description, String diceFormula) {
         String formula = (diceFormula == null || diceFormula.isBlank()) ? "1d20" : diceFormula;

core/src/main/java/com/loremind/application/gamesystemcontext/GameSystemService.java

@@ -39,9 +39,12 @@ public class GameSystemService {
             byte[] pdfBytes,
             String filename,
             java.util.function.Consumer<com.loremind.domain.gamesystemcontext.RulesImportProgress> onProgress,
+            Runnable onHeartbeat,
+            java.util.function.Consumer<String> onStatus,
             java.util.function.Consumer<RulesImportResult> onDone,
             java.util.function.Consumer<Throwable> onError) {
-        rulesPdfImporter.importRulesStreaming(pdfBytes, filename, onProgress, onDone, onError);
+        rulesPdfImporter.importRulesStreaming(
+                pdfBytes, filename, onProgress, onHeartbeat, onStatus, onDone, onError);
     }
 
     /**
@@ -54,6 +57,7 @@ public class GameSystemService {
             String rulesMarkdown,
             List<TemplateField> characterTemplate,
             List<TemplateField> npcTemplate,
+            List<TemplateField> enemyTemplate,
             String author,
             boolean isPublic
     ) {}
@@ -68,6 +72,7 @@ public class GameSystemService {
                 .build();
         gameSystem.replaceCharacterTemplate(data.characterTemplate());
         gameSystem.replaceNpcTemplate(data.npcTemplate());
+        gameSystem.replaceEnemyTemplate(data.enemyTemplate());
         return gameSystemRepository.save(gameSystem);
     }
 
@@ -87,6 +92,7 @@ public class GameSystemService {
         existing.setRulesMarkdown(data.rulesMarkdown());
         existing.replaceCharacterTemplate(data.characterTemplate());
         existing.replaceNpcTemplate(data.npcTemplate());
+        existing.replaceEnemyTemplate(data.enemyTemplate());
         existing.setAuthor(normalize(data.author()));
         existing.setPublic(data.isPublic());
         return gameSystemRepository.save(existing);

core/src/main/java/com/loremind/application/generationcontext/CampaignStructuralContextBuilder.java

@@ -1,6 +1,7 @@
 package com.loremind.application.generationcontext;
 
 import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.domain.campaigncontext.ArcType;
 import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.domain.campaigncontext.Character;
@@ -10,6 +11,7 @@ import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
 import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.EnemyRepository;
 import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import com.loremind.domain.generationcontext.CampaignStructuralContext;
@@ -48,6 +50,7 @@ public class CampaignStructuralContextBuilder {
     private final SceneRepository sceneRepository;
     private final CharacterRepository characterRepository;
     private final NpcRepository npcRepository;
+    private final EnemyRepository enemyRepository;
 
     public CampaignStructuralContextBuilder(
             CampaignRepository campaignRepository,
@@ -55,13 +58,15 @@ public class CampaignStructuralContextBuilder {
             ChapterRepository chapterRepository,
             SceneRepository sceneRepository,
             CharacterRepository characterRepository,
-            NpcRepository npcRepository) {
+            NpcRepository npcRepository,
+            EnemyRepository enemyRepository) {
         this.campaignRepository = campaignRepository;
         this.arcRepository = arcRepository;
         this.chapterRepository = chapterRepository;
         this.sceneRepository = sceneRepository;
         this.characterRepository = characterRepository;
         this.npcRepository = npcRepository;
+        this.enemyRepository = enemyRepository;
     }
 
     /** Longueur max du snippet de PJ/PNJ injecté dans le contexte (coût tokens maîtrisé). */
@@ -84,9 +89,17 @@ public class CampaignStructuralContextBuilder {
                 .orElseThrow(() -> new IllegalArgumentException(
                         "Campagne non trouvée avec l'ID: " + campaignId));
 
+        // Libellés du bestiaire (« Nom (niveau) ») chargés UNE fois pour résoudre
+        // les enemyIds des pièces sans N+1 sur le repo.
+        Map<String, String> enemyLabelById = enemyRepository.findByCampaignId(campaignId).stream()
+                .collect(Collectors.toMap(
+                        com.loremind.domain.campaigncontext.Enemy::getId,
+                        CampaignStructuralContextBuilder::enemyLabel,
+                        (a, b) -> a));
+
         List<ArcSummary> arcs = arcRepository.findByCampaignId(campaignId).stream()
                 .sorted(Comparator.comparingInt(Arc::getOrder))
-                .map(this::toArcSummary)
+                .map(arc -> toArcSummary(arc, enemyLabelById))
                 .collect(Collectors.toList());
 
         List<CharacterSummary> characters = (playthroughId == null || playthroughId.isBlank())
@@ -143,19 +156,20 @@ public class CampaignStructuralContextBuilder {
         return "";
     }
 
-    private ArcSummary toArcSummary(Arc arc) {
+    private ArcSummary toArcSummary(Arc arc, Map<String, String> enemyLabelById) {
         List<ChapterSummary> chapters = chapterRepository.findByArcId(arc.getId()).stream()
                 .sorted(Comparator.comparingInt(Chapter::getOrder))
-                .map(this::toChapterSummary)
+                .map(chapter -> toChapterSummary(chapter, enemyLabelById))
                 .collect(Collectors.toList());
         return new ArcSummary(
                 arc.getName(),
                 arc.getDescription(),
+                arc.getType() == ArcType.HUB,
                 countImages(arc.getIllustrationImageIds()),
                 chapters);
     }
 
-    private ChapterSummary toChapterSummary(Chapter chapter) {
+    private ChapterSummary toChapterSummary(Chapter chapter, Map<String, String> enemyLabelById) {
         List<Scene> scenes = sceneRepository.findByChapterId(chapter.getId()).stream()
                 .sorted(Comparator.comparingInt(Scene::getOrder))
                 .toList();
@@ -166,7 +180,7 @@ public class CampaignStructuralContextBuilder {
                 .collect(Collectors.toMap(Scene::getId, Scene::getName));
 
         List<SceneSummary> summaries = scenes.stream()
-                .map(s -> toSceneSummary(s, nameById))
+                .map(s -> toSceneSummary(s, nameById, enemyLabelById))
                 .collect(Collectors.toList());
 
         return new ChapterSummary(
@@ -176,7 +190,8 @@ public class CampaignStructuralContextBuilder {
                 summaries);
     }
 
-    private SceneSummary toSceneSummary(Scene scene, Map<String, String> nameById) {
+    private SceneSummary toSceneSummary(
+            Scene scene, Map<String, String> nameById, Map<String, String> enemyLabelById) {
         List<BranchHint> hints = scene.getBranches() == null
                 ? List.of()
                 : scene.getBranches().stream()
@@ -186,7 +201,7 @@ public class CampaignStructuralContextBuilder {
                             b.condition()))
                     .collect(Collectors.toList());
 
-        List<RoomSummary> rooms = toRoomSummaries(scene);
+        List<RoomSummary> rooms = toRoomSummaries(scene, enemyLabelById);
 
         return new SceneSummary(
                 scene.getName(),
@@ -202,7 +217,7 @@ public class CampaignStructuralContextBuilder {
      * connaît la structure du lieu (nom des pièces, ennemis, sorties) — c'est
      * suffisant pour proposer de la narration ou anticiper les choix.
      */
-    private List<RoomSummary> toRoomSummaries(Scene scene) {
+    private List<RoomSummary> toRoomSummaries(Scene scene, Map<String, String> enemyLabelById) {
         if (scene.getRooms() == null || scene.getRooms().isEmpty()) return List.of();
         Map<String, String> nameById = scene.getRooms().stream()
                 .collect(Collectors.toMap(
@@ -219,11 +234,36 @@ public class CampaignStructuralContextBuilder {
                                         nameById.getOrDefault(b.targetRoomId(), "(pièce inconnue)"),
                                         b.condition()))
                                 .collect(Collectors.toList());
-                    return new RoomSummary(r.getName(), r.getFloor(), r.getDescription(), r.getEnemies(), hints);
+                    return new RoomSummary(
+                            r.getName(), r.getFloor(), r.getDescription(),
+                            roomEnemiesText(r, enemyLabelById), hints);
                 })
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Texte « ennemis » d'une pièce pour le prompt : fiches du bestiaire
+     * référencées (libellés résolus, IDs orphelins ignorés) suivies du texte
+     * libre. L'un ou l'autre peut être vide.
+     */
+    private static String roomEnemiesText(
+            com.loremind.domain.campaigncontext.Room room, Map<String, String> enemyLabelById) {
+        String linked = room.getEnemyIds() == null ? "" : room.getEnemyIds().stream()
+                .map(enemyLabelById::get)
+                .filter(l -> l != null && !l.isBlank())
+                .collect(Collectors.joining(", "));
+        String freeText = room.getEnemies() == null ? "" : room.getEnemies().strip();
+        if (linked.isEmpty()) return freeText;
+        if (freeText.isEmpty()) return linked;
+        return linked + " — " + freeText;
+    }
+
+    /** Libellé court d'une fiche du bestiaire : « Nom (niveau) » ou « Nom ». */
+    private static String enemyLabel(com.loremind.domain.campaigncontext.Enemy enemy) {
+        String level = enemy.getLevel() == null ? "" : enemy.getLevel().strip();
+        return level.isEmpty() ? enemy.getName() : enemy.getName() + " (" + level + ")";
+    }
+
     /** Helper defensif : compte les illustrations attachees (null-safe). */
     private static int countImages(List<String> ids) {
         return ids == null ? 0 : ids.size();

core/src/main/java/com/loremind/application/generationcontext/NarrativeEntityContextBuilder.java

@@ -8,6 +8,7 @@ import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
 import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.EnemyRepository;
 import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import com.loremind.domain.generationcontext.NarrativeEntityContext;
@@ -32,18 +33,21 @@ public class NarrativeEntityContextBuilder {
     private final SceneRepository sceneRepository;
     private final CharacterRepository characterRepository;
     private final NpcRepository npcRepository;
+    private final EnemyRepository enemyRepository;
 
     public NarrativeEntityContextBuilder(
             ArcRepository arcRepository,
             ChapterRepository chapterRepository,
             SceneRepository sceneRepository,
             CharacterRepository characterRepository,
-            NpcRepository npcRepository) {
+            NpcRepository npcRepository,
+            EnemyRepository enemyRepository) {
         this.arcRepository = arcRepository;
         this.chapterRepository = chapterRepository;
         this.sceneRepository = sceneRepository;
         this.characterRepository = characterRepository;
         this.npcRepository = npcRepository;
+        this.enemyRepository = enemyRepository;
     }
 
     /**
@@ -124,10 +128,41 @@ public class NarrativeEntityContextBuilder {
         putField(fields, "choicesConsequences",  s.getChoicesConsequences());
         putField(fields, "combatDifficulty",     s.getCombatDifficulty());
         putField(fields, "enemies",              s.getEnemies());
+        putField(fields, "linkedEnemies",        resolveLinkedEnemies(s));
         putField(fields, "gmSecretNotes",        s.getGmSecretNotes());
         return new NarrativeEntityContext("scene", s.getName(), fields);
     }
 
+    /**
+     * Résout les fiches du bestiaire référencées par la scène en une ligne par
+     * ennemi : « Nom (niveau) — champ: valeur ; … ». Valeurs tronquées : le
+     * contexte focus doit camper la rencontre, pas embarquer la fiche complète.
+     * Les IDs orphelins (fiche supprimée) sont ignorés silencieusement.
+     */
+    private String resolveLinkedEnemies(Scene s) {
+        if (s.getEnemyIds() == null || s.getEnemyIds().isEmpty()) return "";
+        StringBuilder sb = new StringBuilder();
+        for (String enemyId : s.getEnemyIds()) {
+            enemyRepository.findById(enemyId).ifPresent(e -> {
+                if (sb.length() > 0) sb.append("\n");
+                sb.append("- ").append(e.getName());
+                if (e.getLevel() != null && !e.getLevel().isBlank()) {
+                    sb.append(" (").append(e.getLevel().trim()).append(")");
+                }
+                String stats = e.getValues().entrySet().stream()
+                        .filter(en -> en.getValue() != null && !en.getValue().isBlank())
+                        .map(en -> en.getKey() + ": " + truncate(en.getValue().trim(), 100))
+                        .collect(java.util.stream.Collectors.joining(" ; "));
+                if (!stats.isEmpty()) sb.append(" — ").append(stats);
+            });
+        }
+        return sb.toString();
+    }
+
+    private static String truncate(String value, int maxLen) {
+        return value.length() <= maxLen ? value : value.substring(0, maxLen - 1).stripTrailing() + "…";
+    }
+
     private NarrativeEntityContext fromCharacter(Character c) {
         Map<String, String> fields = new LinkedHashMap<>();
         if (c.getValues() != null) {

core/src/main/java/com/loremind/application/licensing/LicenseService.java

@@ -40,26 +40,33 @@ public class LicenseService {
     private final LicenseRelay relay;
     private final long gracePeriodSeconds;
     private final long refreshBeforeExpirySeconds;
+    private final boolean licensingEnabled;
 
     public LicenseService(
             LicenseRepository repository,
             JwtVerifier jwtVerifier,
             LicenseRelay relay,
             @Value("${licensing.grace-period-days:14}") int gracePeriodDays,
-            @Value("${licensing.refresh-before-expiry-days:2}") int refreshBeforeExpiryDays) {
+            @Value("${licensing.refresh-before-expiry-days:2}") int refreshBeforeExpiryDays,
+            @Value("${licensing.enabled:true}") boolean licensingEnabled) {
         this.repository = repository;
         this.jwtVerifier = jwtVerifier;
         this.relay = relay;
         this.gracePeriodSeconds = (long) gracePeriodDays * 86_400L;
         this.refreshBeforeExpirySeconds = (long) refreshBeforeExpiryDays * 86_400L;
+        this.licensingEnabled = licensingEnabled;
     }
 
     /**
-     * @return true si le verifier est configure (cle publique presente).
-     *         L'UI peut masquer toute la section Patreon si false.
+     * @return true si le licensing Patreon est actif : il faut a la fois que la
+     *         feature soit activee ({@code licensing.enabled}, faux en mode
+     *         bureau/local ou le gating par image Docker n'a aucun sens) ET que
+     *         le verifier soit configure (cle publique presente). Faux => l'UI
+     *         masque toute la section Patreon, le daemon de refresh est no-op,
+     *         et le canal beta est desactive.
      */
     public boolean isLicensingEnabled() {
-        return jwtVerifier.isConfigured();
+        return licensingEnabled && jwtVerifier.isConfigured();
     }
 
     /**

core/src/main/java/com/loremind/application/lorecontext/PageService.java

@@ -76,6 +76,8 @@ public class PageService {
         existing.setNodeId(changes.getNodeId());
         existing.setValues(CollectionUtils.copyMap(changes.getValues()));
         existing.setImageValues(CollectionUtils.copyMap(changes.getImageValues()));
+        existing.setKeyValueValues(CollectionUtils.copyMap(changes.getKeyValueValues()));
+        existing.setTableValues(CollectionUtils.copyMap(changes.getTableValues()));
         existing.setNotes(changes.getNotes());
         existing.setTags(CollectionUtils.copyList(changes.getTags()));
         existing.setRelatedPageIds(CollectionUtils.copyList(changes.getRelatedPageIds()));

core/src/main/java/com/loremind/domain/campaigncontext/Enemy.java

@@ -0,0 +1,70 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Fiche d'ennemi (monstre/créature) d'une campagne — le bestiaire du MJ.
+ * <p>
+ * Même principe de templating que {@link Npc} : champs universels hard-codés
+ * (nom, niveau, dossier, portrait, bandeau) + champs pilotés par le template
+ * ENNEMI du GameSystem ({@code GameSystem.enemyTemplate} : CA, PV, attaques…).
+ * Classement libre par dossier (« Démons », « Humanoïdes »…).
+ */
+@Data
+@Builder
+public class Enemy {
+
+    private String id;
+    private String name;
+
+    /** Niveau / FP / dangerosité — texte libre (« 5 », « FP 8 », « Boss »). Nullable. */
+    private String level;
+
+    /** Dossier de classement (texte libre). Null = non classé. */
+    private String folder;
+
+    /** ID de l'image portrait (champ universel hard-codé). Nullable. */
+    private String portraitImageId;
+
+    /** ID de l'image header/bannière (champ universel hard-codé). Nullable. */
+    private String headerImageId;
+
+    /** Valeurs TEXT/NUMBER du template ennemi. Jamais null après construction. */
+    private Map<String, String> values;
+
+    /** Valeurs IMAGE du template ennemi (listes d'IDs ordonnées par champ). Jamais null. */
+    private Map<String, List<String>> imageValues;
+
+    /** Valeurs KEY_VALUE_LIST : fieldName -> label -> value. Jamais null. */
+    private Map<String, Map<String, String>> keyValueValues;
+
+    /** Référence vers la Campaign parente (cross-aggregate via ID). */
+    private String campaignId;
+
+    /** Ordre d'affichage dans la liste. */
+    private int order;
+
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+
+    public Map<String, String> getValues() {
+        if (values == null) values = new HashMap<>();
+        return values;
+    }
+
+    public Map<String, List<String>> getImageValues() {
+        if (imageValues == null) imageValues = new HashMap<>();
+        return imageValues;
+    }
+
+    public Map<String, Map<String, String>> getKeyValueValues() {
+        if (keyValueValues == null) keyValueValues = new HashMap<>();
+        return keyValueValues;
+    }
+}

core/src/main/java/com/loremind/domain/campaigncontext/NotebookMessage.java

@@ -17,4 +17,6 @@ public class NotebookMessage {
     private String role;
     private String content;
     private LocalDateTime createdAt;
+    /** Null = conversation active ; sinon horodatage du « vider » (lot d'archive). */
+    private LocalDateTime archivedAt;
 }

core/src/main/java/com/loremind/domain/campaigncontext/Npc.java

@@ -4,6 +4,7 @@ import lombok.Builder;
 import lombok.Data;
 
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -46,6 +47,13 @@ public class Npc {
     /** Référence vers la Campaign parente (cross-aggregate via ID). */
     private String campaignId;
 
+    /**
+     * IDs de Pages de Lore référencées par ce PNJ (sa ville, sa faction, sa
+     * région…). Référence faible cross-context, même principe que sur
+     * Arc/Chapter/Scene — alimente notamment le graphe du Lore.
+     */
+    private List<String> relatedPageIds;
+
     /** Dossier de classement (texte libre, ex. « Bard's Gate »). Nullable = non classé. */
     private String folder;
 
@@ -69,4 +77,9 @@ public class Npc {
         if (keyValueValues == null) keyValueValues = new HashMap<>();
         return keyValueValues;
     }
+
+    public List<String> getRelatedPageIds() {
+        if (relatedPageIds == null) relatedPageIds = new ArrayList<>();
+        return relatedPageIds;
+    }
 }

core/src/main/java/com/loremind/domain/campaigncontext/Room.java

@@ -38,6 +38,13 @@ public class Room {
     /** Énemis, créatures, boss éventuels (markdown libre). */
     private String enemies;
 
+    /**
+     * IDs des fiches du bestiaire ({@link Enemy}) présentes dans la pièce
+     * (weak refs). Complète le texte libre {@code enemies}, comme sur Scene.
+     */
+    @Builder.Default
+    private List<String> enemyIds = new ArrayList<>();
+
     /** Loot / récompenses présentes dans la pièce. */
     private String loot;
 

core/src/main/java/com/loremind/domain/campaigncontext/Scene.java

@@ -40,7 +40,15 @@ public class Scene {
 
     // === Combat ou rencontre ===
     private String combatDifficulty;       // Difficulté estimée
-    private String enemies;                // Liste des ennemis et créatures
+    private String enemies;                // Liste des ennemis et créatures (texte libre)
+
+    /**
+     * IDs des fiches du bestiaire ({@link Enemy}) engagées dans cette rencontre
+     * (weak cross-aggregate references). Complète le texte libre `enemies` :
+     * l'utilisateur peut référencer ses fiches, ou tout écrire à la main, ou les deux.
+     */
+    @Builder.Default
+    private List<String> enemyIds = new ArrayList<>();
 
     /**
      * IDs des pages du Lore associées à cette scène (weak cross-context references).

core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignPdfImporter.java

@@ -15,14 +15,23 @@ public interface CampaignPdfImporter {
      * Variante streamée : l'import peut durer plusieurs minutes, on remonte
      * l'avancement au fil de l'eau, puis la proposition finale.
      *
-     * @param onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onDone     invoqué une fois avec l'arbre proposé (non persisté).
-     * @param onError    invoqué si l'extraction/structuration échoue.
+     * @param onProgress  invoqué à chaque étape (extraction, puis par morceau).
+     * @param onHeartbeat invoqué périodiquement pendant un appel LLM long (aucune
+     *                    avancée à afficher, mais le canal SSE vers le navigateur
+     *                    doit rester actif — sinon un proxy intermédiaire le coupe).
+     * @param onStatus    invoqué avec un message lisible quand quelque chose se
+     *                    passe pendant l'attente (fournisseur saturé → retry,
+     *                    morceau re-découpé, morceau ignoré…) — affiché par l'UI
+     *                    pour que l'utilisateur n'ait pas à lire les logs.
+     * @param onDone      invoqué une fois avec l'arbre proposé (non persisté).
+     * @param onError     invoqué si l'extraction/structuration échoue.
      */
     void importCampaignStreaming(
             byte[] pdfBytes,
             String filename,
             Consumer<CampaignImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<CampaignImportProposal> onDone,
             Consumer<Throwable> onError);
 }

core/src/main/java/com/loremind/domain/campaigncontext/ports/CharacterRepository.java

@@ -19,4 +19,7 @@ public interface CharacterRepository {
     void deleteById(String id);
 
     boolean existsById(String id);
+
+    /** Recherche par nom (insensible à la casse) — alimente la recherche globale. */
+    List<Character> searchByName(String query);
 }

core/src/main/java/com/loremind/domain/campaigncontext/ports/EnemyRepository.java

@@ -0,0 +1,23 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Enemy;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des fiches d'ennemis (bestiaire de campagne).
+ */
+public interface EnemyRepository {
+
+    Enemy save(Enemy enemy);
+
+    Optional<Enemy> findById(String id);
+
+    List<Enemy> findByCampaignId(String campaignId);
+
+    void deleteById(String id);
+
+    /** Recherche par nom (insensible à la casse) — alimente la recherche globale. */
+    List<Enemy> searchByName(String query);
+}

core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogRepository.java

@@ -19,4 +19,7 @@ public interface ItemCatalogRepository {
     void deleteById(String id);
 
     boolean existsById(String id);
+
+    /** Recherche par nom (insensible à la casse) — alimente la recherche globale. */
+    List<ItemCatalog> searchByName(String query);
 }

core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookRepository.java

@@ -28,5 +28,10 @@ public interface NotebookRepository {
 
     // --- Messages (conversation) ---
     NotebookMessage saveMessage(NotebookMessage message);
+    /** Messages de la conversation ACTIVE (les archives sont exclues). */
     List<NotebookMessage> findMessagesByNotebookId(String notebookId);
+    /** « Vider » : archive le fil actif en un lot horodaté (rien n'est supprimé). */
+    void archiveMessagesByNotebookId(String notebookId);
+    /** Messages archivés, chronologiques (regroupables par {@code archivedAt}). */
+    List<NotebookMessage> findArchivedMessagesByNotebookId(String notebookId);
 }

core/src/main/java/com/loremind/domain/campaigncontext/ports/NpcRepository.java

@@ -19,4 +19,7 @@ public interface NpcRepository {
     void deleteById(String id);
 
     boolean existsById(String id);
+
+    /** Recherche par nom (insensible à la casse) — alimente la recherche globale. */
+    List<Npc> searchByName(String query);
 }

core/src/main/java/com/loremind/domain/campaigncontext/ports/RandomTableRepository.java

@@ -19,4 +19,7 @@ public interface RandomTableRepository {
     void deleteById(String id);
 
     boolean existsById(String id);
+
+    /** Recherche par nom (insensible à la casse) — alimente la recherche globale. */
+    List<RandomTable> searchByName(String query);
 }

core/src/main/java/com/loremind/domain/conversationcontext/ports/ConversationTitleGenerator.java

@@ -10,6 +10,9 @@ 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);
 }

core/src/main/java/com/loremind/domain/gamesystemcontext/GameSystem.java

@@ -50,6 +50,14 @@ public class GameSystem {
      */
     private List<TemplateField> npcTemplate;
 
+    /**
+     * Template de fiche ENNEMI (monstres/créatures du bestiaire de campagne).
+     * Mêmes règles que {@link #characterTemplate} — distinct du template PNJ :
+     * un ennemi porte des stats de combat (CA, PV, attaques…), pas une
+     * caractérisation narrative.
+     */
+    private List<TemplateField> enemyTemplate;
+
     /** Auteur déclaré — futur marketplace. Nullable. */
     private String author;
 
@@ -98,6 +106,10 @@ public class GameSystem {
         npcTemplate = validateAndCopy(fields);
     }
 
+    public void replaceEnemyTemplate(List<TemplateField> fields) {
+        enemyTemplate = validateAndCopy(fields);
+    }
+
     // --- Helpers privés ----------------------------------------------------
 
     private static List<TemplateField> appendField(List<TemplateField> current, TemplateField field) {

core/src/main/java/com/loremind/domain/gamesystemcontext/ports/RulesPdfImporter.java

@@ -26,14 +26,23 @@ public interface RulesPdfImporter {
      * l'avancement au fil de l'eau. Les callbacks sont invoqués depuis le thread
      * d'exécution de l'adapter (synchrone jusqu'à {@code onDone}/{@code onError}).
      *
-     * @param onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onDone     invoqué une fois avec le résultat final.
-     * @param onError    invoqué si l'extraction/structuration échoue.
+     * @param onProgress  invoqué à chaque étape (extraction, puis par morceau).
+     * @param onHeartbeat invoqué périodiquement pendant un appel LLM long (aucune
+     *                    avancée à afficher, mais le canal SSE vers le navigateur
+     *                    doit rester actif — sinon un proxy intermédiaire le coupe).
+     * @param onStatus    invoqué avec un message lisible quand quelque chose se
+     *                    passe pendant l'attente (fournisseur saturé → retry,
+     *                    morceau re-découpé, morceau ignoré…) — affiché par l'UI
+     *                    pour que l'utilisateur n'ait pas à lire les logs.
+     * @param onDone      invoqué une fois avec le résultat final.
+     * @param onError     invoqué si l'extraction/structuration échoue.
      */
     void importRulesStreaming(
             byte[] pdfBytes,
             String filename,
             Consumer<RulesImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<RulesImportResult> onDone,
             Consumer<Throwable> onError);
 }

core/src/main/java/com/loremind/domain/generationcontext/CampaignStructuralContext.java

@@ -52,11 +52,15 @@ public record CampaignStructuralContext(
     /**
      * Résumé d'un arc : nom + description courte + ses chapitres.
      *
+     * @param hub               true si l'arc est de type HUB : ses chapitres sont des
+     *                          « quêtes » parallèles (vocabulaire UI). L'IA doit le savoir
+     *                          pour parler de quêtes et cibler le bon arc.
      * @param illustrationCount Nombre d'illustrations attachees a cet arc (pour hint dans le prompt IA).
      */
     public record ArcSummary(
             String name,
             String description,
+            boolean hub,
             int illustrationCount,
             List<ChapterSummary> chapters) {
     }

core/src/main/java/com/loremind/domain/lorecontext/Page.java

@@ -39,6 +39,20 @@ public class Page {
      */
     private Map<String, List<String>> imageValues;
 
+    /**
+     * Valeurs des champs KEY_VALUE_LIST (tableau libelle → valeur, comme sur les
+     * fiches de personnage) : fieldName → (label → valeur). Les labels sont
+     * definis par le Template ; seules les valeurs vivent sur la page.
+     */
+    private Map<String, Map<String, String>> keyValueValues;
+
+    /**
+     * Valeurs des champs TABLE (colonnes figees au template, lignes libres) :
+     * fieldName → liste ordonnee de lignes, chaque ligne = colonne → cellule.
+     * Usage type : inventaire de boutique, table d'objets.
+     */
+    private Map<String, List<Map<String, String>>> tableValues;
+
     /** Notes privées du MJ (non exportées vers FoundryVTT). */
     private String notes;
 

core/src/main/java/com/loremind/domain/shared/template/FieldType.java

@@ -9,6 +9,11 @@ package com.loremind.domain.shared.template;
  * - KEY_VALUE_LIST  : liste de paires {label, value} avec labels figes au template
  *                     (Map<String, Map<String, String>> : fieldName -> label -> value).
  *                     Usage : stat blocks, listes de competences, traits.
+ * - TABLE           : tableau a colonnes figees au template (TemplateField.labels =
+ *                     noms de colonnes) et lignes LIBRES ajoutees au remplissage
+ *                     (Map<String, List<Map<String, String>>> : fieldName -> lignes,
+ *                     chaque ligne = colonne -> cellule).
+ *                     Usage : inventaire de boutique, tables d'objets, listes de prix.
  * <p>
  * Extension future possible : RICH_TEXT, DATE, BOOLEAN, REFERENCE...
  */
@@ -16,5 +21,6 @@ public enum FieldType {
     TEXT,
     IMAGE,
     NUMBER,
-    KEY_VALUE_LIST
+    KEY_VALUE_LIST,
+    TABLE
 }

core/src/main/java/com/loremind/domain/shared/template/TemplateField.java

@@ -30,8 +30,9 @@ public class TemplateField {
     /** Variante de rendu pour les champs IMAGE. Null = GALLERY. */
     private ImageLayout layout;
     /**
-     * Labels predefinis pour les champs KEY_VALUE_LIST (ordre significatif).
-     * Ex: ["FOR","DEX","CON","INT","SAG","CHA"] pour un champ "Caracteristiques".
+     * Labels predefinis (ordre significatif), selon le type :
+     * - KEY_VALUE_LIST : libelles des lignes. Ex: ["FOR","DEX","CON","INT","SAG","CHA"].
+     * - TABLE          : noms des COLONNES. Ex: ["Objet","Prix","Description"].
      * Null/vide pour les autres types.
      */
     private List<String> labels;
@@ -70,4 +71,9 @@ public class TemplateField {
     public static TemplateField keyValueList(String name, List<String> labels) {
         return new TemplateField(name, FieldType.KEY_VALUE_LIST, null, labels);
     }
+
+    /** Raccourci : construit un champ TABLE avec ses noms de colonnes. */
+    public static TemplateField table(String name, List<String> columns) {
+        return new TemplateField(name, FieldType.TABLE, null, columns);
+    }
 }

core/src/main/java/com/loremind/infrastructure/ai/BrainAiChatClient.java

@@ -4,6 +4,7 @@ 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;
@@ -64,6 +65,7 @@ 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)

core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignAdaptClient.java

@@ -3,6 +3,7 @@ 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;
@@ -65,6 +66,7 @@ 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()))

core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignImportClient.java

@@ -11,6 +11,7 @@ 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;
@@ -60,6 +61,8 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
             byte[] pdfBytes,
             String filename,
             Consumer<CampaignImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<CampaignImportProposal> onDone,
             Consumer<Throwable> onError) {
 
@@ -69,6 +72,7 @@ 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()))
@@ -83,7 +87,8 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
             flux
                 .timeout(Duration.ofSeconds(importTimeoutSeconds))
                 .doOnNext(sse -> handleEvent(
-                        sse, pageCount, ocrPageCount, terminated, onProgress, onDone, onError))
+                        sse, pageCount, ocrPageCount, terminated,
+                        onProgress, onHeartbeat, onStatus, onDone, onError))
                 .blockLast();
             if (!terminated[0]) {
                 onError.accept(new CampaignImportException(
@@ -107,12 +112,36 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
             int[] ocrPageCount,
             boolean[] terminated,
             Consumer<CampaignImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<CampaignImportProposal> onDone,
             Consumer<Throwable> onError) {
 
         String event = sse.event();
         String data = sse.data() == null ? "" : sse.data();
 
+        if ("heartbeat".equals(event)) {
+            // Keep-alive du Brain pendant un appel LLM long : à PROPAGER jusqu'au
+            // navigateur, sinon nginx (proxy_read_timeout) coupe le SSE Core→front.
+            onHeartbeat.run();
+            return;
+        }
+        if ("status".equals(event)) {
+            // Message d'attente lisible (retry sur fournisseur saturé, morceau
+            // re-découpé…) : affiché par l'UI au lieu de n'exister qu'en logs.
+            onStatus.accept(readMessage(data));
+            return;
+        }
+        if ("chunk_failed".equals(event)) {
+            JsonNode node = readJson(data);
+            String msg = node != null && node.hasNonNull("message")
+                    ? node.get("message").asText() : "";
+            int current = node != null ? node.path("current").asInt() : 0;
+            int total = node != null ? node.path("total").asInt() : 0;
+            onStatus.accept("Morceau " + current + "/" + total + " ignoré"
+                    + (msg.isEmpty() ? "." : " : " + msg));
+            return;
+        }
         if ("error".equals(event)) {
             terminated[0] = true;
             onError.accept(new CampaignImportException(

core/src/main/java/com/loremind/infrastructure/ai/BrainChatPayloadBuilder.java

@@ -252,9 +252,15 @@ public class BrainChatPayloadBuilder {
                 ArcSummary::name,
                 ArcSummary::description,
                 ArcSummary::illustrationCount,
-                (map, arc) -> map.put("chapters", arc.chapters().stream()
-                        .map(this::chapterSummaryToMap)
-                        .collect(Collectors.toList())));
+                (map, arc) -> {
+                    // Vocabulaire UI : les chapitres d'un arc HUB sont des « quêtes ».
+                    if (arc.hub()) {
+                        map.put("arc_type", "HUB");
+                    }
+                    map.put("chapters", arc.chapters().stream()
+                            .map(this::chapterSummaryToMap)
+                            .collect(Collectors.toList()));
+                });
     }
 
     private Map<String, Object> chapterSummaryToMap(ChapterSummary c) {

core/src/main/java/com/loremind/infrastructure/ai/BrainConversationTitleClient.java

@@ -2,6 +2,7 @@ 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;
@@ -50,6 +51,7 @@ 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()

core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookChatClient.java

@@ -4,6 +4,7 @@ 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;
@@ -66,6 +67,7 @@ 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)

core/src/main/java/com/loremind/infrastructure/ai/BrainRulesImportClient.java

@@ -6,6 +6,7 @@ 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;
@@ -114,6 +115,8 @@ public class BrainRulesImportClient implements RulesPdfImporter {
             byte[] pdfBytes,
             String filename,
             Consumer<RulesImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<RulesImportResult> onDone,
             Consumer<Throwable> onError) {
 
@@ -123,6 +126,7 @@ 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()))
@@ -139,7 +143,8 @@ public class BrainRulesImportClient implements RulesPdfImporter {
             flux
                 .timeout(Duration.ofSeconds(importTimeoutSeconds))
                 .doOnNext(sse -> handleEvent(
-                        sse, pageCount, ocrPageCount, terminated, onProgress, onDone, onError))
+                        sse, pageCount, ocrPageCount, terminated,
+                        onProgress, onHeartbeat, onStatus, onDone, onError))
                 .blockLast();
             // Flux terminé sans event done/error (ex: connexion coupée) → on signale.
             if (!terminated[0]) {
@@ -165,12 +170,37 @@ public class BrainRulesImportClient implements RulesPdfImporter {
             int[] ocrPageCount,
             boolean[] terminated,
             Consumer<RulesImportProgress> onProgress,
+            Runnable onHeartbeat,
+            Consumer<String> onStatus,
             Consumer<RulesImportResult> onDone,
             Consumer<Throwable> onError) {
 
         String event = sse.event();
         String data = sse.data() == null ? "" : sse.data();
 
+        if ("heartbeat".equals(event)) {
+            // Keep-alive du Brain pendant un appel LLM long : à PROPAGER jusqu'au
+            // navigateur, sinon nginx (proxy_read_timeout) coupe le SSE Core→front
+            // resté silencieux pendant tout le traitement du morceau.
+            onHeartbeat.run();
+            return;
+        }
+        if ("status".equals(event)) {
+            // Message d'attente lisible (retry sur fournisseur saturé, morceau
+            // re-découpé…) : affiché par l'UI au lieu de n'exister qu'en logs.
+            onStatus.accept(readMessage(data));
+            return;
+        }
+        if ("chunk_failed".equals(event)) {
+            JsonNode node = readJson(data);
+            String msg = node != null && node.hasNonNull("message")
+                    ? node.get("message").asText() : "";
+            int current = node != null ? node.path("current").asInt() : 0;
+            int total = node != null ? node.path("total").asInt() : 0;
+            onStatus.accept("Morceau " + current + "/" + total + " ignoré"
+                    + (msg.isEmpty() ? "." : " : " + msg));
+            return;
+        }
         if ("error".equals(event)) {
             terminated[0] = true;
             onError.accept(new RulesImportException(

core/src/main/java/com/loremind/infrastructure/ai/BrainSidecar.java

@@ -0,0 +1,126 @@
+package com.loremind.infrastructure.ai;
+
+import jakarta.annotation.PreDestroy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Lance le Brain (service IA Python) comme SOUS-PROCESSUS du Core, en mode
+ * local-first (application de bureau empaquetee, sans Docker).
+ * <p>
+ * Cycle de vie calque sur celui du Core :
+ * <ul>
+ *   <li>demarrage : a {@link ApplicationReadyEvent} (le serveur HTTP du Core
+ *       est deja pret) ;</li>
+ *   <li>arret : a {@link PreDestroy} (fermeture du contexte Spring) — on arrete
+ *       proprement le Brain pour ne pas laisser de process orphelin.</li>
+ * </ul>
+ * <p>
+ * Tolerance aux pannes : si le Brain ne peut pas etre lance (exe absent,
+ * commande non configuree...), on LOGGUE sans faire echouer le Core. L'app
+ * reste utilisable (Lore, Campagnes, Systeme de jeu) ; seules les fonctions IA
+ * sont indisponibles jusqu'a correction.
+ */
+@Component
+@Profile("local")
+public class BrainSidecar {
+
+    private static final Logger log = LoggerFactory.getLogger(BrainSidecar.class);
+
+    private final BrainSidecarProperties props;
+    private final String internalSecret;
+
+    private volatile Process process;
+
+    public BrainSidecar(BrainSidecarProperties props,
+                        @Value("${brain.internal-secret:}") String internalSecret) {
+        this.props = props;
+        this.internalSecret = internalSecret;
+    }
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void start() {
+        if (!props.isEnabled()) {
+            log.info("[Brain] Sidecar desactive (brain.sidecar.enabled=false).");
+            return;
+        }
+        if (props.getCommand() == null || props.getCommand().isEmpty()) {
+            log.warn("[Brain] Aucune commande configuree (brain.sidecar.command) : "
+                    + "le Brain n'est pas lance. Les fonctions IA seront indisponibles.");
+            return;
+        }
+
+        try {
+            ProcessBuilder pb = new ProcessBuilder(props.getCommand());
+            pb.redirectErrorStream(true);
+            pb.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+
+            File workingDir = resolveWorkingDir();
+            if (workingDir != null) {
+                pb.directory(workingDir);
+            }
+
+            // Secret partage Core <-> Brain : le Brain est fail-closed sans lui.
+            // (cf. Settings.internal_shared_secret cote Python -> env INTERNAL_SHARED_SECRET)
+            pb.environment().put("INTERNAL_SHARED_SECRET", internalSecret);
+
+            this.process = pb.start();
+            log.info("[Brain] Sidecar demarre (pid={}, cwd={}).",
+                    process.pid(), workingDir != null ? workingDir : "<heritee>");
+        } catch (IOException e) {
+            log.error("[Brain] Echec du lancement du sidecar (commande={}). "
+                            + "Les fonctions IA seront indisponibles. Cause : {}",
+                    props.getCommand(), e.getMessage());
+        }
+    }
+
+    @PreDestroy
+    public void stop() {
+        Process p = this.process;
+        if (p == null || !p.isAlive()) {
+            return;
+        }
+        log.info("[Brain] Arret du sidecar (pid={})...", p.pid());
+        p.destroy();
+        try {
+            if (!p.waitFor(10, TimeUnit.SECONDS)) {
+                log.warn("[Brain] Arret propre depasse (10s) : kill force.");
+                p.destroyForcibly();
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            p.destroyForcibly();
+        }
+    }
+
+    /**
+     * Resout (et cree au besoin) le repertoire de travail du Brain. Le Brain y
+     * ecrit son dossier {@code data/} (index vectoriel, settings.json).
+     */
+    private File resolveWorkingDir() {
+        String dir = props.getWorkingDir();
+        if (dir == null || dir.isBlank()) {
+            return null; // herite du cwd du Core
+        }
+        Path path = Path.of(dir).toAbsolutePath().normalize();
+        try {
+            Files.createDirectories(path);
+        } catch (IOException e) {
+            log.warn("[Brain] Impossible de creer le repertoire de travail {} : {}. "
+                    + "Lancement avec le cwd herite.", path, e.getMessage());
+            return null;
+        }
+        return path.toFile();
+    }
+}

core/src/main/java/com/loremind/infrastructure/ai/BrainSidecarProperties.java

@@ -0,0 +1,53 @@
+package com.loremind.infrastructure.ai;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Configuration du lancement du Brain (service IA Python) en SIDECAR, c.-a-d.
+ * comme sous-processus du Core, en mode local-first.
+ * <p>
+ * En deploiement Docker, le Brain est un conteneur independant : ce mecanisme
+ * est inactif (profil {@code local} uniquement). En application de bureau
+ * empaquetee, il n'y a pas de Docker : le Core demarre lui-meme le Brain.
+ *
+ * @see BrainSidecar
+ */
+@Component
+@Profile("local")
+@ConfigurationProperties(prefix = "brain.sidecar")
+public class BrainSidecarProperties {
+
+    /** Active le lancement du Brain par le Core. */
+    private boolean enabled = false;
+
+    /**
+     * Commande de lancement (programme + arguments). Vide = ne rien lancer
+     * (cas du dev qui demarre le Brain a la main).
+     * <ul>
+     *   <li>Mode empaquete (jpackage) : chemin de l'exe PyInstaller, ex.
+     *       {@code C:\Program Files\LoreMind\brain\loremind-brain.exe}</li>
+     *   <li>Dev : {@code python,-m,uvicorn,app.main:app,--host,127.0.0.1,--port,8000}</li>
+     * </ul>
+     */
+    private List<String> command = List.of();
+
+    /**
+     * Repertoire de travail du process Brain. Le Brain ecrit ses donnees (index
+     * vectoriel, settings.json) sous {@code data/} RELATIF a ce dossier : on le
+     * place donc sous loremind.home pour que tout vive au meme endroit.
+     */
+    private String workingDir;
+
+    public boolean isEnabled() { return enabled; }
+    public void setEnabled(boolean enabled) { this.enabled = enabled; }
+
+    public List<String> getCommand() { return command; }
+    public void setCommand(List<String> command) { this.command = command; }
+
+    public String getWorkingDir() { return workingDir; }
+    public void setWorkingDir(String workingDir) { this.workingDir = workingDir; }
+}

core/src/main/java/com/loremind/infrastructure/ai/RestTemplateConfig.java

@@ -1,5 +1,6 @@
 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;
@@ -17,6 +18,12 @@ 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 {
@@ -36,6 +43,7 @@ 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();
@@ -59,6 +67,7 @@ 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();

core/src/main/java/com/loremind/infrastructure/desktop/DesktopBrowserOpener.java

@@ -0,0 +1,31 @@
+package com.loremind.infrastructure.desktop;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * En mode bureau (profil "local"), ouvre le navigateur par defaut sur
+ * l'application des que le serveur est pret. L'app n'ayant pas de fenetre
+ * native, c'est ce qui donne a l'utilisateur un retour visuel immediat apres
+ * le double-clic.
+ * <p>
+ * Concerne uniquement l'instance qui a effectivement demarre le serveur :
+ * l'instance « perdante » du verrou unique ouvre le navigateur des le {@code main}
+ * puis sort (cf. {@link DesktopSingleInstance}).
+ */
+@Component
+@Profile("local")
+public class DesktopBrowserOpener {
+
+    private static final Logger log = LoggerFactory.getLogger(DesktopBrowserOpener.class);
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void onReady() {
+        log.info("[Desktop] Application prete — ouverture du navigateur.");
+        DesktopSingleInstance.openAppInBrowser();
+    }
+}

core/src/main/java/com/loremind/infrastructure/desktop/DesktopSingleInstance.java

@@ -0,0 +1,113 @@
+package com.loremind.infrastructure.desktop;
+
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+/**
+ * Utilitaires du mode BUREAU (profil "local", application empaquetee jpackage).
+ * <p>
+ * Resout deux problemes specifiques au lancement par double-clic :
+ * <ol>
+ *   <li><b>Instance unique</b> : un serveur web n'ouvre pas de fenetre. Un
+ *       utilisateur qui ne voit rien re-double-clique souvent — la 2e instance
+ *       trouvait la base H2 verrouillee et sortait en erreur, ce que le launcher
+ *       jpackage traduit par un trompeur « Failed to launch JVM ». On detecte
+ *       donc tres tot (avant Spring) qu'une instance tourne deja, et on se
+ *       contente d'ouvrir le navigateur puis de sortir proprement (code 0).</li>
+ *   <li><b>Ouverture du navigateur</b> : l'app n'ayant pas de fenetre native,
+ *       on ouvre le navigateur par defaut sur l'URL locale pour que l'utilisateur
+ *       voie l'application immediatement.</li>
+ * </ol>
+ * Volontairement sans dependance a {@code java.awt.Desktop} : ce module
+ * ({@code java.desktop}) pourrait etre absent du runtime reduit par jlink.
+ * On passe donc par la commande systeme d'ouverture d'URL.
+ */
+public final class DesktopSingleInstance {
+
+    /** Conserve le verrou ouvert pour TOUTE la duree de vie du process (sinon GC = relache). */
+    @SuppressWarnings("unused")
+    private static FileChannel lockChannel;
+    private static FileLock lock;
+
+    private DesktopSingleInstance() {}
+
+    /** Vrai si le profil Spring actif inclut "local" (cas de l'app de bureau). */
+    public static boolean isLocalProfile(String[] args) {
+        String prop = System.getProperty("spring.profiles.active", "");
+        String env = System.getenv().getOrDefault("SPRING_PROFILES_ACTIVE", "");
+        if (containsLocal(prop) || containsLocal(env)) return true;
+        if (args != null) {
+            for (String a : args) {
+                if (a.startsWith("--spring.profiles.active=") && containsLocal(a)) return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean containsLocal(String s) {
+        for (String p : s.split("[,=]")) {
+            if (p.trim().equals("local")) return true;
+        }
+        return false;
+    }
+
+    /**
+     * Tente de prendre le verrou d'instance unique (fichier {@code .instance.lock}
+     * sous loremind.home). Retourne {@code true} si on est la PREMIERE instance
+     * (verrou obtenu, on doit demarrer le serveur), {@code false} si une autre
+     * instance le detient deja.
+     * <p>
+     * En cas d'erreur d'E/S inattendue, on retourne {@code true} (degradation
+     * prudente : mieux vaut tenter de demarrer que bloquer l'app).
+     */
+    public static boolean tryAcquire() {
+        try {
+            Path dir = loremindHome();
+            Files.createDirectories(dir);
+            Path lockFile = dir.resolve(".instance.lock");
+            lockChannel = FileChannel.open(lockFile,
+                    StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+            lock = lockChannel.tryLock();
+            return lock != null; // null = deja verrouille par une autre instance
+        } catch (IOException e) {
+            System.err.println("[Desktop] Verrou d'instance indisponible (" + e.getMessage()
+                    + ") — on tente de demarrer quand meme.");
+            return true;
+        }
+    }
+
+    /** Ouvre le navigateur par defaut sur l'URL de l'application locale. */
+    public static void openAppInBrowser() {
+        openUrl("http://localhost:" + System.getProperty("server.port", "8080") + "/");
+    }
+
+    /** Ouvre le navigateur par defaut sur une URL quelconque (sans dependance AWT). */
+    public static void openUrl(String url) {
+        try {
+            String os = System.getProperty("os.name", "").toLowerCase();
+            ProcessBuilder pb;
+            if (os.contains("win")) {
+                // rundll32 : ouverture d'URL fiable sans dependance graphique Java.
+                pb = new ProcessBuilder("rundll32", "url.dll,FileProtocolHandler", url);
+            } else if (os.contains("mac")) {
+                pb = new ProcessBuilder("open", url);
+            } else {
+                pb = new ProcessBuilder("xdg-open", url);
+            }
+            pb.start();
+        } catch (IOException e) {
+            System.err.println("[Desktop] Impossible d'ouvrir le navigateur sur " + url
+                    + " : " + e.getMessage() + ". Ouvrez-le manuellement.");
+        }
+    }
+
+    private static Path loremindHome() {
+        String home = System.getProperty("loremind.home");
+        if (home != null && !home.isBlank()) return Path.of(home);
+        return Path.of(System.getProperty("user.home"), ".loremind");
+    }
+}

core/src/main/java/com/loremind/infrastructure/desktop/DesktopUpdateService.java

@@ -0,0 +1,129 @@
+package com.loremind.infrastructure.desktop;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.info.BuildProperties;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.lang.Nullable;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+import java.time.Duration;
+import java.util.Optional;
+
+/**
+ * Verification des mises a jour pour l'application de BUREAU (profil "local").
+ * <p>
+ * Contrairement au mode Docker (registry + Watchtower, cf.
+ * {@link com.loremind.infrastructure.updates.UpdateCheckService}), il n'y a pas
+ * de mise a jour automatique : on interroge l'API <b>GitHub Releases</b> pour la
+ * derniere release STABLE, on compare a la version courante du binaire, et si
+ * une version plus recente existe on le signale (via l'icone systray, cf.
+ * {@link SystemTrayManager}). L'utilisateur telecharge puis lance le nouvel
+ * installeur (MSI de meme UpgradeCode = mise a jour en place).
+ * <p>
+ * {@code /releases/latest} ne renvoie que les releases stables (pas les
+ * prereleases) : les utilisateurs stables ne sont donc pas notifies des betas.
+ */
+@Service
+@Profile("local")
+public class DesktopUpdateService {
+
+    private static final Logger log = LoggerFactory.getLogger(DesktopUpdateService.class);
+
+    private final RestTemplate http;
+    private final boolean enabled;
+    private final String releasesApiUrl;
+    /** Version semver du binaire courant (ex: "0.14.0"), ou null en dev sans build-info. */
+    private final String currentVersion;
+
+    public DesktopUpdateService(
+            RestTemplateBuilder builder,
+            @Value("${desktop.update.enabled:true}") boolean enabled,
+            @Value("${desktop.update.releases-api-url:https://api.github.com/repos/IGMLcreation/LoreMind/releases/latest}") String releasesApiUrl,
+            @Nullable BuildProperties buildProperties) {
+        this.http = builder
+                .setConnectTimeout(Duration.ofSeconds(5))
+                .setReadTimeout(Duration.ofSeconds(10))
+                .build();
+        this.enabled = enabled;
+        this.releasesApiUrl = releasesApiUrl;
+        this.currentVersion = buildProperties != null ? buildProperties.getVersion() : null;
+    }
+
+    /**
+     * Interroge GitHub Releases. Retourne les infos de mise a jour SI une version
+     * plus recente que la version courante existe, sinon {@code Optional.empty()}
+     * (a jour, desactive, ou verification impossible — jamais d'exception propagee).
+     */
+    public Optional<UpdateInfo> checkForUpdate() {
+        if (!enabled || currentVersion == null) {
+            return Optional.empty();
+        }
+        try {
+            HttpHeaders headers = new HttpHeaders();
+            // GitHub exige un User-Agent ; l'Accept versionne l'API.
+            headers.set(HttpHeaders.USER_AGENT, "LoreMind-Desktop");
+            headers.set(HttpHeaders.ACCEPT, "application/vnd.github+json");
+
+            ResponseEntity<JsonNode> resp = http.exchange(
+                    releasesApiUrl, HttpMethod.GET, new HttpEntity<>(headers), JsonNode.class);
+            JsonNode body = resp.getBody();
+            if (body == null || body.path("tag_name").isMissingNode()) {
+                return Optional.empty();
+            }
+            String tag = body.path("tag_name").asText("");          // ex: "v0.15.0"
+            String releaseUrl = body.path("html_url").asText(null);  // page de la release
+            String latest = tag.startsWith("v") ? tag.substring(1) : tag;
+
+            if (!latest.isBlank() && compareSemver(currentVersion, latest) < 0) {
+                log.info("[Update] Nouvelle version disponible : {} (courante : {})", latest, currentVersion);
+                return Optional.of(new UpdateInfo(currentVersion, latest, releaseUrl));
+            }
+            log.info("[Update] A jour (courante : {}, derniere release : {}).", currentVersion, latest);
+            return Optional.empty();
+        } catch (Exception e) {
+            // Hors-ligne, rate-limit GitHub, etc. : non bloquant, on ne notifie juste pas.
+            log.info("[Update] Verification GitHub Releases impossible : {}", e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    /** Infos d'une mise a jour disponible. */
+    public record UpdateInfo(String currentVersion, String latestVersion, String releaseUrl) {}
+
+    /**
+     * Compare deux versions MAJOR.MINOR.PATCH (suffixe -beta/-rc ignore).
+     * @return &lt;0 si a&lt;b, 0 si egales, &gt;0 si a&gt;b.
+     */
+    static int compareSemver(String a, String b) {
+        int[] va = parse(a);
+        int[] vb = parse(b);
+        for (int i = 0; i < 3; i++) {
+            int cmp = Integer.compare(va[i], vb[i]);
+            if (cmp != 0) return cmp;
+        }
+        return 0;
+    }
+
+    private static int[] parse(String version) {
+        String core = version.split("[-+]", 2)[0]; // retire -beta, -rc, +build...
+        String[] parts = core.split("\\.");
+        int[] out = new int[3];
+        for (int i = 0; i < 3 && i < parts.length; i++) {
+            try {
+                out[i] = Integer.parseInt(parts[i].trim());
+            } catch (NumberFormatException ignored) {
+                out[i] = 0;
+            }
+        }
+        return out;
+    }
+}

core/src/main/java/com/loremind/infrastructure/desktop/SystemTrayManager.java

@@ -0,0 +1,154 @@
+package com.loremind.infrastructure.desktop;
+
+import jakarta.annotation.PreDestroy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.MenuItem;
+import java.awt.PopupMenu;
+import java.awt.RenderingHints;
+import java.awt.SystemTray;
+import java.awt.TrayIcon;
+import java.awt.image.BufferedImage;
+
+/**
+ * Icone dans la zone de notification (barre des taches) en mode bureau
+ * (profil "local"). Donne a l'utilisateur un controle visible de l'application,
+ * qui tourne sinon en serveur sans fenetre : impossible autrement de la fermer
+ * proprement (fermer l'onglet du navigateur laisse le Core et le Brain tourner).
+ * <p>
+ * Menu : « Ouvrir LoreMind » (ouvre le navigateur) et « Quitter LoreMind »
+ * (ferme le contexte Spring — ce qui declenche le {@code @PreDestroy} de
+ * {@link com.loremind.infrastructure.ai.BrainSidecar} et arrete donc aussi le
+ * Brain — puis termine le process).
+ * <p>
+ * Necessite que le mode headless soit desactive (cf. LoreMindApplication.main,
+ * qui appelle {@code setHeadless(false)} en profil local). Le module
+ * {@code java.desktop} est embarque dans le runtime jpackage.
+ */
+@Component
+@Profile("local")
+public class SystemTrayManager {
+
+    private static final Logger log = LoggerFactory.getLogger(SystemTrayManager.class);
+
+    private final ConfigurableApplicationContext context;
+    private final DesktopUpdateService updateService;
+    private TrayIcon trayIcon;
+    private PopupMenu popup;
+
+    public SystemTrayManager(ConfigurableApplicationContext context,
+                             DesktopUpdateService updateService) {
+        this.context = context;
+        this.updateService = updateService;
+    }
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void install() {
+        if (!SystemTray.isSupported()) {
+            log.warn("[Tray] Zone de notification non supportee sur ce systeme — "
+                    + "pas d'icone. Pour quitter : menu de la fenetre console, ou gestionnaire des taches.");
+            return;
+        }
+        try {
+            popup = new PopupMenu();
+
+            MenuItem open = new MenuItem("Ouvrir LoreMind");
+            open.addActionListener(e -> DesktopSingleInstance.openAppInBrowser());
+            popup.add(open);
+
+            popup.addSeparator();
+
+            MenuItem quit = new MenuItem("Quitter LoreMind");
+            quit.addActionListener(e -> quit());
+            popup.add(quit);
+
+            trayIcon = new TrayIcon(createIcon(), "LoreMind", popup);
+            trayIcon.setImageAutoSize(true);
+            // Double-clic sur l'icone : ouvre l'application dans le navigateur.
+            trayIcon.addActionListener(e -> DesktopSingleInstance.openAppInBrowser());
+
+            SystemTray.getSystemTray().add(trayIcon);
+            log.info("[Tray] Icone installee dans la zone de notification.");
+
+            // Verification de mise a jour en arriere-plan (appel reseau GitHub) :
+            // ne bloque pas le demarrage ; met a jour le menu/notifie si dispo.
+            new Thread(this::checkForUpdate, "loremind-update-check").start();
+        } catch (Exception e) {
+            // Echec non bloquant : l'app reste utilisable, seul le confort de l'icone manque.
+            log.warn("[Tray] Installation de l'icone impossible : {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Interroge GitHub Releases ; si une version plus recente existe, ajoute un
+     * item de menu « Telecharger » et affiche une bulle de notification. L'item
+     * ouvre la page de la release dans le navigateur (telechargement manuel du
+     * nouvel installeur).
+     */
+    private void checkForUpdate() {
+        updateService.checkForUpdate().ifPresent(info -> {
+            String label = "⬇ Telecharger la mise a jour (v" + info.latestVersion() + ")";
+            MenuItem update = new MenuItem(label);
+            update.addActionListener(e -> DesktopSingleInstance.openUrl(info.releaseUrl()));
+            // En tete de menu pour la visibilite, suivi d'un separateur.
+            popup.insert(update, 0);
+            popup.insertSeparator(1);
+
+            trayIcon.displayMessage(
+                    "LoreMind — mise a jour disponible",
+                    "Version " + info.latestVersion() + " disponible (vous avez " + info.currentVersion()
+                            + "). Menu de l'icone → Telecharger.",
+                    TrayIcon.MessageType.INFO);
+        });
+    }
+
+    /**
+     * Arret propre depuis le menu « Quitter » : on retire l'icone puis on ferme
+     * le contexte Spring dans un thread dedie (l'action s'execute sur l'EDT AWT ;
+     * fermer le contexte + arreter Tomcat/Brain depuis l'EDT pourrait le bloquer).
+     */
+    private void quit() {
+        log.info("[Tray] Demande de fermeture de l'application.");
+        new Thread(() -> {
+            int code = SpringApplication.exit(context, () -> 0);
+            System.exit(code);
+        }, "loremind-shutdown").start();
+    }
+
+    /** Retire l'icone si le contexte se ferme par une autre voie (ex. Ctrl+C). */
+    @PreDestroy
+    public void remove() {
+        if (trayIcon != null) {
+            SystemTray.getSystemTray().remove(trayIcon);
+        }
+    }
+
+    /**
+     * Genere une petite icone (carre arrondi violet « L ») sans dependre d'un
+     * fichier image — robuste quel que soit l'empaquetage.
+     */
+    private Image createIcon() {
+        int size = 16;
+        BufferedImage img = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
+        Graphics2D g = img.createGraphics();
+        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g.setColor(new Color(0x8B, 0x5C, 0xF6)); // violet de marque LoreMind
+        g.fillRoundRect(0, 0, size, size, 5, 5);
+        g.setColor(Color.WHITE);
+        g.setFont(new Font("SansSerif", Font.BOLD, 12));
+        g.drawString("L", 4, 13);
+        g.dispose();
+        return img;
+    }
+}

core/src/main/java/com/loremind/infrastructure/persistence/converter/StringRowListMapJsonConverter.java

@@ -0,0 +1,51 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Convertit une Map<String, List<Map<String, String>>> en JSON et inversement.
+ * <p>
+ * Utilise pour Page.tableValues : pour chaque champ TABLE du template, stocke
+ * la liste ordonnee des LIGNES du tableau, chaque ligne etant une map
+ * colonne -> cellule. Exemple :
+ *   {"Inventaire": [{"Objet":"Potion","Prix":"50 po"}, {"Objet":"Corde","Prix":"1 po"}]}
+ * <p>
+ * Adaptateur technique pur : le domaine ignore ce converter.
+ */
+@Converter
+public class StringRowListMapJsonConverter
+        implements AttributeConverter<Map<String, List<Map<String, String>>>, String> {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final TypeReference<Map<String, List<Map<String, String>>>> TYPE_REF =
+            new TypeReference<>() {};
+
+    @Override
+    public String convertToDatabaseColumn(Map<String, List<Map<String, String>>> attribute) {
+        if (attribute == null || attribute.isEmpty()) return "{}";
+        try {
+            return MAPPER.writeValueAsString(attribute);
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    "Erreur serialisation Map<String, List<Map<String,String>>> -> JSON", e);
+        }
+    }
+
+    @Override
+    public Map<String, List<Map<String, String>>> convertToEntityAttribute(String dbData) {
+        if (dbData == null || dbData.isBlank()) return Collections.emptyMap();
+        try {
+            return MAPPER.readValue(dbData, TYPE_REF);
+        } catch (Exception e) {
+            throw new IllegalStateException(
+                    "Erreur deserialisation JSON -> Map<String, List<Map<String,String>>>", e);
+        }
+    }
+}

core/src/main/java/com/loremind/infrastructure/persistence/converter/TemplateFieldListJsonConverter.java

@@ -86,7 +86,7 @@ public class TemplateFieldListJsonConverter
                         }
                     }
                     List<String> labels = null;
-                    if (type == FieldType.KEY_VALUE_LIST) {
+                    if (type == FieldType.KEY_VALUE_LIST || type == FieldType.TABLE) {
                         JsonNode labelsNode = item.path("labels");
                         if (labelsNode.isArray()) {
                             labels = new ArrayList<>();

core/src/main/java/com/loremind/infrastructure/persistence/entity/EnemyJpaEntity.java

@@ -0,0 +1,88 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListMapJsonConverter;
+import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
+import com.loremind.infrastructure.persistence.converter.StringMapMapJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Entité JPA des fiches d'ennemis (bestiaire). Mêmes règles que NpcJpaEntity.
+ */
+@Entity
+@Table(name = "enemies", indexes = {
+        @Index(name = "idx_enemies_campaign_id", columnList = "campaign_id")
+})
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class EnemyJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    /** Niveau / FP — texte libre. Nullable. */
+    @Column(name = "level")
+    private String level;
+
+    /** Dossier de classement (« Démons », « Humanoïdes »…). Nullable = non classé. */
+    @Column(name = "folder")
+    private String folder;
+
+    @Column(name = "portrait_image_id")
+    private String portraitImageId;
+
+    @Column(name = "header_image_id")
+    private String headerImageId;
+
+    @Convert(converter = StringMapJsonConverter.class)
+    @Column(name = "field_values", columnDefinition = "TEXT")
+    private Map<String, String> values;
+
+    @Convert(converter = StringListMapJsonConverter.class)
+    @Column(name = "image_values", columnDefinition = "TEXT")
+    private Map<String, List<String>> imageValues;
+
+    @Convert(converter = StringMapMapJsonConverter.class)
+    @Column(name = "key_value_values", columnDefinition = "TEXT")
+    private Map<String, Map<String, String>> keyValueValues;
+
+    @Column(name = "campaign_id", nullable = false)
+    private Long campaignId;
+
+    @Column(name = "\"order\"", nullable = false)
+    private int order;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+        if (values == null) values = new HashMap<>();
+        if (imageValues == null) imageValues = new HashMap<>();
+        if (keyValueValues == null) keyValueValues = new HashMap<>();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

core/src/main/java/com/loremind/infrastructure/persistence/entity/GameSystemJpaEntity.java

@@ -46,6 +46,11 @@ public class GameSystemJpaEntity {
     @Column(name = "npc_template", columnDefinition = "TEXT")
     private List<TemplateField> npcTemplate;
 
+    /** Template ENNEMI (bestiaire) serialise en JSON. */
+    @Convert(converter = TemplateFieldListJsonConverter.class)
+    @Column(name = "enemy_template", columnDefinition = "TEXT")
+    private List<TemplateField> enemyTemplate;
+
     @Column
     private String author;
 
@@ -64,6 +69,7 @@ public class GameSystemJpaEntity {
         updatedAt = LocalDateTime.now();
         if (characterTemplate == null) characterTemplate = new ArrayList<>();
         if (npcTemplate == null) npcTemplate = new ArrayList<>();
+        if (enemyTemplate == null) enemyTemplate = new ArrayList<>();
     }
 
     @PreUpdate

core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookMessageJpaEntity.java

@@ -34,6 +34,14 @@ public class NotebookMessageJpaEntity {
     @Column(name = "created_at", nullable = false, updatable = false)
     private LocalDateTime createdAt;
 
+    /**
+     * Null = message de la conversation ACTIVE. Non-null = message archivé lors
+     * d'un « vider la conversation » ; tous les messages d'un même clear portent
+     * le même horodatage, qui sert d'identifiant de lot d'archive.
+     */
+    @Column(name = "archived_at")
+    private LocalDateTime archivedAt;
+
     @PrePersist
     protected void onCreate() {
         if (createdAt == null) createdAt = LocalDateTime.now();

core/src/main/java/com/loremind/infrastructure/persistence/entity/NpcJpaEntity.java

@@ -1,5 +1,6 @@
 package com.loremind.infrastructure.persistence.entity;
 
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapMapJsonConverter;
@@ -54,6 +55,11 @@ public class NpcJpaEntity {
     @Column(name = "campaign_id", nullable = false)
     private Long campaignId;
 
+    /** IDs de Pages de Lore référencées (référence faible cross-context). JSON TEXT. */
+    @Convert(converter = StringListJsonConverter.class)
+    @Column(name = "related_page_ids", columnDefinition = "TEXT")
+    private List<String> relatedPageIds;
+
     @Column(name = "folder")
     private String folder;
 

core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java

@@ -3,6 +3,8 @@ package com.loremind.infrastructure.persistence.entity;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
+import com.loremind.infrastructure.persistence.converter.StringMapMapJsonConverter;
+import com.loremind.infrastructure.persistence.converter.StringRowListMapJsonConverter;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -52,6 +54,16 @@ public class PageJpaEntity {
     @Convert(converter = StringListMapJsonConverter.class)
     private Map<String, List<String>> imageValues;
 
+    /** Valeurs des champs KEY_VALUE_LIST : fieldName → (label → valeur). JSON TEXT. */
+    @Column(name = "key_value_values", columnDefinition = "TEXT")
+    @Convert(converter = StringMapMapJsonConverter.class)
+    private Map<String, Map<String, String>> keyValueValues;
+
+    /** Valeurs des champs TABLE : fieldName → lignes (colonne → cellule). JSON TEXT. */
+    @Column(name = "table_values", columnDefinition = "TEXT")
+    @Convert(converter = StringRowListMapJsonConverter.class)
+    private Map<String, List<Map<String, String>>> tableValues;
+
     @Column(columnDefinition = "TEXT")
     private String notes;
 

core/src/main/java/com/loremind/infrastructure/persistence/entity/SceneJpaEntity.java

@@ -75,6 +75,12 @@ public class SceneJpaEntity {
     @Column(columnDefinition = "TEXT")
     private String enemies;
 
+    /** IDs des fiches du bestiaire liées à la rencontre (JSON, weak refs). */
+    @Column(name = "enemy_ids", columnDefinition = "TEXT")
+    @Convert(converter = StringListJsonConverter.class)
+    @Builder.Default
+    private List<String> enemyIds = new ArrayList<>();
+
     @Column(name = "related_page_ids", columnDefinition = "TEXT")
     @Convert(converter = StringListJsonConverter.class)
     @Builder.Default

core/src/main/java/com/loremind/infrastructure/persistence/jpa/CharacterJpaRepository.java

@@ -10,4 +10,7 @@ import java.util.List;
 public interface CharacterJpaRepository extends JpaRepository<CharacterJpaEntity, Long> {
 
     List<CharacterJpaEntity> findByPlaythroughIdOrderByOrderAsc(Long playthroughId);
+
+    /** Recherche globale : bornée pour ne jamais inonder la palette de résultats. */
+    List<CharacterJpaEntity> findTop20ByNameContainingIgnoreCaseOrderByNameAsc(String name);
 }

core/src/main/java/com/loremind/infrastructure/persistence/jpa/EnemyJpaRepository.java

@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.EnemyJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface EnemyJpaRepository extends JpaRepository<EnemyJpaEntity, Long> {
+
+    List<EnemyJpaEntity> findByCampaignIdOrderByOrderAsc(Long campaignId);
+
+    /** Recherche globale : bornée pour ne jamais inonder la palette de résultats. */
+    List<EnemyJpaEntity> findTop20ByNameContainingIgnoreCaseOrderByNameAsc(String name);
+}