CI : build web cassé par la sortie de npm 12 (npm@latest exige Node >= 22)

Suppression du « npm install -g npm@latest » du Dockerfile web : cible
mouvante inutile — le npm embarqué dans node:20 suffit pour npm ci
(lockfileVersion 3) et le build Angular.

.gitea/workflows/ci.yml

@@ -0,0 +1,86 @@
+name: Tests unitaires
+
+# Gate de qualité : lance les 3 suites unitaires (Java / Python / Angular) à
+# chaque push sur main et sur chaque PR. Une suite rouge fait échouer la CI
+# (et, via la branch protection Gitea, peut bloquer le merge).
+# Le build/push des images (release.yml) dépend AUSSI de ces tests via `needs`.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  core:
+    name: Core (Java · mvn test + JaCoCo)
+    runs-on: ubuntu-latest
+    # Les tests Core utilisent une VRAIE base PostgreSQL (cf.
+    # src/test/resources/application.properties, ddl-auto=create-drop).
+    # On en fournit une en service container. Sur Gitea (job en conteneur),
+    # le service est joignable par son NOM d'hôte `postgres`.
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_DB: loremind_test
+          POSTGRES_USER: loremind_test
+          POSTGRES_PASSWORD: loremind_test
+        options: >-
+          --health-cmd "pg_isready -U loremind_test -d loremind_test"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          cache: maven
+      # Maven wrapper (./mvnw) : le runner Gitea n'a pas `mvn` préinstallé et
+      # setup-java n'installe que le JDK → le wrapper bootstrappe Maven lui-même.
+      # `mvn test` exécute aussi jacoco:report + jacoco:check (plancher 60%).
+      - name: mvn test (via wrapper)
+        working-directory: core
+        env:
+          SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/loremind_test
+          SPRING_DATASOURCE_USERNAME: loremind_test
+          SPRING_DATASOURCE_PASSWORD: loremind_test
+        run: |
+          chmod +x ./mvnw
+          ./mvnw -B test
+
+  brain:
+    name: Brain (Python · pytest + couverture)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: pip
+          cache-dependency-path: brain/requirements-dev.txt
+      - name: Install deps (test)
+        working-directory: brain
+        run: pip install -r requirements-dev.txt
+      - name: pytest (+ plancher couverture 50%)
+        working-directory: brain
+        run: pytest --cov=app --cov-report=term-missing --cov-fail-under=50
+
+  web:
+    name: Web (Angular · vitest + couverture)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+      - name: npm ci
+        working-directory: web
+        run: npm ci --no-audit --no-fund
+      # vitest run --coverage applique les seuils définis dans vitest.config.ts.
+      - name: vitest (+ seuils couverture)
+        working-directory: web
+        run: npm run test:unit:coverage

.gitea/workflows/e2e.yml

@@ -82,9 +82,11 @@ jobs:
         if: failure()
         run: docker compose -f docker-compose.yml -f docker-compose.e2e.yml logs --no-color
 
+      # v3 obligatoire : l'API artifacts v4 n'est pas supportée par Gitea
+      # (GHESNotSupportedError — constaté sur le job MegaLinter).
       - name: Upload Playwright report
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: playwright-report
           path: web/playwright-report/

.gitea/workflows/quality.yml

@@ -0,0 +1,104 @@
+name: Qualité & Sécurité
+
+# Analyse statique (MegaLinter, config racine .mega-linter.yml) + CVE des
+# dépendances (Trivy). Workflow SÉPARÉ de ci.yml : un rouge qualité ne bloque
+# pas la chaîne tests → release pendant la phase de rodage. Une fois la base
+# assainie, on pourra l'ajouter aux checks requis de la branch protection.
+on:
+  push:
+    # beta inclus : c'est la branche de dev, le feedback qualité doit y vivre
+    # (ci.yml/e2e.yml, eux, restent volontairement sur main + PR).
+    branches: [main, beta]
+  pull_request:
+    branches: [main]
+
+jobs:
+  megalinter:
+    name: MegaLinter (PMD · Ruff · Bandit · gitleaks · hadolint)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Historique complet : requis par gitleaks (scan de l'historique)
+          # et par le mode "fichiers modifiés seulement" en PR.
+          fetch-depth: 0
+      # Flavor "cupcake" : image allégée couvrant les langages courants
+      # (Java/Python/TS inclus). Si un linter activé manquait à la flavor,
+      # MegaLinter échoue en l'indiquant → remplacer par oxsecurity/megalinter@v9
+      # (image complète, plus lourde).
+      - name: MegaLinter
+        uses: oxsecurity/megalinter/flavors/cupcake@v9
+        env:
+          # main → scan complet du dépôt ; beta et PR → seulement les fichiers
+          # modifiés par rapport à main (rapide, feedback ciblé).
+          VALIDATE_ALL_CODEBASE: ${{ github.ref == 'refs/heads/main' }}
+      # v3 obligatoire : l'API artifacts v4 (@actions/artifact 2.x) n'est pas
+      # supportée par Gitea (GHESNotSupportedError constaté avec v4).
+      - name: Publier les rapports
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: megalinter-reports
+          path: megalinter-reports/
+
+  web-lint:
+    name: Web (ESLint · angular-eslint + sonarjs)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+      - name: npm ci
+        working-directory: web
+        run: npm ci --no-audit --no-fund
+      # Lint via la toolchain du projet (et non via MegaLinter : ESLint a
+      # besoin des plugins de web/node_modules et du contexte Angular).
+      # Config + règles : web/eslint.config.js (sonarjs = règles "à la Sonar").
+      - name: ng lint
+        working-directory: web
+        run: npm run lint
+
+  trivy:
+    name: Trivy (CVE dépendances Maven / pip / npm)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Pour résoudre pom.xml (versions héritées du parent Spring Boot), Trivy
+      # télécharge les BOMs depuis Maven Central — qui finit par rate-limiter
+      # l'IP du runner (429). Parade officielle : peupler ~/.m2 AVANT le scan,
+      # Trivy lit le cache local en priorité. Le cache setup-java (clé pom.xml)
+      # rend l'étape quasi gratuite d'un run à l'autre.
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          cache: maven
+      - name: Précharger le cache Maven (~/.m2)
+        working-directory: core
+        run: |
+          chmod +x ./mvnw
+          ./mvnw -B -q dependency:go-offline
+      - name: Installer Trivy
+        run: curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin
+      # Scanne les manifestes du dépôt (pom.xml, requirements*.txt,
+      # package-lock.json) contre les bases CVE. --ignore-unfixed : on ne
+      # bloque que sur les vulnérabilités qui ONT un correctif publié.
+      # --offline-scan : AUCUNE requête vers Maven Central pendant la
+      # résolution — Trivy allait y chercher les POMs parents même avec le
+      # cache rempli, et l'IP du runner finissait rate-limitée (429, 30 min).
+      # Tout est déjà dans ~/.m2 grâce au dependency:go-offline ci-dessus ;
+      # contrepartie : une dépendance absente du cache serait ignorée en
+      # silence (impossible ici, go-offline échouerait d'abord).
+      - name: Scan des dépendances (HIGH/CRITICAL bloquants)
+        run: |
+          trivy fs . \
+            --scanners vuln \
+            --severity HIGH,CRITICAL \
+            --ignore-unfixed \
+            --offline-scan \
+            --skip-dirs node_modules \
+            --skip-dirs docusaurus \
+            --exit-code 1

.gitea/workflows/release.yml

@@ -12,6 +12,9 @@ env:
   GHCR_NAMESPACE: igmlcreation
 
 jobs:
+  # NB : pas de job de test ici. Le gate qualité vit dans ci.yml (push main + PR) ;
+  # avec la branch protection Gitea (checks requis sur main), on ne tague donc que
+  # du code déjà vert. release.yml ne fait que builder/pousser les images.
   build:
     runs-on: ubuntu-latest
     strategy:

.github/workflows/desktop-release.yml

@@ -0,0 +1,262 @@
+name: Desktop installers
+
+# Produit les installeurs de BUREAU (.msi Windows + AppImage Linux) 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 ne
+# sait PAS cross-compiler : le .msi DOIT etre construit sur un runner Windows et
+# l'AppImage sur un runner Linux — GitHub fournit les deux gratuitement.
+#
+# 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:
+  # GATE : les 3 suites unitaires (Java / Python / Angular) doivent passer avant
+  # de construire le .msi. Tourne sur ubuntu-latest (moins cher/plus rapide que
+  # windows) ; le build natif lui-meme reste sur windows-latest via `needs`.
+  # Auto-suffisant : ne depend PAS du resultat de Gitea (CI separee), il rejoue
+  # les memes tests ici. Un test rouge => pas d'installeur publie.
+  tests:
+    runs-on: ubuntu-latest
+    # Base PostgreSQL réelle pour les tests Core. Sur les runners GitHub (job sur
+    # la VM, pas en conteneur), le service est joignable via localhost + le port mappé.
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_DB: loremind_test
+          POSTGRES_USER: loremind_test
+          POSTGRES_PASSWORD: loremind_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U loremind_test -d loremind_test"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('v{0}', inputs.version) || github.ref }}
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          cache: maven
+      - name: Core — mvn test (+ JaCoCo check)
+        working-directory: core
+        env:
+          SPRING_DATASOURCE_URL: jdbc:postgresql://localhost:5432/loremind_test
+          SPRING_DATASOURCE_USERNAME: loremind_test
+          SPRING_DATASOURCE_PASSWORD: loremind_test
+        run: |
+          chmod +x ./mvnw
+          ./mvnw -B test
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: pip
+          cache-dependency-path: brain/requirements-dev.txt
+      - name: Brain — pytest (+ couverture)
+        working-directory: brain
+        run: |
+          pip install -r requirements-dev.txt
+          pytest --cov=app --cov-report=term-missing --cov-fail-under=50
+
+      - name: Set up Node 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+      - name: Web — vitest (+ couverture)
+        working-directory: web
+        run: |
+          npm ci --no-audit --no-fund
+          npm run test:unit:coverage
+
+  windows:
+    needs: tests
+    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
+
+      # Tesseract OCR : non preinstalle sur windows-latest. Requis pour que
+      # build-windows.ps1 embarque l'OCR des PDF scannes (sinon il skip en
+      # degradation gracieuse). Installe dans %ProgramFiles%\Tesseract-OCR.
+      - name: Install Tesseract OCR
+        shell: pwsh
+        run: choco install tesseract -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
+
+  # LINUX : AppImage (1 fichier, toutes distros) attache a la MEME release.
+  # Tourne sur ubuntu-latest (jpackage ne cross-compile pas -> build natif Linux).
+  # Brain empaquete via python-build-standalone (pas de Python embeddable Linux
+  # officiel ; pas de PyInstaller -> pas de faux positif AV). Memes regles de
+  # publication que windows : stable -> release publique ; beta -> artefact prive.
+  linux:
+    needs: tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && format('v{0}', inputs.version) || github.ref }}
+
+      # Apporte jpackage (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'
+
+      # Pas de setup-python : le Brain utilise SON python-build-standalone
+      # (telecharge par le script, avec son propre pip). Le host n'en a pas besoin.
+
+      # Version (numerique X.Y.Z) + tag + isbeta, comme le job windows.
+      - name: Derive version
+        id: ver
+        run: |
+          if [ '${{ github.event_name }}' = 'workflow_dispatch' ]; then
+            raw='${{ inputs.version }}'
+          else
+            raw='${{ github.ref_name }}'
+          fi
+          raw="${raw#v}"                       # 0.15.0  ou  0.15.0-beta
+          num="${raw%%-*}"                     # 0.15.0
+          case "$raw" in *-beta*) isbeta=true ;; *) isbeta=false ;; esac
+          echo "version=$num"   >> "$GITHUB_OUTPUT"
+          echo "tag=v$raw"      >> "$GITHUB_OUTPUT"
+          echo "isbeta=$isbeta" >> "$GITHUB_OUTPUT"
+
+      - name: Build Linux AppImage
+        env:
+          # Authentifie l'appel API GitHub (resolution python-build-standalone) :
+          # evite le rate limit 60/h anonyme des runners partages.
+          GITHUB_TOKEN: ${{ github.token }}
+        run: bash ./installers/desktop/build-linux.sh --version ${{ steps.ver.outputs.version }}
+
+      # STABLE uniquement : attache l'AppImage a la release publique (meme tag que
+      # le .msi -> les deux installeurs sur la meme release).
+      - name: Publish AppImage 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/DM_Loremind*.AppImage
+          fail_on_unmatched_files: true
+
+      # BETA uniquement : artefact PRIVE (pas de release publique).
+      - name: Upload AppImage as private artifact (beta)
+        if: ${{ steps.ver.outputs.isbeta == 'true' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: loremind-beta-${{ steps.ver.outputs.version }}-appimage
+          path: core/target/dist-out/DM_Loremind*.AppImage
+          retention-days: 90

.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,19 @@ 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
+
+# Rapports de couverture de tests
+web/coverage/
+brain/htmlcov/
+brain/.coverage
+foundry-module/
+plan-promotion-loremind.md
+post-reddit-foundryvtt.md

.mega-linter.yml

@@ -0,0 +1,43 @@
+# Configuration MegaLinter — https://megalinter.io/latest/config-file/
+#
+# Périmètre volontairement resserré (liste ENABLE_LINTERS exclusive) : on
+# active les linters au fil de l'eau plutôt que de subir les ~100 par défaut.
+# Le scan CVE des dépendances n'est PAS ici : il est porté par le job Trivy
+# (cf. .gitea/workflows/quality.yml).
+
+APPLY_FIXES: none
+DEFAULT_BRANCH: main
+SHOW_ELAPSED_TIME: true
+PRINT_ALPACA: false
+
+# Liste EXCLUSIVE : tout linter absent d'ici est désactivé.
+ENABLE_LINTERS:
+  # --- core (Java) : bugs + code smells "à la Sonar" sur les sources.
+  #     (Sonar for IDE reste pertinent en local pour l'analyse de flux fine.)
+  - JAVA_PMD
+  # --- brain (Python) ---
+  - PYTHON_RUFF        # remplace flake8/pylint/isort, très rapide
+  - PYTHON_BANDIT      # sécurité du code Python
+  # - PYTHON_MYPY      # à activer quand le brain aura des annotations de types
+  # --- repo entier ---
+  - REPOSITORY_GITLEAKS   # secrets committés (tokens, mots de passe…)
+  - DOCKERFILE_HADOLINT   # bonnes pratiques Dockerfile
+  # --- web (TypeScript) : PAS via MegaLinter. Le lint tourne avec la
+  #     toolchain du projet (job "web-lint" de quality.yml → ng lint,
+  #     config web/eslint.config.js avec angular-eslint + sonarjs).
+
+# Jamais d'analyse des artefacts de build, dépendances et sites docs.
+FILTER_REGEX_EXCLUDE: '(^|/)(node_modules|target|dist|coverage|\.angular|\.mvn|docusaurus)/'
+
+# Rapports déposés là où le workflow les publie en artefact CI.
+REPORT_OUTPUT_FOLDER: megalinter-reports
+
+# Phase de rodage : passer temporairement à true pour rendre le job
+# informatif (rapport sans échec CI) le temps de purger l'existant.
+DISABLE_ERRORS: false
+
+# PMD : ruleset projet à la racine (java-pmd-ruleset.xml, détecté
+# automatiquement) — orienté bugs réels, sans style. Non-bloquant le temps
+# de purger le backlog (~65 findings : PreserveStackTrace, EmptyCatchBlock,
+# CheckResultSet, RelianceOnDefaultCharset…). Repasser à false ensuite.
+JAVA_PMD_DISABLE_ERRORS: true

README.fr.md

@@ -0,0 +1,80 @@
+# DM 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 DM Loremind en vidéo
+
+[![Présentation DM 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
+
+DM 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.
+
+### Système de JDR
+
+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.
+
+### Campagne
+
+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 système de JDR 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/)** — vos données ne quittent jamais votre machine — ou dans le **cloud** avec votre propre clé API via [1min.ai](https://1min.ai/), [Mistral](https://mistral.ai/), [Google AI Studio (Gemini)](https://aistudio.google.com/) ou [OpenRouter](https://openrouter.ai/).
+
+## Démarrage rapide
+
+**Bureau (le plus simple)** — récupérez le dernier installeur sur la [page Releases](https://github.com/IGMLcreation/LoreMind/releases) : Windows `.msi` ou Linux `.AppImage`, puis lancez-le. Vos données restent en local.
+
+**Auto-hébergement Docker** — sous Linux :
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/IGMLcreation/LoreMind/main/installers/install.sh | bash
+```
+
+Sous Windows, suivez le [guide d'installation](https://loremind-docs.igmlcreation.fr/).
+
+## 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
+- Fonctions IA non incluses dans la démo (elles nécessitent un fournisseur d'IA — Ollama en local ou une clé API cloud — configuré côté serveur)
+
+## Soutenir le projet
+
+DM 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
+
+DM 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 DM Loremind **vous appartiennent entièrement** — la licence ne couvre que le code de l'application.

README.md

@@ -1,66 +1,80 @@
-# LoreMind
+# DM 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 DM Loremind in action
 
-![Tableau de bord](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
+[![DM 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
+
+DM 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/)** — your data stays on your machine — or in the **cloud** with your own API key via [1min.ai](https://1min.ai/), [Mistral](https://mistral.ai/), [Google AI Studio (Gemini)](https://aistudio.google.com/) or [OpenRouter](https://openrouter.ai/).
+
+## Quick start
+
+**Desktop (easiest)** — grab the latest installer from the [Releases page](https://github.com/IGMLcreation/LoreMind/releases): Windows `.msi` or Linux `.AppImage`, then run it. Your data stays local.
+
+**Self-host with Docker** — on Linux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/IGMLcreation/LoreMind/main/installers/install.sh | bash
+```
+
+On Windows, follow the [installation guide](https://loremind-docs.igmlcreation.fr/en/).
 
 ## 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 features are not included in the demo (they require an AI provider — local Ollama or a cloud API key — configured 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 :
+DM 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)**.
+DM 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 DM Loremind **belong entirely to you** — the license only covers the application's code.

brain/.coveragerc

@@ -0,0 +1,15 @@
+# Configuration de couverture (coverage.py / pytest-cov).
+# Rapport HTML (équivalent JaCoCo) : pytest --cov=app --cov-report=html → htmlcov/
+# Plancher anti-régression appliqué en CI : --cov-fail-under=50
+[run]
+source = app
+branch = false
+
+[report]
+show_missing = true
+skip_covered = false
+# Lignes jamais comptées comme « à couvrir ».
+exclude_lines =
+    pragma: no cover
+    if __name__ == .__main__.:
+    raise NotImplementedError

brain/.gitignore

@@ -2,3 +2,8 @@
 __pycache__/
 *.pyc
 .env
+
+# Couverture de tests (pytest-cov)
+htmlcov/
+.coverage
+.pytest_cache/

brain/app/api/__init__.py

@@ -0,0 +1,5 @@
+"""Adapter web (architecture hexagonale) : routers FastAPI, DTOs et factories DI.
+
+C'est la FRONTIÈRE HTTP du Brain : validation Pydantic, mapping DTO ↔ domaine,
+traduction des erreurs domaine → HTTP. Aucune logique métier ici.
+"""

brain/app/api/chat_dto.py

@@ -0,0 +1,215 @@
+"""DTOs Pydantic du chat contextuel — frontière HTTP avec le Core Java.
+
+C'est ici (et seulement ici, avec les autres modules de `app.api`) qu'on
+utilise Pydantic : le domaine ne voit que des dataclasses (voir chat_mapping).
+"""
+from pydantic import BaseModel, Field
+
+
+class ChatMessageDTO(BaseModel):
+    """Un message de la conversation. Rôles acceptés : user, assistant, system."""
+
+    role: str = Field(pattern="^(user|assistant|system)$")
+    content: str
+
+
+class PageSummaryDTO(BaseModel):
+    """Résumé enrichi d'une page : identité + contenu + interconnexions.
+
+    Depuis b9 : values/tags/related_page_titles sont optionnels côté JSON —
+    le Core Java ne les sérialise que s'ils sont non-vides (payload léger
+    pour un Lore avec beaucoup de pages vierges).
+    """
+
+    title: str
+    template_name: str
+    values: dict[str, str] = Field(default_factory=dict)
+    tags: list[str] = Field(default_factory=list)
+    related_page_titles: list[str] = Field(default_factory=list)
+
+
+class LoreContextDTO(BaseModel):
+    """Carte structurelle du Lore avec contenu des pages (b9+)."""
+
+    lore_name: str
+    lore_description: str | None = None
+    folders: dict[str, list[PageSummaryDTO]] = Field(default_factory=dict)
+    tags: list[str] = Field(default_factory=list)
+
+
+class PageContextDTO(BaseModel):
+    """Contexte d'une page spécifique pour focaliser le chat (optionnel)."""
+
+    title: str
+    template_name: str
+    template_fields: list[str] = Field(default_factory=list)
+    values: dict[str, str] = Field(default_factory=dict)
+
+
+class SceneBranchHintDTO(BaseModel):
+    """Indice d'une branche narrative (le Core a deja resolu le nom cible)."""
+
+    label: str
+    target_scene_name: str
+    condition: str | None = None
+
+
+class RoomBranchHintDTO(BaseModel):
+    """Sortie d'une pièce vers une autre pièce du même lieu (donjon)."""
+
+    label: str
+    target_room_name: str
+    condition: str | None = None
+
+
+class RoomSummaryDTO(BaseModel):
+    """Pièce d'un lieu explorable. Omise par le Core si la scène est classique."""
+
+    name: str
+    floor: int | None = None
+    description: str | None = None
+    enemies: str | None = None
+    branches: list[RoomBranchHintDTO] = Field(default_factory=list)
+
+
+class SceneSummaryDTO(BaseModel):
+    """Résumé d'une scène : nom + description courte (synopsis)."""
+
+    name: str
+    description: str | None = None
+    # Optionnel : le Core Java ne serialise illustration_count QUE si > 0
+    # (payload plus leger). Defaut 0 = pas d'illustrations ou champ absent.
+    illustration_count: int = 0
+    # Branches narratives sortantes, omises cote Core si vides.
+    branches: list[SceneBranchHintDTO] = Field(default_factory=list)
+    # Pièces du lieu explorable, omises par Core si scène classique.
+    rooms: list[RoomSummaryDTO] = Field(default_factory=list)
+
+
+class ChapterSummaryDTO(BaseModel):
+    """Résumé d'un chapitre : nom + description courte + ses scènes."""
+
+    name: str
+    description: str | None = None
+    scenes: list[SceneSummaryDTO] = Field(default_factory=list)
+    illustration_count: int = 0
+
+
+class ArcSummaryDTO(BaseModel):
+    """Résumé d'un arc narratif : nom + description courte + ses chapitres."""
+
+    name: str
+    description: str | None = None
+    chapters: list[ChapterSummaryDTO] = Field(default_factory=list)
+    illustration_count: int = 0
+
+
+class CharacterSummaryDTO(BaseModel):
+    """Résumé d'un PJ : nom + snippet. Pas de fiche complète au niveau résumé."""
+
+    name: str
+    snippet: str = ""
+
+
+class NpcSummaryDTO(BaseModel):
+    """Résumé d'un PNJ : symétrique à CharacterSummaryDTO."""
+
+    name: str
+    snippet: str = ""
+
+
+class CampaignContextDTO(BaseModel):
+    """Carte narrative enrichie : arcs → chapitres → scènes avec synopsis."""
+
+    campaign_name: str
+    campaign_description: str | None = None
+    arcs: list[ArcSummaryDTO] = Field(default_factory=list)
+    characters: list[CharacterSummaryDTO] = Field(default_factory=list)
+    npcs: list[NpcSummaryDTO] = Field(default_factory=list)
+
+
+class NarrativeEntityDTO(BaseModel):
+    """Entité narrative (arc/chapter/scene/character) en cours d'édition — focus optionnel."""
+
+    entity_type: str = Field(pattern="^(arc|chapter|scene|character|npc)$")
+    title: str
+    fields: dict[str, str] = Field(default_factory=dict)
+
+
+class GameSystemContextDTO(BaseModel):
+    """Règles de JDR présélectionnées par le Core (filtrées par intent).
+
+    Les sections sont un dict titre_H2 → contenu_markdown. Peuvent être
+    vides si aucune section ne matchait l'intent de génération courant.
+    """
+
+    system_name: str
+    system_description: str | None = None
+    sections: dict[str, str] = Field(default_factory=dict)
+
+
+class JournalEntrySummaryDTO(BaseModel):
+    """Une entrée du journal de session.
+
+    `source_session_name` est présent uniquement pour les évènements issus
+    des sessions précédentes — sert à ancrer temporellement dans le prompt.
+    """
+
+    type: str
+    content: str
+    occurred_at: str | None = None
+    source_session_name: str | None = None
+
+
+class QuestSummaryDTO(BaseModel):
+    """Résumé d'une quête (Chapter dans un Arc HUB). Voir QuestSummary côté domaine."""
+
+    name: str
+    arc_name: str
+    description: str | None = None
+
+
+class SessionContextDTO(BaseModel):
+    """Contexte d'une Session de jeu en cours (Play Context).
+
+    Combine le journal complet (`entries`), les EVENTs des sessions précédentes
+    (`previous_events`), et — depuis l'ajout du mode Hub — l'état des quêtes
+    Hub de la campagne (disponibles / en cours / verrouillées) plus les flags
+    narratifs actuellement actifs.
+    """
+
+    session_name: str
+    active: bool
+    started_at: str | None = None
+    entries: list[JournalEntrySummaryDTO] = Field(default_factory=list)
+    previous_events: list[JournalEntrySummaryDTO] = Field(default_factory=list)
+    available_quests: list[QuestSummaryDTO] = Field(default_factory=list)
+    in_progress_quests: list[QuestSummaryDTO] = Field(default_factory=list)
+    locked_quest_titles: list[str] = Field(default_factory=list)
+    active_flags: list[str] = Field(default_factory=list)
+
+
+class ChatStreamRequestDTO(BaseModel):
+    """Requête de chat streamé : historique + contextes structurels.
+
+    Les contextes (lore, page, campaign, narrative_entity, session) sont
+    optionnels, mais au moins l'un des contextes "racines" (lore_context,
+    campaign_context ou session_context) doit être fourni. Le validateur
+    `check_scope` applique cette règle à la frontière HTTP.
+    """
+
+    messages: list[ChatMessageDTO] = Field(min_length=1)
+    lore_context: LoreContextDTO | None = None
+    page_context: PageContextDTO | None = None
+    campaign_context: CampaignContextDTO | None = None
+    narrative_entity: NarrativeEntityDTO | None = None
+    game_system_context: GameSystemContextDTO | None = None
+    session_context: SessionContextDTO | None = None
+
+    def has_scope(self) -> bool:
+        """Vrai si au moins un contexte racine (Lore, Campagne ou Session) est fourni."""
+        return (
+            self.lore_context is not None
+            or self.campaign_context is not None
+            or self.session_context is not None
+        )

brain/app/api/chat_mapping.py

@@ -0,0 +1,192 @@
+"""Mapping DTO → domaine (couche anti-corruption de la frontière HTTP).
+
+Traduit les DTOs Pydantic du chat contextuel en dataclasses du domaine :
+le cœur métier ne dépend ainsi jamais de Pydantic ni du format JSON du Core.
+"""
+from app.api.chat_dto import (
+    CampaignContextDTO,
+    GameSystemContextDTO,
+    JournalEntrySummaryDTO,
+    LoreContextDTO,
+    NarrativeEntityDTO,
+    PageContextDTO,
+    PageSummaryDTO,
+    QuestSummaryDTO,
+    SessionContextDTO,
+)
+from app.domain.models import (
+    ArcSummary,
+    CampaignStructuralContext,
+    ChapterSummary,
+    CharacterSummary,
+    GameSystemContext,
+    JournalEntrySummary,
+    LoreStructuralContext,
+    NarrativeEntityContext,
+    NpcSummary,
+    PageContext,
+    PageSummary,
+    QuestSummary,
+    RoomBranchHint,
+    RoomSummary,
+    SceneBranchHint,
+    SceneSummary,
+    SessionContext,
+)
+
+
+def to_lore_context(dto: LoreContextDTO | None) -> LoreStructuralContext | None:
+    if dto is None:
+        return None
+    return LoreStructuralContext(
+        lore_name=dto.lore_name,
+        lore_description=dto.lore_description,
+        folders={
+            folder: [_to_page_summary(p) for p in pages]
+            for folder, pages in dto.folders.items()
+        },
+        tags=dto.tags,
+    )
+
+
+def _to_page_summary(dto: PageSummaryDTO) -> PageSummary:
+    return PageSummary(
+        title=dto.title,
+        template_name=dto.template_name,
+        values=dict(dto.values),
+        tags=list(dto.tags),
+        related_page_titles=list(dto.related_page_titles),
+    )
+
+
+def to_page_context(dto: PageContextDTO | None) -> PageContext | None:
+    if dto is None:
+        return None
+    return PageContext(
+        title=dto.title,
+        template_name=dto.template_name,
+        template_fields=dto.template_fields,
+        values=dto.values,
+    )
+
+
+def to_campaign_context(dto: CampaignContextDTO | None) -> CampaignStructuralContext | None:
+    if dto is None:
+        return None
+    arcs = [
+        ArcSummary(
+            name=arc.name,
+            description=arc.description,
+            illustration_count=arc.illustration_count,
+            chapters=[
+                ChapterSummary(
+                    name=ch.name,
+                    description=ch.description,
+                    illustration_count=ch.illustration_count,
+                    scenes=[
+                        SceneSummary(
+                            name=sc.name,
+                            description=sc.description,
+                            illustration_count=sc.illustration_count,
+                            branches=[
+                                SceneBranchHint(
+                                    label=br.label,
+                                    target_scene_name=br.target_scene_name,
+                                    condition=br.condition,
+                                )
+                                for br in sc.branches
+                            ],
+                            rooms=[
+                                RoomSummary(
+                                    name=room.name,
+                                    floor=room.floor,
+                                    description=room.description,
+                                    enemies=room.enemies,
+                                    branches=[
+                                        RoomBranchHint(
+                                            label=rb.label,
+                                            target_room_name=rb.target_room_name,
+                                            condition=rb.condition,
+                                        )
+                                        for rb in room.branches
+                                    ],
+                                )
+                                for room in sc.rooms
+                            ],
+                        )
+                        for sc in ch.scenes
+                    ],
+                )
+                for ch in arc.chapters
+            ],
+        )
+        for arc in dto.arcs
+    ]
+    characters = [
+        CharacterSummary(name=c.name, snippet=c.snippet)
+        for c in dto.characters
+    ]
+    npcs = [
+        NpcSummary(name=n.name, snippet=n.snippet)
+        for n in dto.npcs
+    ]
+    return CampaignStructuralContext(
+        campaign_name=dto.campaign_name,
+        campaign_description=dto.campaign_description,
+        arcs=arcs,
+        characters=characters,
+        npcs=npcs,
+    )
+
+
+def to_narrative_entity(dto: NarrativeEntityDTO | None) -> NarrativeEntityContext | None:
+    if dto is None:
+        return None
+    return NarrativeEntityContext(
+        entity_type=dto.entity_type,
+        title=dto.title,
+        fields=dict(dto.fields),
+    )
+
+
+def to_game_system_context(dto: GameSystemContextDTO | None) -> GameSystemContext | None:
+    if dto is None:
+        return None
+    return GameSystemContext(
+        system_name=dto.system_name,
+        system_description=dto.system_description,
+        sections=dict(dto.sections),
+    )
+
+
+def to_session_context(dto: SessionContextDTO | None) -> SessionContext | None:
+    if dto is None:
+        return None
+    return SessionContext(
+        session_name=dto.session_name,
+        active=dto.active,
+        started_at=dto.started_at,
+        entries=[_to_journal_entry(e) for e in dto.entries],
+        previous_events=[_to_journal_entry(e) for e in dto.previous_events],
+        available_quests=[_to_quest_summary(q) for q in dto.available_quests],
+        in_progress_quests=[_to_quest_summary(q) for q in dto.in_progress_quests],
+        locked_quest_titles=list(dto.locked_quest_titles),
+        active_flags=list(dto.active_flags),
+    )
+
+
+def _to_quest_summary(dto: QuestSummaryDTO) -> QuestSummary:
+    return QuestSummary(
+        name=dto.name,
+        arc_name=dto.arc_name,
+        description=dto.description,
+    )
+
+
+def _to_journal_entry(dto: JournalEntrySummaryDTO) -> JournalEntrySummary:
+    return JournalEntrySummary(
+        type=dto.type,
+        content=dto.content,
+        occurred_at=dto.occurred_at,
+        source_session_name=dto.source_session_name,
+    )

brain/app/api/common.py

@@ -0,0 +1,26 @@
+"""Utilitaires partagés des routers : encodage SSE + garde-fous d'upload PDF."""
+from __future__ import annotations
+
+import json
+
+# Garde-fou taille : un livre de règles dépasse rarement quelques dizaines de Mo.
+# Au-delà, on refuse (probable erreur d'upload) plutôt que d'OOM le conteneur.
+MAX_PDF_BYTES = 60 * 1024 * 1024  # 60 Mo
+
+
+def sse_event(event: str, data: dict) -> str:
+    """Encode un évènement Server-Sent Events (accents préservés)."""
+    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
+
+
+def pdf_upload_error(content: bytes) -> str | None:
+    """Message d'erreur si l'upload PDF est invalide (vide / trop gros), sinon None.
+
+    Utilisé par les flux SSE, où l'erreur doit partir en évènement `error`
+    plutôt qu'en HTTPException (le flux est déjà ouvert en 200).
+    """
+    if not content:
+        return "Fichier PDF vide."
+    if len(content) > MAX_PDF_BYTES:
+        return f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo)."
+    return None

brain/app/api/deps.py

@@ -0,0 +1,191 @@
+"""Factories d'injection de dépendance — le point d'inversion de l'hexagone.
+
+C'est ICI (et seulement ici) qu'on choisit QUEL adapter concret incarne chaque
+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
+
+from app.application.adapt_campaign import AdaptCampaignUseCase
+from app.application.chat import ChatUseCase
+from app.application.embeddings import EmbeddingError
+from app.application.generate_page import GeneratePageUseCase
+from app.application.import_campaign import ImportCampaignUseCase
+from app.application.import_rules import ImportRulesUseCase
+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.domain.ports import LLMProvider, LLMProviderError
+from app.infrastructure.gemini_adapter import GeminiLLMProvider
+from app.infrastructure.mistral_adapter import MistralLLMProvider
+from app.infrastructure.mistral_embedding_adapter import MistralEmbeddingProvider
+from app.infrastructure.ollama_adapter import OllamaLLMProvider
+from app.infrastructure.ollama_embedding_adapter import OllamaEmbeddingProvider
+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:
+    """Factory d'adapter — point d'inversion de dépendance.
+
+    C'est ici (et uniquement ici) qu'on choisit QUEL adapter concret
+    incarne le port, en fonction du champ `llm_provider` des Settings
+    (modifiable a chaud depuis l'ecran Parametres de l'UI).
+    """
+    try:
+        if settings.llm_provider == "onemin":
+            return OneMinAiLLMProvider(settings)
+        if settings.llm_provider == "openrouter":
+            return OpenRouterLLMProvider(settings)
+        if settings.llm_provider == "mistral":
+            return MistralLLMProvider(settings)
+        if settings.llm_provider == "gemini":
+            return GeminiLLMProvider(settings)
+        return OllamaLLMProvider(settings)
+    except LLMProviderError as exc:
+        # Ex : cle 1min.ai manquante. On renvoie du 400 plutot que du 500
+        # pour que le frontend puisse afficher un message actionnable.
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+def get_generate_page_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+) -> GeneratePageUseCase:
+    """Factory du use case — injecte le port LLMProvider sans connaître l'adapter."""
+    return GeneratePageUseCase(llm=llm)
+
+
+def get_chat_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+) -> ChatUseCase:
+    """Factory du use case chat.
+
+    L'adapter OllamaLLMProvider satisfait les deux protocoles (LLMProvider
+    et LLMChatProvider) par duck typing ; on lui passe la même instance.
+    """
+    return ChatUseCase(llm=llm)  # type: ignore[arg-type]
+
+
+def get_import_rules_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    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=_effective_import_chunk_tokens(settings),
+        segment_only=settings.llm_provider == "ollama")
+
+
+def get_import_campaign_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> ImportCampaignUseCase:
+    """Factory du use case d'import de campagne PDF (extraction + arborescence)."""
+    return ImportCampaignUseCase(
+        llm=llm,
+        extractor=_PDF_EXTRACTOR,
+        chunk_target_tokens=_effective_import_chunk_tokens(settings),
+        map_concurrency=settings.llm_map_concurrency,
+    )
+
+
+def get_adapt_campaign_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> AdaptCampaignUseCase:
+    """Factory du use case d'adaptation d'un PDF à une campagne (conseils streamés)."""
+    # L'adapter satisfait aussi LLMChatProvider (stream_chat) par duck typing.
+    # Budget d'entrée = taille de morceau configurée (qui passe déjà côté provider).
+    return AdaptCampaignUseCase(  # type: ignore[arg-type]
+        llm=llm, extractor=_PDF_EXTRACTOR, max_input_tokens=settings.import_chunk_tokens)
+
+
+def get_embedding_provider(
+    settings: Annotated[Settings, Depends(get_settings)],
+):
+    """Factory de l'adapter d'embeddings (RAG) selon `embedding_provider`."""
+    try:
+        if settings.embedding_provider == "mistral":
+            return MistralEmbeddingProvider(settings)
+        return OllamaEmbeddingProvider(settings)
+    except EmbeddingError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+def get_notebook_rag_use_case(
+    embedder: Annotated[object, Depends(get_embedding_provider)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> NotebookRagUseCase:
+    return NotebookRagUseCase(
+        extractor=_PDF_EXTRACTOR,
+        embedder=embedder,  # type: ignore[arg-type]
+        min_score=settings.rag_min_score,
+    )
+
+
+def get_notebook_chat_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    rag: Annotated[NotebookRagUseCase, Depends(get_notebook_rag_use_case)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> NotebookChatUseCase:
+    return NotebookChatUseCase(
+        rag=rag, llm=llm, rerank_enabled=settings.rag_rerank)  # type: ignore[arg-type]
+
+
+def get_notebook_deep_use_case(
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    embedder: Annotated[object, Depends(get_embedding_provider)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> NotebookDeepUseCase:
+    return NotebookDeepUseCase(
+        llm=llm,
+        batch_tokens=settings.import_chunk_tokens,
+        map_concurrency=settings.llm_map_concurrency,
+        embedder=embedder,
+        summary_filter=settings.deep_summary_filter,
+    )

brain/app/api/routers/__init__.py

@@ -0,0 +1,5 @@
+"""Routers FastAPI du Brain, un par responsabilité métier.
+
+Chemins inchangés par rapport à l'ancien main.py monolithique : le Core Java
+et le frontend ne voient AUCUNE différence.
+"""

brain/app/api/routers/chat.py

@@ -0,0 +1,123 @@
+"""Endpoint du chat contextuel (/chat/stream) : Structural Context + jauge tokens."""
+import json
+from typing import Annotated, AsyncIterator
+
+import tiktoken
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+
+from app.api.chat_dto import ChatStreamRequestDTO
+from app.api.chat_mapping import (
+    to_campaign_context,
+    to_game_system_context,
+    to_lore_context,
+    to_narrative_entity,
+    to_page_context,
+    to_session_context,
+)
+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
+
+router = APIRouter()
+
+# Encodeur tiktoken partagé — chargé une fois pour éviter le coût de lookup
+# à chaque requête. On utilise cl100k_base (GPT-3.5/4) comme tokenizer
+# universel approximatif : ±10% d'écart avec Llama/Gemma mais largement
+# suffisant pour une jauge visuelle à l'utilisateur.
+_TOKEN_ENCODER: tiktoken.Encoding | None = None
+
+
+def _count_tokens(text: str | None) -> int:
+    """Compte les tokens d'un texte via tiktoken. Null/empty → 0."""
+    if not text:
+        return 0
+    global _TOKEN_ENCODER
+    if _TOKEN_ENCODER is None:
+        _TOKEN_ENCODER = tiktoken.get_encoding("cl100k_base")
+    return len(_TOKEN_ENCODER.encode(text))
+
+
+@router.post("/chat/stream")
+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.
+
+    Accepte jusqu'à 4 contextes optionnels (Lore, Page focalisée, Campagne,
+    entité narrative focalisée). Au moins un contexte racine (Lore ou
+    Campagne) est requis pour que la requête ait du sens.
+
+    Format de flux :
+      - Chaque token : `data: {"token": "..."}\\n\\n`
+      - Fin normale  : `event: done\\ndata: {}\\n\\n`
+      - Erreur LLM   : `event: error\\ndata: {"message": "..."}\\n\\n`
+    """
+    if not body.has_scope():
+        raise HTTPException(
+            status_code=422,
+            detail="Au moins un des deux contextes racines (lore_context ou campaign_context) est requis.",
+        )
+
+    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
+    lore_context = to_lore_context(body.lore_context)
+    page_context = to_page_context(body.page_context)
+    campaign_context = to_campaign_context(body.campaign_context)
+    narrative_entity = to_narrative_entity(body.narrative_entity)
+    game_system_context = to_game_system_context(body.game_system_context)
+    session_context = to_session_context(body.session_context)
+
+    # --- Comptage tokens pour la jauge de contexte frontend ---
+    # On construit le system prompt une fois ici pour le compter — le use case
+    # le reconstruira à l'identique en interne (coût négligeable : concat de str).
+    # Cette duplication évite de complexifier le contrat stream() avec un
+    # paramètre optionnel system_prompt précalculé.
+    system_prompt_preview = use_case.build_system_prompt(
+        lore_context=lore_context,
+        page_context=page_context,
+        campaign_context=campaign_context,
+        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
+    history_msgs = messages[:-1] if messages else []
+    settings = get_settings()
+    usage_payload = {
+        "system": _count_tokens(system_prompt_preview),
+        "history": sum(_count_tokens(m.content) for m in history_msgs),
+        "current": _count_tokens(current_msg.content) if current_msg else 0,
+        # Plafond connu seulement pour Ollama (num_ctx). Pour le cloud (1min/OpenRouter)
+        # on ne connaît pas la fenêtre réelle → 0 = "pas de max" (jauge sans dénominateur).
+        "max": settings.llm_num_ctx if settings.llm_provider == "ollama" else 0,
+    }
+
+    async def event_stream() -> AsyncIterator[str]:
+        # Event 'usage' émis en tout premier : le frontend peut afficher la
+        # jauge avant même le premier token de réponse.
+        yield f"event: usage\ndata: {json.dumps(usage_payload, ensure_ascii=False)}\n\n"
+        try:
+            async for token in use_case.stream(
+                messages,
+                lore_context=lore_context,
+                page_context=page_context,
+                campaign_context=campaign_context,
+                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"
+            yield "event: done\ndata: {}\n\n"
+        except LLMProviderError as exc:
+            yield f"event: error\ndata: {json.dumps({'message': str(exc)})}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")

brain/app/api/routers/generation.py

@@ -0,0 +1,292 @@
+"""Endpoints de génération « simple » : prompt libre, page de Lore, auto-titre."""
+from typing import Annotated, Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+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.llm_json import load_json_object
+from app.application.llm_retry import generate_with_retry
+from app.application.prompts import conversation_title as title_prompts
+from app.application.prompts import narrative_fields as narrative_fields_prompts
+from app.application.prompts import scene_drafts as scene_drafts_prompts
+from app.application.prompts import session_recap as session_recap_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
+
+router = APIRouter()
+
+
+class GenerateRequest(BaseModel):
+    prompt: str
+
+
+class GenerateResponse(BaseModel):
+    model: str
+    response: str
+
+
+@router.post("/generate", response_model=GenerateResponse)
+async def generate(
+    body: GenerateRequest,
+    settings: Annotated[Settings, Depends(get_settings)],
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+) -> GenerateResponse:
+    """Endpoint libre : prompt → texte brut. Utile pour debug et exploration."""
+    try:
+        text = await llm.generate(body.prompt)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    return GenerateResponse(model=settings.llm_model, response=text)
+
+
+class GeneratePageRequestDTO(BaseModel):
+    """Contexte envoyé par le Core Java pour remplir une page via le LLM."""
+
+    lore_name: str
+    folder_name: str
+    template_name: str
+    template_fields: list[str] = Field(min_length=1)
+    page_title: str
+    lore_description: str | None = None
+
+
+class GeneratePageResponseDTO(BaseModel):
+    """Retour : une valeur textuelle par champ du template (clé = field name)."""
+
+    values: dict[str, str]
+
+
+@router.post("/generate-page", response_model=GeneratePageResponseDTO)
+async def generate_page(
+    body: GeneratePageRequestDTO,
+    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.
+
+    Branche tout le use case `GeneratePageUseCase`. Ce controller ne fait
+    que le mapping DTO ↔ dataclass et la traduction d'erreur domaine → HTTP.
+    """
+    context = PageGenerationContext(
+        lore_name=body.lore_name,
+        lore_description=body.lore_description,
+        folder_name=body.folder_name,
+        template_name=body.template_name,
+        template_fields=body.template_fields,
+        page_title=body.page_title,
+    )
+
+    try:
+        result = await use_case.execute(context, language=language)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    return GeneratePageResponseDTO(values=result.values)
+
+
+# --- Auto-titre d'une conversation persistee --------------------------------
+
+
+class SummarizeTitleMessageDTO(BaseModel):
+    role: Literal["user", "assistant", "system"]
+    content: str
+
+
+class SummarizeTitleRequestDTO(BaseModel):
+    """Premiers messages d'une conversation pour auto-generer un titre court."""
+
+    messages: list[SummarizeTitleMessageDTO] = Field(default_factory=list)
+
+
+class SummarizeTitleResponseDTO(BaseModel):
+    title: str
+
+
+@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.
+
+    Appele par le core apres le 1er couple user/assistant, pour remplacer le
+    titre provisoire "Nouvelle conversation" par quelque chose de parlant.
+    """
+    if not body.messages:
+        raise HTTPException(status_code=422, detail="Au moins un message requis")
+
+    transcript = "\n".join(f"{m.role.upper()}: {m.content}" for m in body.messages[:6])
+    prompt = f"{title_prompts.title_system_prompt(language)}\n\nConversation :\n{transcript}\n\nTitre :"
+    try:
+        raw = await llm.generate(prompt)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    title = raw.strip().splitlines()[0].strip().strip('"').strip("'").rstrip(".")
+    if len(title) > 80:
+        title = title[:80].rstrip()
+    if not title:
+        title = title_prompts.TITLE_FALLBACK.get(language, title_prompts.TITLE_FALLBACK["fr"])
+    return SummarizeTitleResponseDTO(title=title)
+
+
+# --- Étoffer une entité narrative (Pilier A : co-MJ propose → l'humain valide) ----------
+
+
+class NarrativeFieldSpecDTO(BaseModel):
+    """Un champ autorisé : clé technique + libellé lisible (fourni par le Core)."""
+
+    key: str
+    label: str = Field(default="")
+
+
+class NarrativeFieldsRequestDTO(BaseModel):
+    """Contexte envoyé par le Core pour proposer des valeurs de champs (arc/chapitre/scène)."""
+
+    entity_type: str = Field(default="")
+    context: str = Field(default="")
+    instruction: str = Field(default="")
+    # Whitelist (clé + libellé) fournie par le Core, source de vérité.
+    fields: list[NarrativeFieldSpecDTO] = Field(default_factory=list)
+
+
+class NarrativeFieldsResponseDTO(BaseModel):
+    """Retour : une valeur proposée par clé (uniquement des clés autorisées, non vides)."""
+
+    fields: dict[str, str]
+
+
+@router.post("/generate/narrative-fields", response_model=NarrativeFieldsResponseDTO)
+async def generate_narrative_fields(
+    body: NarrativeFieldsRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> NarrativeFieldsResponseDTO:
+    """Propose des valeurs pour ÉTOFFER une entité narrative (patch champ par champ, non appliqué).
+
+    Whitelist stricte : on ne retient que les clés autorisées, non vides. Un objet vide
+    est une réponse VALIDE (le modèle n'a rien de pertinent à proposer — l'entité est
+    peut-être déjà complète) ; seule une sortie non-JSON est une erreur.
+    """
+    allowed = {f.key for f in body.fields if f.key}
+    prompt = narrative_fields_prompts.narrative_fields_prompt(
+        body.entity_type, body.context, body.instruction,
+        [{"key": f.key, "label": f.label} for f in body.fields], language)
+    try:
+        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    parsed, _ = load_json_object(raw)
+    if not isinstance(parsed, dict):
+        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de champs exploitables.")
+
+    out: dict[str, str] = {}
+    raw_fields = parsed.get("fields")
+    if isinstance(raw_fields, dict):
+        for key, value in raw_fields.items():
+            if key not in allowed:
+                continue
+            if not isinstance(value, (str, int, float)):
+                continue
+            text = str(value).strip()
+            if text:
+                out[str(key)] = text
+    return NarrativeFieldsResponseDTO(fields=out)
+
+
+# --- Peupler un chapitre en scènes (Pilier A : capacité « create ») ----------
+
+
+class SceneDraftsRequestDTO(BaseModel):
+    """Contexte envoyé par le Core pour ébaucher des scènes d'un chapitre."""
+
+    context: str = Field(default="")
+    instruction: str = Field(default="")
+    count: int = Field(default=4)
+
+
+class SceneDraftDTO(BaseModel):
+    name: str
+    description: str = Field(default="")
+    playerNarration: str = Field(default="")
+
+
+class SceneDraftsResponseDTO(BaseModel):
+    scenes: list[SceneDraftDTO]
+
+
+@router.post("/generate/scene-drafts", response_model=SceneDraftsResponseDTO)
+async def generate_scene_drafts(
+    body: SceneDraftsRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> SceneDraftsResponseDTO:
+    """Propose des ébauches de scènes pour un chapitre (non créées). Un titre par scène
+    est obligatoire ; on borne le nombre. Seule une sortie non-JSON est une erreur."""
+    n = max(1, min(8, body.count))
+    prompt = scene_drafts_prompts.scene_drafts_prompt(body.context, body.instruction, n, language)
+    try:
+        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.8)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    parsed, _ = load_json_object(raw)
+    if not isinstance(parsed, dict):
+        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de scènes exploitables.")
+
+    scenes: list[SceneDraftDTO] = []
+    for s in (parsed.get("scenes") or [])[:n]:
+        if not isinstance(s, dict):
+            continue
+        name = str(s.get("name") or "").strip()
+        if not name:
+            continue
+        scenes.append(SceneDraftDTO(
+            name=name[:200],
+            description=str(s.get("description") or "").strip(),
+            playerNarration=str(s.get("playerNarration") or "").strip(),
+        ))
+    return SceneDraftsResponseDTO(scenes=scenes)
+
+
+# --- Récap « précédemment… » d'une séance (mode cockpit) ---------------------
+
+
+class SessionRecapRequestDTO(BaseModel):
+    """Journal chronologique de la séance précédente + méta courte."""
+
+    transcript: str
+    context: str = Field(default="")
+
+
+class SessionRecapResponseDTO(BaseModel):
+    recap: str
+
+
+@router.post("/generate/session-recap", response_model=SessionRecapResponseDTO)
+async def generate_session_recap(
+    body: SessionRecapRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> SessionRecapResponseDTO:
+    """Rédige le récap « Précédemment… » à lire aux joueurs (texte libre, pas de JSON)."""
+    if not body.transcript.strip():
+        raise HTTPException(status_code=422, detail="Journal vide : rien à résumer.")
+    prompt = session_recap_prompts.session_recap_prompt(body.transcript, body.context, language)
+    try:
+        raw = await generate_with_retry(llm, prompt, temperature=0.7)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+    recap = raw.strip()
+    if not recap:
+        raise HTTPException(status_code=502, detail="Le modèle n'a renvoyé aucun récit.")
+    return SessionRecapResponseDTO(recap=recap)

brain/app/api/routers/imports.py

@@ -0,0 +1,188 @@
+"""Endpoints d'import/adaptation de PDF (règles, campagne) — REST + flux SSE."""
+import json
+import logging
+from typing import Annotated, AsyncIterator
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from app.api.common import MAX_PDF_BYTES, pdf_upload_error, sse_event
+from app.api.deps import (
+    get_adapt_campaign_use_case,
+    get_import_campaign_use_case,
+    get_import_rules_use_case,
+)
+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
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class RulesImportResponseDTO(BaseModel):
+    """Proposition de sections de règles extraites d'un PDF.
+
+    `sections` = {titre → contenu markdown}. C'est une PROPOSITION : le Core
+    et l'UI laissent l'utilisateur réviser/éditer avant toute persistance.
+    `ocr_page_count` permet d'indiquer si le PDF était un scan (OCR utilisé).
+    """
+
+    sections: dict[str, str]
+    page_count: int
+    ocr_page_count: int
+
+
+@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).
+
+    Extrait le texte (couche texte + repli OCR par page pour les scans), découpe,
+    et demande au LLM de répartir les règles en sections thématiques. Ne persiste
+    rien : renvoie la proposition au Core, qui la présente pour révision.
+    """
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=422, detail="Fichier PDF vide.")
+    if len(content) > MAX_PDF_BYTES:
+        raise HTTPException(
+            status_code=413,
+            detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).",
+        )
+
+    try:
+        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:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    return RulesImportResponseDTO(
+        sections=result.sections,
+        page_count=result.page_count,
+        ocr_page_count=result.ocr_page_count,
+    )
+
+
+@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.
+
+    Évènements SSE :
+      - `event: extracting`  → data: {}                    (extraction en cours)
+      - `event: start`       → data: {page_count, ocr_page_count, total}
+      - `event: progress`    → data: {current, total, new_sections:[...]}
+      - `event: done`        → data: {sections, page_count, ocr_page_count}
+      - `event: error`       → data: {message}
+    """
+    content = await file.read()
+
+    async def event_stream() -> AsyncIterator[str]:
+        upload_error = pdf_upload_error(content)
+        if upload_error:
+            yield sse_event("error", {"message": upload_error})
+            return
+        try:
+            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:
+            yield sse_event("error", {"message": str(exc)})
+        except LLMProviderError as exc:
+            yield sse_event("error", {"message": str(exc)})
+        except Exception as exc:  # noqa: BLE001 — filet : une erreur inattendue ne doit
+            # PAS casser le flux SSE brutalement (sinon le Core n'a qu'un message générique
+            # sans détail). On la transforme en évènement `error` propre + log avec trace.
+            logger.exception("Import règles : erreur inattendue dans le flux.")
+            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+@router.post("/import/campaign/stream")
+async def import_campaign_stream(
+    use_case: Annotated[ImportCampaignUseCase, Depends(get_import_campaign_use_case)],
+    file: UploadFile = File(...),
+) -> StreamingResponse:
+    """Import streamé d'un PDF de campagne → arbre arc→chapitre→scène (SSE).
+
+    Évènements : `extracting`, `start` {page_count, ocr_page_count, total},
+    `progress` {current, total, arc_count, chapter_count, scene_count},
+    `done` {arcs:[...], page_count, ocr_page_count}, `error` {message}.
+    """
+    content = await file.read()
+
+    async def event_stream() -> AsyncIterator[str]:
+        upload_error = pdf_upload_error(content)
+        if upload_error:
+            yield sse_event("error", {"message": upload_error})
+            return
+        try:
+            async for ev in use_case.stream(content):
+                event_type = ev.pop("type")
+                yield sse_event(event_type, ev)
+        except PdfExtractionError as exc:
+            yield sse_event("error", {"message": str(exc)})
+        except LLMProviderError as exc:
+            yield sse_event("error", {"message": str(exc)})
+        except Exception as exc:  # noqa: BLE001 — voir import règles : on ne laisse pas
+            # une erreur inattendue casser le flux sans détail.
+            logger.exception("Import campagne : erreur inattendue dans le flux.")
+            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
+
+    return StreamingResponse(event_stream(), media_type="text/event-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("[]"),
+) -> StreamingResponse:
+    """Adaptation CONVERSATIONNELLE d'un PDF à une campagne (SSE markdown).
+
+    `brief` = description de la campagne (Core). `messages` = JSON de l'échange
+    ([{role, content}, …]) ; vide au 1er tour. Évènements : `token`, `done`, `error`.
+    """
+    content = await file.read()
+
+    try:
+        raw_messages = json.loads(messages) if messages else []
+    except json.JSONDecodeError:
+        raw_messages = []
+    convo = [
+        ChatMessage(role=str(m.get("role", "user")), content=str(m.get("content", "")))
+        for m in raw_messages
+        if isinstance(m, dict) and str(m.get("content", "")).strip()
+    ]
+
+    async def event_stream() -> AsyncIterator[str]:
+        upload_error = pdf_upload_error(content)
+        if upload_error:
+            yield sse_event("error", {"message": upload_error})
+            return
+        try:
+            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:
+            yield sse_event("error", {"message": str(exc)})
+        except LLMProviderError as exc:
+            yield sse_event("error", {"message": str(exc)})
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")

brain/app/api/routers/models.py

@@ -0,0 +1,365 @@
+"""Endpoints de catalogue de modèles (Ollama, OpenRouter, Mistral, Gemini, 1min.ai).
+
+Proxifie les APIs des providers pour que l'UI propose des listes de modèles ;
+repli statique quand l'API est injoignable ou la clé absente (pas de 500 à l'UI).
+"""
+import json
+from typing import Annotated, AsyncIterator
+
+import httpx
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from app.core.config import Settings, get_settings
+
+router = APIRouter()
+
+
+@router.get("/models/ollama")
+async def list_ollama_models(
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> dict[str, list[str]]:
+    """Liste les modeles disponibles sur le serveur Ollama configure.
+
+    Retourne une liste vide si Ollama est injoignable — l'UI affichera un
+    message plutot qu'une 500.
+    """
+    url = f"{settings.ollama_base_url}/api/tags"
+    try:
+        async with httpx.AsyncClient(timeout=5) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPError:
+        return {"models": []}
+    models = [m.get("name", "") for m in data.get("models", []) if m.get("name")]
+    return {"models": sorted(models)}
+
+
+class OllamaModelInfoDTO(BaseModel):
+    """Info utile extraite de /api/show pour un modele Ollama donne.
+
+    `context_length` = fenetre de contexte max supportee par le modele
+    (extraite des metadonnees GGUF). 0 si inconnue. Le frontend s'en sert
+    pour borner le slider de num_ctx dans les Parametres.
+    """
+
+    context_length: int = 0
+
+
+@router.post("/models/ollama/info", response_model=OllamaModelInfoDTO)
+async def get_ollama_model_info(
+    body: dict[str, str],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> OllamaModelInfoDTO:
+    """Retourne les metadonnees d'un modele Ollama via /api/show.
+
+    On passe par POST (et pas GET /models/ollama/{name}) parce que les noms
+    Ollama contiennent souvent un `:` (ex: `gemma3:e2b`) qui se segmente
+    mal dans une URL — le body JSON evite le probleme d'escaping.
+
+    Le champ qui nous interesse est `model_info["<arch>.context_length"]`
+    (ex: `gemma3.context_length: 131072`). L'arch varie selon le modele, on
+    scanne donc tous les champs finissant par `.context_length`.
+    """
+    name = (body.get("name") or "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="name requis")
+    url = f"{settings.ollama_base_url}/api/show"
+    try:
+        async with httpx.AsyncClient(timeout=5) as client:
+            response = await client.post(url, json={"model": name})
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPError:
+        return OllamaModelInfoDTO(context_length=0)
+    model_info = data.get("model_info") or {}
+    for key, value in model_info.items():
+        if key.endswith(".context_length") and isinstance(value, int):
+            return OllamaModelInfoDTO(context_length=value)
+    return OllamaModelInfoDTO(context_length=0)
+
+
+@router.post("/models/ollama/pull")
+async def pull_ollama_model(
+    body: dict[str, str],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> StreamingResponse:
+    """Telecharge un modele depuis Ollama et streame la progression.
+
+    Proxifie l'endpoint `/api/pull` d'Ollama qui renvoie du JSON ligne par
+    ligne (NDJSON) avec le statut de chaque etape : manifest, layers,
+    digest, success. On reemet ce flux tel quel au client (le front
+    parsera les lignes et affichera une barre de progression).
+
+    Le timeout est intentionnellement tres long (60 min) car certains
+    modeles font 30+ Go.
+    """
+    name = (body.get("name") or "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="name requis")
+    url = f"{settings.ollama_base_url}/api/pull"
+
+    async def stream() -> AsyncIterator[bytes]:
+        # On utilise un timeout long pour la lecture (60 min) mais court pour
+        # la connexion (10s) — si Ollama n'est pas joignable, on echoue vite.
+        timeout = httpx.Timeout(connect=10, read=3600, write=10, pool=10)
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                async with client.stream("POST", url, json={"model": name, "stream": True}) as r:
+                    if r.status_code != 200:
+                        # Ollama renvoie un message JSON d'erreur. On le passe
+                        # tel quel au client en preservant le code HTTP.
+                        body_text = await r.aread()
+                        yield body_text
+                        return
+                    async for chunk in r.aiter_bytes():
+                        yield chunk
+        except httpx.HTTPError as e:
+            # Erreur reseau : on emet une ligne JSON d'erreur compatible
+            # avec le format NDJSON d'Ollama.
+            err = json.dumps({"error": f"Connexion a Ollama impossible : {e}"}) + "\n"
+            yield err.encode("utf-8")
+
+    # application/x-ndjson : un objet JSON par ligne, pas de wrapping SSE.
+    # C'est le format natif d'Ollama, le front le parsera ligne par ligne.
+    return StreamingResponse(stream(), media_type="application/x-ndjson")
+
+
+@router.delete("/models/ollama/{name:path}")
+async def delete_ollama_model(
+    name: str,
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> dict[str, str]:
+    """Supprime un modele du serveur Ollama.
+
+    Le `:path` dans le pattern autorise les `:` du nom (ex: `gemma4:e4b`)
+    sans avoir besoin de URL-encoder cote client.
+    """
+    if not name.strip():
+        raise HTTPException(status_code=400, detail="name requis")
+    url = f"{settings.ollama_base_url}/api/delete"
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.request("DELETE", url, json={"model": name})
+            if response.status_code == 404:
+                raise HTTPException(status_code=404, detail=f"Modele '{name}' introuvable")
+            response.raise_for_status()
+    except httpx.HTTPError as e:
+        raise HTTPException(status_code=502, detail=f"Ollama injoignable : {e}")
+    return {"status": "deleted", "name": name}
+
+
+@router.get("/models/openrouter")
+async def list_openrouter_models() -> dict[str, list[dict[str, object]]]:
+    """Catalogue DYNAMIQUE des modeles OpenRouter (API publique, sans cle).
+
+    Renvoie {models: [{id, name, context_length, free}]}, trie gratuits d'abord
+    puis contexte decroissant. `free` = id finissant par ':free' OU prix nul.
+    """
+    try:
+        async with httpx.AsyncClient(timeout=20) as client:
+            response = await client.get("https://openrouter.ai/api/v1/models")
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPError as exc:
+        raise HTTPException(status_code=502, detail=f"OpenRouter injoignable : {exc}")
+
+    def _is_zero(value: object) -> bool:
+        try:
+            return float(value) == 0.0  # type: ignore[arg-type]
+        except (TypeError, ValueError):
+            return False
+
+    models: list[dict[str, object]] = []
+    for m in data.get("data", []) or []:
+        mid = str(m.get("id") or "")
+        if not mid:
+            continue
+        pricing = m.get("pricing") or {}
+        is_free = mid.endswith(":free") or (
+            _is_zero(pricing.get("prompt")) and _is_zero(pricing.get("completion"))
+        )
+        try:
+            ctx = int(m.get("context_length") or 0)
+        except (TypeError, ValueError):
+            ctx = 0
+        models.append({
+            "id": mid,
+            "name": str(m.get("name") or mid),
+            "context_length": ctx,
+            "free": is_free,
+        })
+
+    models.sort(key=lambda x: (not x["free"], -int(x["context_length"])))  # type: ignore[index]
+    return {"models": models}
+
+
+# Repli statique si la cle Mistral n'est pas (encore) configuree ou si l'API est
+# injoignable — l'utilisateur peut quand meme choisir un modele. Liste curee
+# (juin 2026) ; pour l'extraction de PDF, prefere `large` (fidele, 128k) ou `small`.
+_MISTRAL_FALLBACK_MODELS = [
+    "mistral-large-latest",
+    "mistral-medium-latest",
+    "mistral-small-latest",
+    "open-mistral-nemo",
+    "ministral-8b-latest",
+    "ministral-3b-latest",
+    "magistral-medium-latest",
+    "magistral-small-latest",
+    "pixtral-large-latest",
+    "codestral-latest",
+]
+
+
+@router.get("/models/mistral")
+async def list_mistral_models(
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> dict[str, list[dict[str, object]]]:
+    """Catalogue des modeles Mistral. Dynamique si une cle est configuree
+    (GET /v1/models, qui requiert l'auth), sinon repli statique.
+
+    Renvoie {models: [{id}]} (tous accessibles sur le tier gratuit Experiment)."""
+    key = settings.mistral_api_key
+    if not key:
+        return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
+    try:
+        async with httpx.AsyncClient(timeout=20) as client:
+            response = await client.get(
+                "https://api.mistral.ai/v1/models",
+                headers={"Authorization": f"Bearer {key}"},
+            )
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPError:
+        # Cle invalide / API down : on ne casse pas l'UI, on propose le repli.
+        return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
+
+    ids = sorted({str(m.get("id")) for m in data.get("data", []) or [] if m.get("id")})
+    if not ids:
+        ids = _MISTRAL_FALLBACK_MODELS
+    return {"models": [{"id": i} for i in ids]}
+
+
+# Repli statique Gemini (juin 2026). Pour l'extraction, prefere un Flash a grand
+# contexte ; `gemini-2.0-flash` a le quota gratuit le plus genereux.
+_GEMINI_FALLBACK_MODELS = [
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-lite",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-2.5-pro",
+    "gemini-1.5-flash",
+    "gemini-1.5-pro",
+]
+
+
+@router.get("/models/gemini")
+async def list_gemini_models(
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> dict[str, list[dict[str, object]]]:
+    """Catalogue des modeles Gemini. Dynamique si une cle est configuree (endpoint
+    OpenAI-compatible /openai/models), sinon repli statique. Renvoie {models:[{id}]}."""
+    key = settings.gemini_api_key
+    if not key:
+        return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
+    try:
+        async with httpx.AsyncClient(timeout=20) as client:
+            response = await client.get(
+                "https://generativelanguage.googleapis.com/v1beta/openai/models",
+                headers={"Authorization": f"Bearer {key}"},
+            )
+            response.raise_for_status()
+            data = response.json()
+    except httpx.HTTPError:
+        return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
+
+    # Les ids peuvent arriver prefixes "models/" → on nettoie pour que la valeur
+    # selectionnee soit directement utilisable dans l'appel chat. On garde les
+    # modeles "gemini-*" (hors embeddings/aqa) pour ne pas noyer la liste.
+    ids: set[str] = set()
+    for m in data.get("data", []) or []:
+        mid = str(m.get("id") or "")
+        if mid.startswith("models/"):
+            mid = mid[len("models/"):]
+        if mid.startswith("gemini-"):
+            ids.add(mid)
+    clean = sorted(ids) if ids else _GEMINI_FALLBACK_MODELS
+    return {"models": [{"id": i} for i in clean]}
+
+
+@router.get("/models/onemin")
+def list_onemin_models() -> dict[str, list[dict[str, object]]]:
+    """Catalogue statique des modeles 1min.ai, groupes par fournisseur.
+
+    Liste construite par probing direct de l'endpoint chat-with-ai avec
+    une vraie cle API (avril 2026) : chaque ID renvoie 200, les IDs
+    absents renvoient 400 UNSUPPORTED_MODEL.
+
+    Nota : les IDs Anthropic utilisent la nomenclature propre a 1min.ai
+    (`claude-<family>-<version>`), pas la convention officielle Anthropic.
+    """
+    return {
+        "groups": [
+            {
+                "provider": "Anthropic",
+                "models": ["claude-opus-4-6", "claude-sonnet-4-6"],
+            },
+            {
+                "provider": "OpenAI",
+                "models": [
+                    "gpt-5",
+                    "gpt-5-mini",
+                    "gpt-5-nano",
+                    "gpt-4.1",
+                    "gpt-4.1-mini",
+                    "gpt-4.1-nano",
+                    "gpt-4o",
+                    "gpt-4o-mini",
+                    "gpt-4-turbo",
+                    "gpt-3.5-turbo",
+                    "o3",
+                    "o3-pro",
+                    "o3-mini",
+                    "o4-mini",
+                ],
+            },
+            {
+                "provider": "Google",
+                "models": ["gemini-2.5-pro", "gemini-2.5-flash"],
+            },
+            {
+                "provider": "Mistral",
+                "models": [
+                    "mistral-large-latest",
+                    "mistral-medium-latest",
+                    "mistral-small-latest",
+                    "open-mistral-nemo",
+                ],
+            },
+            {
+                "provider": "DeepSeek",
+                "models": ["deepseek-chat", "deepseek-reasoner"],
+            },
+            {
+                "provider": "xAI",
+                "models": ["grok-3", "grok-3-mini"],
+            },
+            {
+                "provider": "Meta",
+                "models": [
+                    "meta/meta-llama-3.1-405b-instruct",
+                    "meta/meta-llama-3-70b-instruct",
+                ],
+            },
+            {
+                "provider": "Alibaba",
+                "models": ["qwen-plus", "qwen3-max"],
+            },
+            {
+                "provider": "Perplexity",
+                "models": ["sonar", "sonar-pro"],
+            },
+        ]
+    }

brain/app/api/routers/notebooks.py

@@ -0,0 +1,133 @@
+"""Endpoints des notebooks (atelier RAG) : indexation des sources + chats ancrés."""
+import logging
+from typing import Annotated, AsyncIterator
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from app.api.common import MAX_PDF_BYTES, sse_event
+from app.api.deps import (
+    get_notebook_chat_use_case,
+    get_notebook_deep_use_case,
+    get_notebook_rag_use_case,
+)
+from app.application.embeddings import EmbeddingError
+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
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class IndexSourceResponseDTO(BaseModel):
+    chunks: int
+    page_count: int
+    ocr_page_count: int
+
+
+@router.post("/index/notebook-source", response_model=IndexSourceResponseDTO)
+async def index_notebook_source(
+    rag: Annotated[NotebookRagUseCase, Depends(get_notebook_rag_use_case)],
+    source_id: str = Form(...),
+    file: UploadFile = File(...),
+) -> IndexSourceResponseDTO:
+    """Indexe une source PDF (extraction + embeddings + stockage vectoriel)."""
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=422, detail="Fichier PDF vide.")
+    if len(content) > MAX_PDF_BYTES:
+        raise HTTPException(
+            status_code=413, detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).")
+    try:
+        recap = await rag.index_source(source_id, content)
+    except PdfExtractionError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except EmbeddingError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+    return IndexSourceResponseDTO(**recap)
+
+
+@router.delete("/index/notebook-source/{source_id}")
+def delete_notebook_source(source_id: str) -> dict[str, str]:
+    """Supprime les vecteurs d'une source (au DELETE d'une source/notebook)."""
+    vector_store.delete(source_id)
+    return {"status": "deleted", "source_id": source_id}
+
+
+class NotebookChatMessageDTO(BaseModel):
+    role: str
+    content: str
+
+
+class NotebookChatRequestDTO(BaseModel):
+    source_ids: list[str] = Field(default_factory=list)
+    messages: list[NotebookChatMessageDTO] = Field(default_factory=list)
+    context: str = Field(default="")
+
+
+@router.post("/chat/notebook/stream")
+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}."""
+    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
+    top_k = max(1, min(settings.rag_top_k, 200))
+
+    async def event_stream() -> AsyncIterator[str]:
+        try:
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k, language=language):
+                if ev["type"] == "token":
+                    if ev.get("token"):
+                        yield sse_event("token", {"token": ev["token"]})
+                else:
+                    # 'sources' (et tout futur évènement typé) : relayé tel quel.
+                    ev_type = ev.pop("type")
+                    yield sse_event(ev_type, ev)
+            yield sse_event("done", {})
+        except (LLMProviderError, EmbeddingError) as exc:
+            yield sse_event("error", {"message": str(exc)})
+        except Exception as exc:  # noqa: BLE001 — filet : pas de coupure brutale du flux.
+            logger.exception("Chat notebook : erreur inattendue.")
+            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+@router.post("/chat/notebook/deep/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`."""
+    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
+    question = next((m.content for m in reversed(messages) if m.role == "user"), "")
+
+    async def event_stream() -> AsyncIterator[str]:
+        if not question.strip():
+            yield sse_event("error", {"message": "Question vide."})
+            return
+        try:
+            async for ev in use_case.stream(body.source_ids, messages, context=body.context, language=language):
+                ev_type = ev.pop("type")
+                yield sse_event(ev_type, ev)
+        except (LLMProviderError, EmbeddingError) as exc:
+            yield sse_event("error", {"message": str(exc)})
+        except Exception as exc:  # noqa: BLE001 — filet : pas de coupure brutale.
+            logger.exception("Analyse approfondie : erreur inattendue.")
+            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")

brain/app/api/routers/settings.py

@@ -0,0 +1,115 @@
+"""Endpoints de paramétrage runtime (écran Paramètres de l'UI)."""
+from typing import Annotated, Literal
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from app.core.config import Settings, get_settings
+from app.core.settings_store import save_overrides
+
+router = APIRouter()
+
+
+class SettingsDTO(BaseModel):
+    """Vue serialisable des settings modifiables depuis l'UI.
+
+    Expose uniquement les champs que l'utilisateur peut changer a chaud.
+    Les secrets (onemin_api_key) sont masques en lecture.
+    """
+
+    llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"]
+    ollama_base_url: str
+    llm_model: str
+    onemin_model: str
+    # True si une cle 1min.ai est deja configuree — pas de leak de la cle elle-meme.
+    onemin_api_key_set: bool
+    openrouter_model: str
+    # True si une cle OpenRouter est deja configuree (cle elle-meme jamais renvoyee).
+    openrouter_api_key_set: bool
+    mistral_model: str
+    # True si une cle Mistral est deja configuree (cle elle-meme jamais renvoyee).
+    mistral_api_key_set: bool
+    gemini_model: str
+    # True si une cle Gemini est deja configuree (cle elle-meme jamais renvoyee).
+    gemini_api_key_set: bool
+    # Embeddings (RAG des ateliers) : provider + modeles + auto-pull Ollama.
+    embedding_provider: Literal["ollama", "mistral"]
+    ollama_embedding_model: str
+    mistral_embedding_model: str
+    auto_pull_embedding_model: bool
+    rag_top_k: int
+    # Fenetre de contexte effective passee au modele (num_ctx Ollama) — sert
+    # aussi de plafond a la jauge de contexte UI.
+    llm_num_ctx: int
+    # Taille cible d'un morceau (tokens) pour l'import de PDF (regles/campagne).
+    import_chunk_tokens: int
+    # Timeout HTTP des appels LLM (s). A monter si les imports lourds expirent.
+    llm_timeout_seconds: int
+
+
+class SettingsUpdateDTO(BaseModel):
+    """Patch partiel des settings. Tous les champs sont optionnels."""
+
+    llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"] | None = None
+    ollama_base_url: str | None = None
+    llm_model: str | None = None
+    onemin_model: str | None = None
+    # Chaine vide => on efface la cle. None => pas de changement.
+    onemin_api_key: str | None = None
+    openrouter_model: str | None = None
+    openrouter_api_key: str | None = None
+    mistral_model: str | None = None
+    mistral_api_key: str | None = None
+    gemini_model: str | None = None
+    gemini_api_key: str | None = None
+    embedding_provider: Literal["ollama", "mistral"] | None = None
+    ollama_embedding_model: str | None = None
+    mistral_embedding_model: str | None = None
+    auto_pull_embedding_model: bool | None = None
+    rag_top_k: int | None = None
+    llm_num_ctx: int | None = None
+    import_chunk_tokens: int | None = None
+    llm_timeout_seconds: int | None = None
+
+
+def _to_settings_dto(s: Settings) -> SettingsDTO:
+    return SettingsDTO(
+        llm_provider=s.llm_provider,
+        ollama_base_url=s.ollama_base_url,
+        llm_model=s.llm_model,
+        onemin_model=s.onemin_model,
+        onemin_api_key_set=bool(s.onemin_api_key),
+        openrouter_model=s.openrouter_model,
+        openrouter_api_key_set=bool(s.openrouter_api_key),
+        mistral_model=s.mistral_model,
+        mistral_api_key_set=bool(s.mistral_api_key),
+        gemini_model=s.gemini_model,
+        gemini_api_key_set=bool(s.gemini_api_key),
+        embedding_provider=s.embedding_provider,
+        ollama_embedding_model=s.ollama_embedding_model,
+        mistral_embedding_model=s.mistral_embedding_model,
+        auto_pull_embedding_model=s.auto_pull_embedding_model,
+        rag_top_k=s.rag_top_k,
+        llm_num_ctx=s.llm_num_ctx,
+        import_chunk_tokens=s.import_chunk_tokens,
+        llm_timeout_seconds=s.llm_timeout_seconds,
+    )
+
+
+@router.get("/settings", response_model=SettingsDTO)
+def read_settings(settings: Annotated[Settings, Depends(get_settings)]) -> SettingsDTO:
+    """Retourne la config courante (secrets masques)."""
+    return _to_settings_dto(settings)
+
+
+@router.put("/settings", response_model=SettingsDTO)
+def update_settings(patch: SettingsUpdateDTO) -> SettingsDTO:
+    """Applique un patch partiel aux settings et persiste les overrides.
+
+    Toute requete HTTP suivante verra les nouvelles valeurs (pas de cache).
+    """
+    overrides = {k: v for k, v in patch.model_dump().items() if v is not None}
+    if overrides:
+        save_overrides(overrides)
+    # Relit .env + overrides fusionnes pour confirmation.
+    return _to_settings_dto(get_settings())

brain/app/api/routers/tables.py

@@ -0,0 +1,187 @@
+"""Endpoints « outils de table » : tables aléatoires, improvisation, catalogues d'objets."""
+import re
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+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()
+
+_DICE_FORMULA_RE = re.compile(r"^\s*(\d*)\s*[dD]\s*(\d+)\s*$")
+
+
+def _dice_total_range(formula: str) -> tuple[int, int] | None:
+    """(min, max) des totaux possibles d'une formule NdM, ou None si invalide."""
+    match = _DICE_FORMULA_RE.match(formula or "")
+    if not match:
+        return None
+    count = int(match.group(1)) if match.group(1) else 1
+    faces = int(match.group(2))
+    if count < 1 or count > 100 or faces < 2 or faces > 10000:
+        return None
+    return count, count * faces
+
+
+class GenerateTableRequestDTO(BaseModel):
+    description: str
+    dice_formula: str = Field(default="1d20")
+    # Contexte libre assemblé par le Core (nom de campagne, système, ambiance…).
+    context: str = Field(default="")
+
+
+class GeneratedTableEntryDTO(BaseModel):
+    min_roll: int
+    max_roll: int
+    label: str
+    detail: str = ""
+
+
+class GenerateTableResponseDTO(BaseModel):
+    name: str
+    description: str = ""
+    entries: list[GeneratedTableEntryDTO]
+
+
+@router.post("/generate/random-table", response_model=GenerateTableResponseDTO)
+async def generate_random_table(
+    body: GenerateTableRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> GenerateTableResponseDTO:
+    """Génère une table aléatoire (entrées par plage) couvrant la formule de dé."""
+    rng = _dice_total_range(body.dice_formula)
+    if rng is None:
+        raise HTTPException(status_code=422, detail="Formule de dé invalide (ex. 1d20, 2d6, d100).")
+    lo, hi = rng
+    prompt = prompts.random_table_prompt(
+        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:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    parsed, _ = load_json_object(raw)
+    if not isinstance(parsed, dict):
+        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de table exploitable.")
+
+    entries: list[GeneratedTableEntryDTO] = []
+    for e in parsed.get("entries", []) or []:
+        if not isinstance(e, dict):
+            continue
+        try:
+            mn = int(e["min_roll"])
+            mx = int(e["max_roll"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        label = str(e.get("label") or "").strip()
+        if not label:
+            continue
+        entries.append(GeneratedTableEntryDTO(
+            min_roll=mn, max_roll=max(mn, mx), label=label[:200],
+            detail=str(e.get("detail") or "").strip(),
+        ))
+    if not entries:
+        raise HTTPException(status_code=502, detail="Aucune entrée générée — réessaie ou reformule.")
+
+    name = str(parsed.get("name") or body.description).strip()[:120] or "Table générée"
+    return GenerateTableResponseDTO(
+        name=name,
+        description=str(parsed.get("description") or "").strip(),
+        entries=entries,
+    )
+
+
+class ImproviseRollRequestDTO(BaseModel):
+    table_name: str
+    result_label: str
+    result_detail: str = Field(default="")
+    context: str = Field(default="")
+
+
+class ImproviseRollResponseDTO(BaseModel):
+    narration: str
+
+
+@router.post("/improvise/table-roll", response_model=ImproviseRollResponseDTO)
+async def improvise_table_roll(
+    body: ImproviseRollRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> ImproviseRollResponseDTO:
+    """Brode un court récit (2-3 phrases) sur un résultat tiré, pour lancer la scène."""
+    prompt = prompts.improvise_roll_prompt(
+        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:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+    return ImproviseRollResponseDTO(narration=raw.strip())
+
+
+# --- Catalogues d'objets (boutiques) : génération IA -------------------------
+
+
+class GenerateCatalogRequestDTO(BaseModel):
+    description: str
+    context: str = Field(default="")
+
+
+class GeneratedCatalogItemDTO(BaseModel):
+    name: str
+    price: str = ""
+    category: str = ""
+    description: str = ""
+
+
+class GenerateCatalogResponseDTO(BaseModel):
+    name: str
+    description: str = ""
+    items: list[GeneratedCatalogItemDTO]
+
+
+@router.post("/generate/item-catalog", response_model=GenerateCatalogResponseDTO)
+async def generate_item_catalog(
+    body: GenerateCatalogRequestDTO,
+    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
+    language: Annotated[str, Depends(get_user_language)],
+) -> GenerateCatalogResponseDTO:
+    """Génère un catalogue d'objets (boutique, butin…) — nom, prix, catégorie, description."""
+    prompt = prompts.item_catalog_prompt(body.description, body.context, language)
+    try:
+        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
+    except LLMProviderError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+    parsed, _ = load_json_object(raw)
+    if not isinstance(parsed, dict):
+        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de catalogue exploitable.")
+
+    items: list[GeneratedCatalogItemDTO] = []
+    for it in parsed.get("items", []) or []:
+        if not isinstance(it, dict):
+            continue
+        name = str(it.get("name") or "").strip()
+        if not name:
+            continue
+        items.append(GeneratedCatalogItemDTO(
+            name=name[:200],
+            price=str(it.get("price") or "").strip(),
+            category=str(it.get("category") or "").strip(),
+            description=str(it.get("description") or "").strip(),
+        ))
+    if not items:
+        raise HTTPException(status_code=502, detail="Aucun objet généré — réessaie ou reformule.")
+
+    name = str(parsed.get("name") or body.description).strip()[:120] or "Catalogue généré"
+    return GenerateCatalogResponseDTO(
+        name=name,
+        description=str(parsed.get("description") or "").strip(),
+        items=items,
+    )

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/chunking.py

@@ -13,8 +13,19 @@ from __future__ import annotations
 CHUNK_TARGET_TOKENS = 6000
 
 
-def chunk_text(full_text: str, target_tokens: int = CHUNK_TARGET_TOKENS) -> list[str]:
-    """Découpe `full_text` en morceaux ~`target_tokens` tokens (frontières de §)."""
+def chunk_text(
+    full_text: str,
+    target_tokens: int = CHUNK_TARGET_TOKENS,
+    overlap_tokens: int = 0,
+) -> list[str]:
+    """Découpe `full_text` en morceaux ~`target_tokens` tokens (frontières de §).
+
+    `overlap_tokens` > 0 : chaque morceau reprend la fin du précédent (les derniers
+    paragraphes, jusqu'à ~`overlap_tokens` tokens). Utile pour le RAG : une phrase-clé
+    à cheval sur deux morceaux reste retrouvable dans au moins l'un des deux. À
+    laisser à 0 pour les imports (recopie) : un overlap y DUPLIQUERAIT du texte.
+    Un morceau peut légèrement dépasser la cible (jusqu'à target + overlap).
+    """
     if not full_text.strip():
         return []
 
@@ -26,32 +37,65 @@ def chunk_text(full_text: str, target_tokens: int = CHUNK_TARGET_TOKENS) -> list
     chunks: list[str] = []
     current: list[str] = []
     current_tokens = 0
+    fresh = False  # `current` contient-il du contenu pas encore émis ? (évite de
+    # ré-émettre un morceau composé uniquement de l'overlap en fin de texte)
     for para in paragraphs:
         para_tokens = len(enc.encode(para))
         # Un paragraphe seul plus gros que la cible : on le coupe en sous-blocs.
         if para_tokens > target_tokens:
-            if current:
+            if current and fresh:
                 chunks.append("\n\n".join(current))
-                current, current_tokens = [], 0
-            chunks.extend(_split_oversized(para, enc, target_tokens))
+            current, current_tokens, fresh = [], 0, False
+            chunks.extend(_split_oversized(para, enc, target_tokens, overlap_tokens))
             continue
         if current_tokens + para_tokens > target_tokens and current:
+            if fresh:
                 chunks.append("\n\n".join(current))
-            current, current_tokens = [], 0
+            current, current_tokens = _overlap_tail(current, enc, overlap_tokens)
+            fresh = False
         current.append(para)
         current_tokens += para_tokens
+        fresh = True
 
-    if current:
+    if current and fresh:
         chunks.append("\n\n".join(current))
     return chunks
 
 
-def _split_oversized(paragraph: str, enc, target_tokens: int) -> list[str]:
-    """Coupe un paragraphe géant en sous-blocs ~`target_tokens` tokens."""
+def _overlap_tail(parts: list[str], enc, overlap_tokens: int) -> tuple[list[str], int]:
+    """Derniers paragraphes de `parts` totalisant au plus `overlap_tokens` tokens —
+    le « rappel » recopié en tête du morceau suivant."""
+    if overlap_tokens <= 0 or not parts:
+        return [], 0
+    tail: list[str] = []
+    total = 0
+    for para in reversed(parts):
+        para_tokens = len(enc.encode(para))
+        if total + para_tokens > overlap_tokens:
+            break
+        tail.insert(0, para)
+        total += para_tokens
+    if not tail:
+        # Aucun paragraphe entier ne tient dans le budget (paragraphes longs) :
+        # on reprend la FIN du dernier paragraphe pour garantir le recouvrement.
+        tokens = enc.encode(parts[-1])
+        tail = [enc.decode(tokens[-overlap_tokens:])]
+        total = min(overlap_tokens, len(tokens))
+    return tail, total
+
+
+def _split_oversized(paragraph: str, enc, target_tokens: int, overlap_tokens: int = 0) -> list[str]:
+    """Coupe un paragraphe géant en sous-blocs ~`target_tokens` tokens (fenêtre
+    glissante avec recouvrement si `overlap_tokens` > 0)."""
     tokens = enc.encode(paragraph)
+    step = max(1, target_tokens - overlap_tokens)
     out: list[str] = []
-    for i in range(0, len(tokens), target_tokens):
+    i = 0
+    while i < len(tokens):
         out.append(enc.decode(tokens[i : i + target_tokens]))
+        if i + target_tokens >= len(tokens):
+            break
+        i += step
     return out
 
 

brain/app/application/embeddings.py

@@ -14,7 +14,13 @@ class EmbeddingError(Exception):
 
 
 class EmbeddingProvider(Protocol):
-    """Calcule les vecteurs d'une liste de textes (ordre préservé)."""
+    """Calcule les vecteurs d'une liste de textes (ordre préservé).
 
-    async def embed(self, texts: list[str]) -> list[list[float]]:
+    `kind` distingue les DOCUMENTS indexés ("document") de la QUESTION posée
+    ("query") : certains modèles (nomic-embed-text) sont entraînés avec des
+    préfixes de tâche distincts et perdent en pertinence sans eux. Les adapters
+    qui n'en ont pas besoin (mistral-embed) ignorent simplement le paramètre.
+    """
+
+    async def embed(self, texts: list[str], kind: str = "document") -> list[list[float]]:
         ...

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

@@ -10,11 +10,18 @@ PROPOSITION non persistée : le Core crée les entités seulement après revue.
 """
 from __future__ import annotations
 
+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
@@ -24,10 +31,16 @@ from app.domain.models import (
     ArcProposal,
     CampaignImportResult,
     ChapterProposal,
+    NpcImportProposal,
     RoomProposal,
     SceneProposal,
 )
-from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
+from app.domain.ports import (
+    LLMGenerationTimeout,
+    LLMProvider,
+    LLMProviderError,
+    PdfTextExtractor,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -35,66 +48,101 @@ 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).
+# 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,
+}
 
-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...).
+# Garde-fou prompt : une TOC de gros livre peut compter des centaines d'entrées
+# (sous-sous-sections). On la limite aux niveaux hauts et à un nombre raisonnable.
+_TOC_MAX_LEVEL = 2
+_TOC_MAX_ENTRIES = 80
 
-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 [].
-
-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": "..."}}]}}
-     ]}}]}}
-  ]}}
-- 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": []}}."""
+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]
+    if not entries:
+        return ""
+    return "\n".join(f"{'  ' * (e.level - 1)}- {e.title} (p. {e.page})" for e in entries)
 
 
 class _TreeMerger:
@@ -108,6 +156,8 @@ class _TreeMerger:
     def __init__(self) -> None:
         # arc_key -> {"name", "description", "chapters": {chap_key -> {...}}}
         self._arcs: dict[str, dict] = {}
+        # npc_key (nom en minuscules) -> {"name", "description"}
+        self._npcs: dict[str, dict] = {}
 
     def add(self, arcs_json: list[dict]) -> None:
         for arc in arcs_json or []:
@@ -136,8 +186,12 @@ class _TreeMerger:
                         {"name": sname, "description": "", "player_narration": "",
                          "gm_notes": "", "rooms": {}})
                     self._fill_desc(s, sc)
-                    self._fill_field(s, sc, "player_narration")
-                    self._fill_field(s, sc, "gm_notes")
+                    # Narration/notes : CONCATÉNATION (pas premier-gagne) — une
+                    # scène coupée entre deux morceaux apporte la suite de son
+                    # contenu dans le morceau suivant ; la jeter perdrait la
+                    # moitié du donjon. Le doublon exact (overlap) est filtré.
+                    self._append_field(s, sc, "player_narration")
+                    self._append_field(s, sc, "gm_notes")
                     for rm in sc.get("rooms", []) or []:
                         rname = str(rm.get("name", "")).strip()
                         if not rname:
@@ -149,6 +203,22 @@ class _TreeMerger:
                         self._fill_field(r, rm, "enemies")
                         self._fill_field(r, rm, "loot")
 
+    def add_npcs(self, npcs_json: list[dict]) -> None:
+        """Accumule les PNJ détectés. Un PNJ revu dans un autre morceau garde la
+        description la plus COMPLÈTE (la plus longue) — un PNJ récurrent est
+        souvent décrit en détail une seule fois."""
+        for npc in npcs_json or []:
+            name = str(npc.get("name", "")).strip()
+            if not name:
+                continue
+            desc = str(npc.get("description") or "").strip()
+            entry = self._npcs.setdefault(name.lower(), {"name": name, "description": ""})
+            if len(desc) > len(entry["description"]):
+                entry["description"] = desc
+
+    def npcs(self) -> list[NpcImportProposal]:
+        return [NpcImportProposal(n["name"], n["description"]) for n in self._npcs.values()]
+
     @staticmethod
     def _fill_desc(node: dict, src: dict) -> None:
         if not node["description"]:
@@ -159,6 +229,23 @@ class _TreeMerger:
         if not node[field_name]:
             node[field_name] = str(src.get(field_name) or "").strip()
 
+    @staticmethod
+    def _append_field(node: dict, src: dict, field_name: str) -> None:
+        """Accumule la valeur de `src` à la suite de l'existante (scène coupée
+        entre deux morceaux). Ignore le vide et le contenu déjà présent (un
+        morceau redondant — relecture d'overlap — ne duplique rien)."""
+        new = str(src.get(field_name) or "").strip()
+        if not new:
+            return
+        current = node[field_name]
+        if not current:
+            node[field_name] = new
+        elif new not in current and current not in new:
+            node[field_name] = current + "\n\n" + new
+        elif current in new:
+            # Le nouveau contenu ENGLOBE l'ancien (version plus complète) → on le prend.
+            node[field_name] = new
+
     def result(self) -> list[ArcProposal]:
         arcs: list[ArcProposal] = []
         for a in self._arcs.values():
@@ -182,6 +269,79 @@ class _TreeMerger:
         scenes = sum(len(c["scenes"]) for a in self._arcs.values() for c in a["chapters"].values())
         return arcs, chapters, scenes
 
+    # --- Consolidation : fusion des quasi-doublons détectés par le LLM ---------
+
+    def skeleton_text(self) -> str:
+        """Squelette de l'arbre (noms seuls) — entrée compacte de la consolidation."""
+        lines: list[str] = []
+        for a in self._arcs.values():
+            lines.append(f"ARC: {a['name']}")
+            for c in a["chapters"].values():
+                lines.append(f"  CHAPITRE: {c['name']}")
+                for s in c["scenes"].values():
+                    lines.append(f"    SCENE: {s['name']}")
+        return "\n".join(lines)
+
+    def merge_chapters(self, into_name: str, merge_names: list[str]) -> bool:
+        """Fusionne les chapitres `merge_names` dans `into_name` (tous arcs).
+
+        Best-effort : les noms inconnus sont ignorés. Renvoie True si modifié.
+        """
+        target = self._find_chapter(into_name)
+        if target is None:
+            return False
+        changed = False
+        for mname in merge_names:
+            key = str(mname).strip().lower()
+            if not key or key == str(into_name).strip().lower():
+                continue
+            for a in self._arcs.values():
+                src = a["chapters"].pop(key, None)
+                if src is None or src is target:
+                    continue
+                self._fill_desc(target, src)
+                for skey, sdict in src["scenes"].items():
+                    if skey in target["scenes"]:
+                        self._merge_scene_into(target["scenes"][skey], sdict)
+                    else:
+                        target["scenes"][skey] = sdict
+                changed = True
+        return changed
+
+    def merge_scenes(self, chapter_name: str, into_name: str, merge_names: list[str]) -> bool:
+        """Fusionne les scènes `merge_names` dans `into_name` au sein du chapitre."""
+        chapter = self._find_chapter(chapter_name)
+        if chapter is None:
+            return False
+        target = chapter["scenes"].get(str(into_name).strip().lower())
+        if target is None:
+            return False
+        changed = False
+        for mname in merge_names:
+            key = str(mname).strip().lower()
+            if not key or key == str(into_name).strip().lower():
+                continue
+            src = chapter["scenes"].pop(key, None)
+            if src is None or src is target:
+                continue
+            self._merge_scene_into(target, src)
+            changed = True
+        return changed
+
+    def _find_chapter(self, name: str) -> dict | None:
+        key = str(name).strip().lower()
+        for a in self._arcs.values():
+            if key in a["chapters"]:
+                return a["chapters"][key]
+        return None
+
+    def _merge_scene_into(self, target: dict, src: dict) -> None:
+        self._fill_desc(target, src)
+        self._append_field(target, src, "player_narration")
+        self._append_field(target, src, "gm_notes")
+        for rkey, rdict in src.get("rooms", {}).items():
+            target["rooms"].setdefault(rkey, rdict)
+
 
 class ImportCampaignUseCase:
     """Transforme un PDF de campagne en proposition d'arbre arc→chapitre→scène."""
@@ -191,22 +351,39 @@ class ImportCampaignUseCase:
         llm: LLMProvider,
         extractor: PdfTextExtractor,
         chunk_target_tokens: int = _CHUNK_TARGET_TOKENS,
+        map_concurrency: int = 1,
     ) -> None:
         self._llm = llm
         self._extractor = extractor
         self._chunk_target_tokens = chunk_target_tokens
+        # Appels MAP par VAGUES de cette taille : l'ordre narratif est préservé
+        # (fusion vague par vague, dans l'ordre du livre) mais le mur d'attente
+        # des appels LLM est divisé d'autant. 1 = comportement séquentiel.
+        self._map_concurrency = max(1, map_concurrency)
 
     async def execute(self, pdf_bytes: bytes) -> CampaignImportResult:
         """Variante non-streamée : traite tout puis renvoie l'arbre complet."""
         doc = self._extractor.extract(pdf_bytes)
         chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
+        toc_block = _format_toc(doc.toc)
         merger = _TreeMerger()
-        for i, chunk in enumerate(chunks):
-            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
+        total = len(chunks)
+        for start in range(0, total, self._map_concurrency):
+            wave = list(enumerate(chunks))[start:start + self._map_concurrency]
+            results = await asyncio.gather(*(
+                self._map_chunk(c, index=i, total=total, toc_block=toc_block)
+                for i, c in wave
+            ))
+            for res in results:
+                merger.add(res["arcs"])
+                merger.add_npcs(res["npcs"])
+        if total > 1:
+            await self._consolidate(merger)
         return CampaignImportResult(
             arcs=merger.result(),
             page_count=doc.page_count,
             ocr_page_count=doc.ocr_page_count,
+            npcs=merger.npcs(),
         )
 
     async def stream(self, pdf_bytes: bytes):
@@ -221,10 +398,12 @@ class ImportCampaignUseCase:
 
         doc = self._extractor.extract(pdf_bytes)
         chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
+        toc_block = _format_toc(doc.toc)
         total = len(chunks)
         logger.info(
-            "Import campagne (stream) : %s page(s) (%s via OCR), %s morceau(x).",
+            "Import campagne (stream) : %s page(s) (%s via OCR), %s morceau(x), TOC %s.",
             doc.page_count, doc.ocr_page_count, total,
+            "présente" if toc_block else "absente",
         )
         yield {
             "type": "start",
@@ -236,36 +415,58 @@ class ImportCampaignUseCase:
         merger = _TreeMerger()
         skipped = 0
         last_error: str | None = None
-        for i, chunk in enumerate(chunks):
+        done_count = 0
+        # 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 l'appel LLM pour ne jamais laisser le
-            # flux SSE silencieux (sinon le Core coupe sur timeout d'inactivité).
-            try:
-                arcs_payload: list[dict] | None = None
-                async for kind, payload in with_heartbeat(
-                    self._map_chunk(chunk, index=i, total=total)
-                ):
+            # 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": i + 1, "total": total}
+                        yield {"type": "heartbeat", "current": done_count + 1, "total": total}
+                    elif kind == "status":
+                        yield {"type": "status", "message": payload,
+                               "current": done_count + 1, "total": total}
                     else:
-                        arcs_payload = payload
-                merger.add(arcs_payload or [])
-            except LLMProviderError as exc:
+                        results = payload
+                for (i, _), res in zip(wave, results or []):
+                    done_count += 1
+                    if isinstance(res, LLMProviderError):
                         skipped += 1
-                last_error = str(exc)
-                logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
+                        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(exc)[:300]}
+                               "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": i + 1,
+                        "current": done_count,
                         "total": total,
                         "arc_count": arcs,
                         "chapter_count": chapters,
                         "scene_count": scenes,
+                        "npc_count": len(merger.npcs()),
                         "skipped": skipped,
                     }
 
@@ -276,33 +477,125 @@ class ImportCampaignUseCase:
                                   f"Dernier message : {last_error or 'inconnu'}"}
                 return
 
+            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
+
+            # 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) ---------------------
+
+    async def _consolidate(self, merger: _TreeMerger) -> None:
+        """Une passe LLM sur le squelette pour fusionner les quasi-doublons.
+
+        BEST-EFFORT : toute erreur (LLM indisponible, JSON invalide, noms
+        inconnus) laisse l'arbre tel quel — la consolidation ne peut qu'améliorer,
+        jamais bloquer un import.
+        """
+        _, chapters, scenes = merger.counts()
+        if chapters + scenes < 3:
+            return  # rien à dédoublonner sur un arbre minuscule
+        skeleton = merger.skeleton_text()
+        try:
+            raw = await generate_with_retry(
+                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é.
+            logger.warning("Consolidation ignorée (échec) : %s", exc)
+            return
+        parsed, _ = load_json_object(raw)
+        if not isinstance(parsed, dict):
+            logger.warning("Consolidation ignorée (réponse non-JSON).")
+            return
+        merged = 0
+        for cm in parsed.get("chapter_merges") or []:
+            if isinstance(cm, dict) and merger.merge_chapters(
+                    str(cm.get("into") or ""), list(cm.get("merge") or [])):
+                merged += 1
+        for sm in parsed.get("scene_merges") or []:
+            if isinstance(sm, dict) and merger.merge_scenes(
+                    str(sm.get("chapter") or ""), str(sm.get("into") or ""),
+                    list(sm.get("merge") or [])):
+                merged += 1
+        if merged:
+            logger.info("Consolidation : %s fusion(s) de quasi-doublons appliquée(s).", merged)
 
     # --- MAP : un morceau → sous-arbre ---------------------------------------
 
-    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> list[dict]:
-        return await self._extract_arcs(chunk, index=index, total=total, depth=0)
+    async def _map_chunk(
+        self, chunk: str, *, index: int, total: int, toc_block: str = ""
+    ) -> dict:
+        """Phase MAP d'un morceau → {"arcs": [...], "npcs": [...]}."""
+        return await self._extract_payload(
+            chunk, index=index, total=total, depth=0, toc_block=toc_block)
 
-    async def _extract_arcs(
-        self, text: str, *, index: int, total: int, depth: int
-    ) -> list[dict]:
-        """Extrait l'arborescence 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é)."""
+    async def _extract_payload(
+        self, text: str, *, index: int, total: int, depth: int, toc_block: str = ""
+    ) -> dict:
+        """Extrait l'arborescence + les PNJ d'un texte. Si la SORTIE est tronquée,
+        retraite le texte en DEUX moitiés et concatène — le `_TreeMerger` final
+        dédoublonne par nom (un arc/chapitre coupé entre les moitiés est recollé)."""
+        toc_section = prompts.TOC_BLOCK.format(toc=toc_block) if toc_block else ""
         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."
         )
+        try:
             raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-        arcs, truncated = self._parse_arcs(raw, index=index)
+                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:
             left, right = split_in_half(text)
@@ -310,17 +603,23 @@ class ImportCampaignUseCase:
                 logger.info(
                     "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
                     index, depth + 1)
-                a = await self._extract_arcs(left, index=index, total=total, depth=depth + 1)
-                b = await self._extract_arcs(right, index=index, total=total, depth=depth + 1)
-                return a + b
+                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(
+                    right, index=index, total=total, depth=depth + 1, toc_block=toc_block)
+                return {"arcs": a["arcs"] + b["arcs"], "npcs": a["npcs"] + b["npcs"]}
         if truncated:
             logger.warning(
                 "Morceau %s : sortie tronquée, profondeur max atteinte — partiel conservé.", index)
-        return arcs
+        return payload
 
     @staticmethod
-    def _parse_arcs(raw: str, *, index: int) -> tuple[list[dict], bool]:
-        """Parse robuste → (arcs, tronqué). `tronqué`=True si récupération partielle."""
+    def _parse_payload(raw: str, *, index: int) -> tuple[dict, bool]:
+        """Parse robuste → ({"arcs", "npcs"}, tronqué). `tronqué`=True si partiel."""
+        empty = {"arcs": [], "npcs": []}
         parsed, recovered = load_json_object(raw)
         if parsed is None:
             truncated = looks_like_truncated_json(raw)
@@ -329,11 +628,15 @@ class ImportCampaignUseCase:
                     "Morceau %s : aucun objet JSON exploitable, ignoré. "
                     "Début de la réponse du modèle : %r",
                     index, (raw or "").strip()[:300] or "(réponse VIDE)")
-            return [], truncated
+            return empty, truncated
         if isinstance(parsed, dict):
             arcs = parsed.get("arcs", [])
-            return (arcs if isinstance(arcs, list) else []), recovered
-        return [], recovered
+            npcs = parsed.get("npcs", [])
+            return {
+                "arcs": arcs if isinstance(arcs, list) else [],
+                "npcs": npcs if isinstance(npcs, list) else [],
+            }, recovered
+        return empty, recovered
 
 
 def _serialize_arcs(arcs: list[ArcProposal]) -> list[dict]:

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,6 +285,11 @@ class ImportRulesUseCase:
         merger = _SectionMerger()
         skipped = 0
         last_error: str | None = None
+        # 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).
@@ -188,10 +299,14 @@ class ImportRulesUseCase:
                 try:
                     sections: dict[str, str] | None = None
                     async for kind, payload in with_heartbeat(
-                    self._map_chunk(chunk, index=i, total=total)
+                        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 {})
@@ -208,6 +323,8 @@ class ImportRulesUseCase:
                     "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,24 +354,52 @@ 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."
         )
+        try:
             raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
+                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:
@@ -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,57 +9,22 @@ 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__(self, rag: NotebookRagUseCase, llm: LLMChatProvider) -> None:
+    def __init__(
+        self, rag: NotebookRagUseCase, llm: LLMChatProvider, rerank_enabled: bool = False
+    ) -> None:
         self._rag = rag
         self._llm = llm
+        # Reranking LLM d'un pool élargi avant injection (voir app.application.rerank).
+        self._rerank_enabled = rerank_enabled
 
     async def stream(
         self,
@@ -67,9 +32,33 @@ class NotebookChatUseCase:
         messages: list[ChatMessage],
         context: str = "",
         top_k: int = 6,
-    ) -> AsyncIterator[str]:
-        last_user = next((m.content for m in reversed(messages) if m.role == "user"), "")
-        passages = await self._rag.retrieve(source_ids, last_user, top_k=top_k)
+        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}."""
+        # Question AUTONOME pour la recherche : sur une relance (« et ses
+        # faiblesses ? »), l'embedding du dernier message seul ne contient pas
+        # le sujet → on le résout depuis l'historique (best-effort, 1 appel léger,
+        # uniquement à partir du 2e tour). La réponse, elle, voit tout l'historique.
+        search_query = await standalone_question(self._llm, messages)
+        if self._rerank_enabled:
+            # Pool élargi → notation LLM → top_k final (meilleure précision sur
+            # les questions ambiguës, au prix d'un appel avant le premier token).
+            pool = await self._rag.retrieve(
+                source_ids, search_query, top_k=pool_size(top_k))
+            passages = await rerank(self._llm, search_query, pool, top_k)
+        else:
+            passages = await self._rag.retrieve(source_ids, search_query, top_k=top_k)
+        # Évènement 'sources' AVANT le premier token : l'UI peut afficher les
+        # pages utilisées (« 📖 p. 12, 47 ») dès le début de la réponse.
+        yield {"type": "sources", "sources": [
+            {
+                "source_id": p.get("source_id"),
+                "page": p.get("page"),
+                "score": round(float(p.get("score") or 0.0), 3),
+            }
+            for p in passages
+        ]}
         sources_block = (
             "\n\n".join(self._format_passage(p) for p in passages)
             if passages else "(aucun passage pertinent trouvé dans les sources)"
@@ -78,10 +67,11 @@ 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 token
+            yield {"type": "token", "token": token}
 
     @staticmethod
     def _format_passage(p: dict) -> str:

brain/app/application/notebook_deep.py

@@ -13,12 +13,16 @@ lots ; avec un petit modèle local, plus de lots (mais ça reste exhaustif).
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 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
@@ -28,37 +32,37 @@ logger = logging.getLogger(__name__)
 _NO_MATCH = "RAS"
 _MAP_TEMPERATURE = 0.2
 
-_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.
+# --- Index de résumés (pré-filtrage des lots) --------------------------------
+# Sans index : CHAQUE question relit TOUT le document (1 appel LLM par lot).
+# Avec : les résumés de lots (construits UNE fois, cache disque) sont comparés
+# à 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.
 
-QUESTION : {question}
-
---- EXTRAIT ---
-{excerpt}
---- FIN EXTRAIT ---
-
-Informations pertinentes (ou « {no_match} ») :"""
-
-_REDUCE_SYSTEM = """Tu réponds à la question d'un MJ à partir de NOTES extraites de
-l'ENSEMBLE d'un document source (donc tu as une vue COMPLÈTE, pas un simple extrait).
-Synthétise ces notes en une réponse claire et structurée, cite les pages (« p. X »),
-et n'invente rien qui n'y figure pas. Si une CAMPAGNE est fournie ci-dessous, relie ta
-réponse à sa structure / ses PNJ pour des adaptations cohérentes.
-
-{context_block}
---- NOTES EXTRAITES DE TOUT LE DOCUMENT ---
-{notes_block}
---- FIN DES NOTES ---
-
-Réponds en français."""
+# 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.
+_SELECT_MARGIN = 0.10
+_SELECT_FLOOR = 0.5
+_MIN_KEPT = 3
 
 
 class NotebookDeepUseCase:
-    def __init__(self, llm: LLMProvider, batch_tokens: int = 10000) -> None:
+    def __init__(
+        self,
+        llm: LLMProvider,
+        batch_tokens: int = 10000,
+        map_concurrency: int = 1,
+        embedder=None,
+        summary_filter: bool = True,
+    ) -> None:
         self._llm = llm
         self._batch_tokens = max(2000, batch_tokens)
+        # Lots MAP traités par vagues de cette taille (parallélisme LLM).
+        self._map_concurrency = max(1, map_concurrency)
+        # EmbeddingProvider (duck typing) pour l'index de résumés ; None = pas
+        # de pré-filtrage (plein scan, comportement historique).
+        self._embedder = embedder
+        self._summary_filter = summary_filter
 
     async def stream(
         self,
@@ -66,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é.)
@@ -74,33 +79,57 @@ class NotebookDeepUseCase:
         SYNTHÈSE (reduce) reçoit les `history_limit` derniers messages → les relances
         conversationnelles (« et pour les autres ? ») fonctionnent aussi en approfondi.
         """
-        question = next((m.content for m in reversed(messages) if m.role == "user"), "")
-        chunks: list[dict] = []
+        # Question autonome : la phase MAP lit chaque lot avec LA question — sur
+        # une relance conversationnelle, il faut y résoudre les références
+        # implicites, sinon les lots sont filtrés sur un texte sans sujet.
+        question = await standalone_question(self._llm, messages)
+        # Lots PAR SOURCE (l'index de résumés est caché par source).
+        per_source: list[tuple[str, list[dict]]] = []
         for sid in source_ids:
-            chunks.extend(vector_store.all_chunks(sid))
-        if not chunks:
+            chunks = vector_store.all_chunks(sid)
+            for batch in self._group(chunks):
+                per_source.append((sid, batch))
+        if not per_source:
             yield {"type": "token", "token": "Aucune source indexée à analyser."}
             yield {"type": "done"}
             return
 
-        batches = self._group(chunks)
-        total = len(batches)
-        notes: list[str] = []
-        for i, batch in enumerate(batches):
-            yield {"type": "progress", "current": i, "total": total}
-            excerpt = "\n\n".join(
-                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)
+        # Pré-filtrage par index de résumés (best-effort : tout échec → plein scan).
+        selected: set[int] | None = None
+        if self._summary_filter and self._embedder is not None:
             try:
-                raw = await generate_with_retry(self._llm, prompt, temperature=_MAP_TEMPERATURE)
-            except LLMProviderError as exc:
-                logger.warning("Analyse approfondie : lot %s/%s ignoré : %s", i + 1, total, exc)
-                continue
-            answer = raw.strip()
-            if answer and answer.upper().rstrip(".") != _NO_MATCH:
-                notes.append(answer)
+                async for ev_or_result in self._select_batches(per_source, question):
+                    if isinstance(ev_or_result, dict):
+                        yield ev_or_result  # progress de construction de l'index
+                    else:
+                        selected = ev_or_result
+            except Exception as exc:  # noqa: BLE001 — le filtre ne doit jamais bloquer
+                logger.warning("Index de résumés ignoré (échec) : %s", exc)
+                selected = None
+        if selected is not None:
+            logger.info(
+                "Analyse approfondie : %s/%s lot(s) retenus via l'index de résumés.",
+                len(selected), len(per_source))
+
+        indices = sorted(selected) if selected is not None else list(range(len(per_source)))
+        total = len(indices)
+        notes: list[str] = []
+        # Lots traités par VAGUES parallèles ; les notes restent dans l'ordre du
+        # document (gather préserve l'ordre des tâches de la vague).
+        for start in range(0, total, self._map_concurrency):
+            yield {"type": "progress", "current": start, "total": total}
+            wave = indices[start:start + self._map_concurrency]
+            results = await asyncio.gather(
+                *(self._map_batch(question, per_source[i][1]) for i in wave),
+                return_exceptions=True)
+            for j, res in enumerate(results):
+                if isinstance(res, LLMProviderError):
+                    logger.warning(
+                        "Analyse approfondie : lot %s/%s ignoré : %s", start + j + 1, total, res)
+                elif isinstance(res, BaseException):
+                    raise res  # bug inattendu : ne pas l'avaler
+                elif res:
+                    notes.append(res)
         yield {"type": "progress", "current": total, "total": total}
 
         notes_block = "\n\n".join(notes) if notes else "(aucune information pertinente trouvée dans le document)"
@@ -108,15 +137,100 @@ 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)]
         llm_chat: LLMChatProvider = self._llm  # type: ignore[assignment]
+        produced = False
         async for token in llm_chat.stream_chat(reduce_messages, system_prompt=system_prompt):
+            if token:
+                produced = True
                 yield {"type": "token", "token": token}
+        if not produced:
+            # Jamais de bulle vide : message de repli + orientation vers le mode rapide,
+            # mieux adapté aux demandes créatives (et qui propose des cartes d'action).
+            yield {"type": "token", "token": (
+                "Je n'ai pas trouvé d'éléments pertinents dans le document pour cette demande "
+                "(elle porte sans doute sur des éléments que tu as inventés). Pour une "
+                "**adaptation créative** — proposer des arcs, chapitres, scènes ou PNJ — "
+                "utilise plutôt le bouton **« Envoyer »** (mode rapide) : il est conversationnel, "
+                "voit ta campagne, et te propose des cartes « Créer dans la campagne »."
+            )}
         yield {"type": "done"}
 
+    # --- Index de résumés ------------------------------------------------------
+
+    async def _select_batches(self, per_source: list[tuple[str, list[dict]]], question: str):
+        """Générateur : yield des évènements `progress` pendant la construction de
+        l'index (1ère analyse d'une source), puis le set des indices retenus —
+        ou None si le filtre n'apporte rien (tous retenus)."""
+        # 1. Charge/construit les résumés par source (cache disque).
+        by_sid: dict[str, list[int]] = {}
+        for i, (sid, _) in enumerate(per_source):
+            by_sid.setdefault(sid, []).append(i)
+        vectors: list[list[float] | None] = [None] * len(per_source)
+
+        to_build = []
+        for sid, idxs in by_sid.items():
+            cached = vector_store.load_summaries(sid, self._batch_tokens)
+            if cached is not None and len(cached) == len(idxs):
+                for i, entry in zip(idxs, cached):
+                    vectors[i] = entry.get("vector")
+            else:
+                to_build.append((sid, idxs))
+
+        total_build = sum(len(idxs) for _, idxs in to_build)
+        done_build = 0
+        for sid, idxs in to_build:
+            summaries: list[str] = []
+            for start in range(0, len(idxs), self._map_concurrency):
+                yield {"type": "progress", "current": done_build, "total": total_build}
+                wave = idxs[start:start + self._map_concurrency]
+                results = await asyncio.gather(
+                    *(self._summarize_batch(per_source[i][1]) for i in wave))
+                summaries.extend(results)
+                done_build += len(wave)
+            vecs = await self._embedder.embed(summaries, kind="document")
+            entries = [{"summary": s, "vector": v} for s, v in zip(summaries, vecs)]
+            vector_store.save_summaries(sid, self._batch_tokens, entries)
+            for i, entry in zip(idxs, entries):
+                vectors[i] = entry["vector"]
+
+        # 2. Score de chaque lot face à la question, sélection conservatrice.
+        qv = (await self._embedder.embed([question], kind="query"))[0]
+        scores = [
+            vector_store.cosine_similarity(qv, v) if v else 0.0
+            for v in vectors
+        ]
+        best = max(scores)
+        keep = {i for i, s in enumerate(scores) if s >= best - _SELECT_MARGIN or s >= _SELECT_FLOOR}
+        floor = min(_MIN_KEPT, len(scores))
+        if len(keep) < floor:
+            keep = set(sorted(range(len(scores)), key=lambda i: -scores[i])[:floor])
+        yield keep if len(keep) < len(scores) else None
+
+    async def _summarize_batch(self, batch: list[dict]) -> str:
+        excerpt = "\n\n".join(c.get("text", "").strip() for c in batch)
+        raw = await generate_with_retry(
+            self._llm, prompts.SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
+        return (raw or "").strip()
+
+    async def _map_batch(self, question: str, batch: list[dict]) -> str:
+        """Phase MAP d'un lot : extrait les infos pertinentes ('' si RAS)."""
+        excerpt = "\n\n".join(
+            f"(p. {c['page']}) {c['text'].strip()}" if c.get("page") else c["text"].strip()
+            for c in batch
+        )
+        prompt = prompts.MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
+        raw = await generate_with_retry(self._llm, prompt, temperature=_MAP_TEMPERATURE)
+        answer = raw.strip()
+        if answer and answer.upper().rstrip(".") != _NO_MATCH:
+            return answer
+        return ""
+
     def _group(self, chunks: list[dict]) -> list[list[dict]]:
         """Regroupe les extraits en lots ~`batch_tokens` (compte tiktoken)."""
         enc = tiktoken.get_encoding("cl100k_base")

brain/app/application/notebook_rag.py

@@ -20,6 +20,9 @@ from app.infrastructure import vector_store
 logger = logging.getLogger(__name__)
 
 _RAG_CHUNK_TOKENS = 600
+# Recouvrement entre extraits consécutifs (~13% de la cible) : une phrase-clé à
+# cheval sur deux extraits reste retrouvable dans au moins l'un des deux.
+_RAG_OVERLAP_TOKENS = 80
 # Un extrait avec quasi aucun texte réel (en-tête/pied de page, fragment de numéro
 # de page isolé « 249 250 ») ne sert à rien en RAG → on l'écarte. Seuil bas et
 # conservateur : on ne coupe QUE les fragments quasi-vides, jamais une vraie phrase.
@@ -36,10 +39,14 @@ class NotebookRagUseCase:
         extractor: PdfTextExtractor,
         embedder: EmbeddingProvider,
         chunk_target_tokens: int = _RAG_CHUNK_TOKENS,
+        min_score: float = 0.0,
     ) -> None:
         self._extractor = extractor
         self._embedder = embedder
         self._chunk_target_tokens = chunk_target_tokens
+        # Cosinus minimal pour qu'un extrait soit injecté dans le prompt : sous ce
+        # seuil, l'extrait n'a aucun rapport avec la question → bruit. 0 = désactivé.
+        self._min_score = min_score
 
     async def index_source(self, source_id: str, pdf_bytes: bytes) -> dict:
         """Extrait, découpe PAR PAGE (pour garder le n° de page → citations), embed
@@ -48,7 +55,9 @@ class NotebookRagUseCase:
         chunks: list[str] = []
         pages: list[int] = []
         for page in doc.pages:
-            for piece in chunk_text(page.text, self._chunk_target_tokens):
+            for piece in chunk_text(
+                page.text, self._chunk_target_tokens, overlap_tokens=_RAG_OVERLAP_TOKENS
+            ):
                 if not _has_enough_text(piece):
                     continue  # fragment quasi-vide (en-tête/pied/numéro) → ignoré
                 chunks.append(piece)
@@ -69,11 +78,17 @@ class NotebookRagUseCase:
         }
 
     async def retrieve(self, source_ids: list[str], query: str, top_k: int = 6) -> list[dict]:
-        """Passages les plus pertinents (toutes sources) pour `query`."""
+        """Passages les plus pertinents (toutes sources) pour `query`.
+
+        Recherche hybride (cosinus + bonus lexical sur les mots de la question) ;
+        peut renvoyer moins de `top_k` passages si le seuil de pertinence écarte
+        les extraits hors-sujet."""
         ids = [s for s in source_ids if vector_store.exists(s)]
         if not ids or not query.strip():
             return []
-        query_vectors = await self._embedder.embed([query])
+        query_vectors = await self._embedder.embed([query], kind="query")
         if not query_vectors:
             return []
-        return vector_store.search(ids, query_vectors[0], top_k)
+        return vector_store.search(
+            ids, query_vectors[0], top_k, query_text=query, min_score=self._min_score
+        )

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/narrative_fields.py

@@ -0,0 +1,50 @@
+"""Prompt d'étoffage des champs d'une entité narrative (arc / chapitre / scène) — Pilier A.
+
+Générique : le Core (Java) est la SOURCE DE VÉRITÉ des champs (clé + libellé) et les
+passe en entrée ; ce module ne fait que formuler le prompt. Le modèle ne renvoie que les
+clés fournies et OMET celles pour lesquelles il n'a rien de pertinent (pas de remplissage forcé).
+"""
+from app.core.language import language_name
+
+# Étiquette lisible du type d'entité, pour la formulation du prompt.
+ENTITY_LABEL: dict[str, str] = {
+    "arc": "cet arc narratif",
+    "chapter": "ce chapitre",
+    "scene": "cette scène",
+}
+
+
+def narrative_fields_prompt(entity_type: str, entity_context: str, instruction: str,
+                            fields: list[dict], language: str) -> str:
+    """Construit le prompt d'étoffage. `fields` = [{key, label}] (whitelist du Core)."""
+    label = ENTITY_LABEL.get(entity_type or "", "cette entité narrative")
+    lines = []
+    for f in fields or []:
+        key = str(f.get("key") or "").strip()
+        if not key:
+            continue
+        flabel = str(f.get("label") or key).strip()
+        lines.append(f'- "{key}" : {flabel}')
+    fields_list = "\n".join(lines)
+    instruction_block = (
+        f"\nConsigne particulière du MJ : {instruction.strip()}\n"
+        if instruction and instruction.strip() else ""
+    )
+    return (
+        f"Tu es un co-Maître de Jeu. On te donne l'état ACTUEL d'{label} de jeu de rôle. "
+        "Propose des valeurs pour l'ÉTOFFER, cohérentes avec ce qui existe déjà.\n\n"
+        f"{entity_context.strip()}\n"
+        f"{instruction_block}\n"
+        "Champs que tu peux remplir (n'utilise QUE ces clés) :\n"
+        f"{fields_list}\n\n"
+        "Règles IMPÉRATIVES :\n"
+        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
+        '- Format exact : {"fields": {"cle": "valeur proposée", ...}}\n'
+        "- N'inclus QUE des clés de la liste ci-dessus. N'invente AUCUNE autre clé.\n"
+        "- Si un champ est déjà bien rempli ou si tu n'as rien de pertinent, OMETS-le "
+        "(ne le renvoie pas) plutôt que de le remplir de force.\n"
+        "- Reste cohérent avec le contexte : n'invente pas d'élément qui contredit "
+        "l'entité ou la campagne.\n"
+        f"- Rédige les valeurs en {language_name(language)}.\n"
+        "Renvoie maintenant le JSON."
+    )

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/scene_drafts.py

@@ -0,0 +1,30 @@
+"""Prompt d'ébauche de scènes pour un chapitre (Pilier A — capacité « create »).
+
+Le co-MJ propose plusieurs scènes cohérentes pour PEUPLER un chapitre vide (ou en manque).
+JSON structuré, une liste de scènes ; l'humain révise et ne crée que celles qu'il retient.
+"""
+from app.core.language import language_name
+
+
+def scene_drafts_prompt(context: str, instruction: str, count: int, language: str) -> str:
+    instruction_block = (
+        f"\nConsigne particulière du MJ : {instruction.strip()}\n"
+        if instruction and instruction.strip() else ""
+    )
+    return (
+        f"Tu es un co-Maître de Jeu. Propose {count} SCÈNES de jeu de rôle pour PEUPLER ce "
+        "chapitre, cohérentes entre elles et avec le contexte.\n\n"
+        f"{context.strip()}\n"
+        f"{instruction_block}\n"
+        "Règles IMPÉRATIVES :\n"
+        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
+        '- Format exact : {"scenes": [{"name": "...", "description": "...", "playerNarration": "..."}]}\n'
+        f"- Propose AU PLUS {count} scènes, distinctes et complémentaires (une progression du chapitre).\n"
+        "- 'name' : titre court et évocateur (OBLIGATOIRE).\n"
+        "- 'description' : un résumé bref (une phrase).\n"
+        "- 'playerNarration' : 2-3 phrases de mise en scène lues aux joueurs.\n"
+        "- Ne DUPLIQUE pas les scènes déjà présentes ; reste cohérent avec le chapitre et la campagne "
+        "(n'invente pas d'élément qui les contredit).\n"
+        f"- Rédige en {language_name(language)}.\n"
+        "Renvoie maintenant le JSON."
+    )

brain/app/application/prompts/session_recap.py

@@ -0,0 +1,25 @@
+"""Prompt du récap « précédemment dans… » (mode séance).
+
+Le Core envoie le journal chronologique de la séance PRÉCÉDENTE ; le modèle rédige un
+récapitulatif court, à lire aux joueurs à l'ouverture de la séance suivante. Texte libre
+(pas de JSON) : c'est de la narration.
+"""
+from app.core.language import language_name
+
+
+def session_recap_prompt(transcript: str, context: str, language: str) -> str:
+    context_block = f"\n{context.strip()}\n" if context and context.strip() else ""
+    return (
+        "Tu es le Maître du Jeu. Voici le journal de la SÉANCE PRÉCÉDENTE de ta table "
+        "(entrées chronologiques : notes, évènements, jets de dés, actions des joueurs).\n"
+        f"{context_block}\n"
+        "Journal :\n"
+        f"{transcript.strip()}\n\n"
+        "Rédige un récapitulatif « Précédemment… » à LIRE AUX JOUEURS pour ouvrir la "
+        "nouvelle séance :\n"
+        "- 4 à 8 phrases, ton narratif et vivant, au passé.\n"
+        "- Uniquement ce qui s'est réellement passé dans le journal — n'invente RIEN, "
+        "ne révèle aucun secret du MJ.\n"
+        "- Termine sur la situation où les joueurs se sont arrêtés (le « cliffhanger »).\n"
+        f"- Rédige en {language_name(language)}. Pas de préambule ni de méta : juste le récit."
+    )

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

@@ -0,0 +1,51 @@
+"""Réécriture de la question courante en question AUTONOME (chat des ateliers).
+
+Problème : le retrieval (embedding) et la phase MAP de l'analyse approfondie ne
+voient que le DERNIER message. Une relance comme « et ses faiblesses ? » ne
+contient pas le sujet (Strahd) → recherche aveugle. La parade standard
+(conversational query rewriting) : un appel LLM léger condense la conversation
+en une question autonome, utilisée UNIQUEMENT pour la recherche — la réponse
+finale, elle, voit toujours l'historique complet.
+"""
+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__)
+
+# Nombre de messages récents fournis au réécrivain (assez pour résoudre les
+# pronoms, pas plus — la latence de cet appel doit rester négligeable).
+_MAX_HISTORY = 6
+
+# Garde-fou : une « question » réécrite anormalement longue est suspecte (le
+# modèle a divagué) → on retombe sur la question brute.
+_MAX_REWRITE_CHARS = 400
+
+
+async def standalone_question(llm, messages: list[ChatMessage]) -> str:
+    """Condense `messages` en une question autonome pour la RECHERCHE.
+
+    Best-effort : premier message de la conversation, échec LLM ou réponse
+    suspecte → on renvoie simplement la dernière question brute (comportement
+    historique). `llm` doit exposer `generate()` (duck typing des adapters).
+    """
+    last_user = next((m.content for m in reversed(messages) if m.role == "user"), "")
+    user_turns = sum(1 for m in messages if m.role == "user" and m.content.strip())
+    if user_turns <= 1 or not last_user.strip():
+        return last_user  # pas d'historique à résoudre → appel LLM inutile
+
+    recent = [m for m in messages if m.content.strip()][-_MAX_HISTORY:]
+    conversation = "\n".join(f"{m.role.upper()}: {m.content.strip()}" for m in recent)
+    try:
+        raw = await llm.generate(
+            prompts.REWRITE_PROMPT.format(conversation=conversation), temperature=0.0)
+    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
+    rewritten = (raw or "").strip().strip('"').strip()
+    if not rewritten or len(rewritten) > _MAX_REWRITE_CHARS:
+        return last_user
+    return rewritten

brain/app/application/rerank.py

@@ -0,0 +1,64 @@
+"""Reranking LLM des passages RAG (chat des ateliers).
+
+Le cosinus classe par similarité de SURFACE ; sur les questions ambiguës, des
+passages proches lexicalement mais inutiles passent devant l'extrait qui répond
+vraiment. Le reranking récupère un POOL élargi (ex. 3× top_k), fait noter la
+pertinence de chaque extrait par le LLM en UN appel, et garde les top_k mieux
+notés. Coût : ~1 appel LLM avant le premier token — opt-in via RAG_RERANK.
+"""
+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__)
+
+# Taille du pool élargi : multiple du top_k demandé, plafonné (le prompt de
+# notation doit rester raisonnable même avec rag_top_k élevé).
+POOL_FACTOR = 3
+POOL_MAX = 24
+
+# Un extrait long n'a pas besoin d'être noté en entier : tronquer borne le
+# prompt sans changer le jugement de pertinence.
+_EXCERPT_CHARS = 600
+
+
+def pool_size(top_k: int) -> int:
+    """Taille du pool à récupérer avant reranking."""
+    return min(max(top_k * POOL_FACTOR, top_k), POOL_MAX)
+
+
+async def rerank(llm, question: str, passages: list[dict], top_k: int) -> list[dict]:
+    """Renvoie les `top_k` passages les mieux notés par le LLM (tri stable :
+    à note égale, l'ordre cosinus d'origine est préservé).
+
+    BEST-EFFORT : échec LLM, JSON invalide ou nombre de notes incohérent →
+    on renvoie simplement les `top_k` premiers du classement cosinus.
+    """
+    if len(passages) <= top_k:
+        return passages
+    numbered = "\n\n".join(
+        f"--- EXTRAIT {i + 1} ---\n{(p.get('text') or '')[:_EXCERPT_CHARS]}"
+        for i, p in enumerate(passages)
+    )
+    prompt = prompts.RERANK_PROMPT.format(
+        question=question, passages=numbered, count=len(passages))
+    try:
+        raw = await llm.generate(prompt, temperature=0.0)
+    except Exception as exc:  # noqa: BLE001 — un chat dégradé vaut mieux que pas de chat
+        logger.warning("Reranking ignoré (échec LLM) : %s", exc)
+        return passages[:top_k]
+    parsed, _ = load_json_object(raw)
+    scores = parsed.get("scores") if isinstance(parsed, dict) else None
+    if not isinstance(scores, list) or len(scores) != len(passages):
+        logger.warning("Reranking ignoré (notes inexploitables).")
+        return passages[:top_k]
+    try:
+        scored = [(float(s), i) for i, s in enumerate(scores)]
+    except (TypeError, ValueError):
+        logger.warning("Reranking ignoré (notes non numériques).")
+        return passages[:top_k]
+    order = sorted(range(len(passages)), key=lambda i: (-scored[i][0], i))
+    return [passages[i] for i in order[:top_k]]

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/config.py

@@ -83,6 +83,32 @@ class Settings(BaseSettings):
     # mais prompt plus long. 8 par défaut (montable jusqu'à ~20 sur grand contexte).
     rag_top_k: int = 8
 
+    # Analyse approfondie : pré-filtrage des lots via un index de résumés
+    # (construit une fois par source, cache disque). Les questions ciblées ne
+    # relisent que les lots plausiblement pertinents (3-5x moins d'appels) ;
+    # False = relire TOUT le document à chaque question (exhaustivité maximale).
+    deep_summary_filter: bool = True
+
+    # Reranking LLM du chat atelier : recupere un pool elargi (3x top_k, max 24)
+    # puis fait NOTER la pertinence de chaque extrait par le LLM avant d'injecter
+    # les top_k meilleurs. Meilleure precision sur les questions ambigues, MAIS
+    # +1 appel LLM avant le premier token (quelques secondes sur un petit modele
+    # local). Desactive par defaut ; recommande avec un provider cloud rapide.
+    rag_rerank: bool = False
+
+    # Cosinus minimal pour qu'un extrait soit injecté dans le prompt du chat
+    # atelier : en dessous, l'extrait n'a aucun rapport avec la question → mieux
+    # vaut moins d'extraits que du bruit. Défaut conservateur (0.30) : les paires
+    # pertinentes scorent typiquement 0.6+ avec nomic-embed-text/mistral-embed,
+    # les hors-sujet 0.2-0.4. Montable à ~0.4 si trop de bruit, 0 = désactivé.
+    rag_min_score: float = 0.30
+
+    # Nombre d'appels LLM MAP menes EN PARALLELE (import de campagne, analyse
+    # approfondie). 3 = bon defaut cloud (divise le temps d'un gros livre par ~3).
+    # Ollama local sequence les requetes de toute facon (pas de gain, pas de mal).
+    # Baisser a 1 si un provider gratuit rate-limite agressivement.
+    llm_map_concurrency: int = 3
+
     # Taille cible d'un morceau (en tokens) pour l'import de PDF (regles/campagne).
     # Plus c'est gros, moins il y a de morceaux => moins de fragmentation et un
     # import plus rapide, MAIS il faut que ca tienne dans la fenetre du modele.

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/models.py

@@ -320,11 +320,26 @@ class ExtractedPage:
     used_ocr: bool
 
 
+@dataclass(frozen=True)
+class TocEntry:
+    """Une entrée de la table des matières (bookmarks/outline) du PDF.
+
+    `level` : profondeur 1-based (1 = chapitre, 2 = section…). `page` : 1-based.
+    """
+
+    level: int
+    title: str
+    page: int
+
+
 @dataclass(frozen=True)
 class ExtractedDocument:
     """Résultat brut de l'extraction d'un PDF : une entrée par page."""
 
     pages: list[ExtractedPage]
+    # Table des matières (bookmarks PDF). Vide si le PDF n'en a pas — fréquent
+    # pour les scans ; les livres born-digital en ont presque toujours une.
+    toc: list[TocEntry] = field(default_factory=list)
 
     @property
     def page_count(self) -> int:
@@ -409,6 +424,18 @@ class ArcProposal:
     chapters: list[ChapterProposal] = field(default_factory=list)
 
 
+@dataclass(frozen=True)
+class NpcImportProposal:
+    """PNJ/créature notable détecté à l'import d'un PDF de campagne.
+
+    PNJ NOMMÉS et créatures uniques (boss) — pas les monstres génériques.
+    `description` = courte fiche (rôle, apparence, motivations, où on le croise).
+    """
+
+    name: str
+    description: str = ""
+
+
 @dataclass(frozen=True)
 class CampaignImportResult:
     """Proposition d'arborescence narrative extraite d'un PDF de campagne.
@@ -420,6 +447,9 @@ class CampaignImportResult:
     arcs: list[ArcProposal]
     page_count: int
     ocr_page_count: int
+    # PNJ/créatures notables détectés au fil des morceaux (proposition, à cocher
+    # dans l'écran de revue avant création).
+    npcs: list[NpcImportProposal] = field(default_factory=list)
 
     def counts(self) -> tuple[int, int, int]:
         """(nb arcs, nb chapitres, nb scènes) — pour le diagnostic / la progression."""

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/base_openai_adapter.py

@@ -0,0 +1,226 @@
+"""Socle commun aux adapters LLM « OpenAI-compatible » (OpenRouter, Gemini,
+Mistral) — ils exposent tous `POST {base}/chat/completions` en SSE avec le même
+schéma de payload et de flux.
+
+Cette classe de base porte la mécanique partagée (construction du payload, appel
+HTTP streamé, parsing SSE, garde-fous de timeout au temps écoulé, traduction des
+erreurs). Chaque adapter concret ne fournit plus que ses spécificités :
+URL, en-têtes, support du mode JSON natif, messages d'erreur, lecture de la config.
+
+`generate` one-shot passe lui aussi par le streaming (puis recollage) pour éviter
+les coupures de passerelle sur les longues générations (cf. Cloudflare 524).
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import AsyncIterator
+
+import httpx
+
+from app.domain.models import ChatMessage
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
+
+logger = logging.getLogger(__name__)
+
+# Délai max pour le PREMIER token de contenu. Un modèle « en file d'attente »
+# n'envoie que des keep-alive (aucun contenu) → on échoue vite et clairement au
+# lieu de pendre. Le timeout réseau d'httpx ne suffit pas : des keep-alive font
+# « arriver des octets » et empêchent son read-timeout de se déclencher.
+_FIRST_TOKEN_TIMEOUT_SECONDS = 120.0
+
+
+class BaseOpenAICompatibleAdapter:
+    """Base des adapters clients d'une API OpenAI-compatible (chat/completions SSE).
+
+    Satisfait par duck typing les ports LLMProvider et LLMChatProvider. Les
+    sous-classes définissent : ``_provider_label``, ``_api_url``,
+    ``_supports_json_object`` (mode JSON natif), et surchargent au besoin
+    ``_headers`` / ``_error_for_status`` / les messages de timeout.
+    """
+
+    # Surchargés par les sous-classes.
+    _provider_label: str = "LLM"
+    _api_url: str = ""
+    _supports_json_object: bool = False
+
+    def __init__(self, api_key: str, model: str, timeout: int) -> None:
+        self._api_key = api_key
+        self._model = model
+        self._timeout = timeout
+
+    # --- Spécificités surchargeables ----------------------------------------
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def _first_token_timeout_message(self) -> str:
+        return (
+            f"Erreur {self._provider_label} : aucun contenu produit en "
+            f"{int(_FIRST_TOKEN_TIMEOUT_SECONDS)}s — le modèle est probablement en "
+            "file d'attente / saturé. Réessayez plus tard ou choisissez un autre modèle."
+        )
+
+    def _generation_timeout_message(self) -> str:
+        return (
+            f"Erreur {self._provider_label} : 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."
+        )
+
+    def _error_for_status(self, status_code: int, detail: str) -> LLMProviderError:
+        """Erreur de domaine pour une réponse HTTP >= 400 (détail déjà lu)."""
+        return LLMProviderError(
+            f"Erreur {self._provider_label} (HTTP {status_code})"
+            + (f" : {detail[:500]}" if detail else "")
+        )
+
+    # --- API publique (ports) -----------------------------------------------
+
+    async def generate(
+        self,
+        prompt: str,
+        *,
+        output_format: str | None = None,
+        temperature: float | None = None,
+    ) -> str:
+        """One-shot via streaming (puis recollage), avec garde-fous au temps écoulé."""
+        return await self._collect_with_timeouts(
+            [ChatMessage(role="user", content=prompt)], temperature, output_format
+        )
+
+    async def stream_chat(
+        self,
+        messages: list[ChatMessage],
+        *,
+        system_prompt: str | None = None,
+        temperature: float | None = None,
+    ) -> AsyncIterator[str]:
+        async for token in self._stream(messages, system_prompt, temperature):
+            yield token
+
+    # --- Mécanique partagée -------------------------------------------------
+
+    async def _collect_with_timeouts(
+        self,
+        messages: list[ChatMessage],
+        temperature: float | None,
+        output_format: str | None,
+    ) -> str:
+        """Collecte le stream avec DEUX garde-fous au temps écoulé :
+        - 1er token borné (`_FIRST_TOKEN_TIMEOUT_SECONDS`) : détecte un modèle bloqué
+          en file d'attente (que des keep-alive, aucun contenu) → échec rapide ;
+        - ceiling global (`self._timeout`) : génération qui ne se termine jamais.
+        """
+        async def _collect() -> str:
+            chunks: list[str] = []
+            agen = self._stream(messages, None, temperature, output_format)
+            try:
+                while True:
+                    # Borne SEULEMENT l'attente du 1er token ; ensuite on laisse
+                    # générer (le ceiling global couvre le reste).
+                    first = _FIRST_TOKEN_TIMEOUT_SECONDS if not chunks else None
+                    try:
+                        token = await asyncio.wait_for(agen.__anext__(), timeout=first)
+                    except StopAsyncIteration:
+                        break
+                    except asyncio.TimeoutError:
+                        raise LLMProviderError(self._first_token_timeout_message())
+                    chunks.append(token)
+            finally:
+                await agen.aclose()
+            return "".join(chunks)
+
+        try:
+            return await asyncio.wait_for(_collect(), timeout=self._timeout)
+        except asyncio.TimeoutError as exc:
+            raise LLMGenerationTimeout(self._generation_timeout_message()) from exc
+
+    def _build_body(
+        self,
+        messages: list[ChatMessage],
+        system_prompt: str | None,
+        temperature: float | None,
+        output_format: str | None,
+    ) -> dict[str, object]:
+        payload_messages: list[dict[str, str]] = []
+        if system_prompt:
+            payload_messages.append({"role": "system", "content": system_prompt})
+        for m in messages:
+            payload_messages.append({"role": m.role, "content": m.content})
+
+        body: dict[str, object] = {
+            "model": self._model,
+            "messages": payload_messages,
+            "stream": True,
+        }
+        if temperature is not None:
+            body["temperature"] = temperature
+        # Mode JSON natif : supprime les fences ```json et le JSON invalide (retours
+        # à la ligne bruts), principale cause de morceaux d'import 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. Désactivé pour les
+        # providers/modèles gratuits qui ne le supportent pas (réponse vide).
+        if self._supports_json_object and output_format is not None:
+            body["response_format"] = {"type": "json_object"}
+        return body
+
+    async def _stream(
+        self,
+        messages: list[ChatMessage],
+        system_prompt: str | None,
+        temperature: float | None,
+        output_format: str | None = None,
+    ) -> AsyncIterator[str]:
+        body = self._build_body(messages, system_prompt, temperature, output_format)
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            try:
+                async with client.stream(
+                    "POST", self._api_url, headers=self._headers(), json=body
+                ) as response:
+                    if response.status_code >= 400:
+                        # En streaming le corps n'est pas lu automatiquement : on le
+                        # lit pour exposer le détail du provider (le 429 précise le
+                        # type de quota, le 401 la clé invalide…), sinon on n'a que
+                        # le code HTTP nu et le diagnostic est impossible.
+                        detail = (await response.aread()).decode("utf-8", "replace").strip()
+                        raise self._error_for_status(response.status_code, detail)
+                    async for token in self._parse_sse(response):
+                        yield token
+            except httpx.HTTPError as exc:
+                raise LLMProviderError(self._format_http_error(exc)) from exc
+
+    @staticmethod
+    async def _parse_sse(response: httpx.Response) -> AsyncIterator[str]:
+        """SSE OpenAI : lignes `data: {json}`, fin sur `data: [DONE]`."""
+        async for line in response.aiter_lines():
+            if not line or not line.startswith("data:"):
+                continue  # lignes vides ou commentaires keep-alive (`: ...`)
+            data = line[len("data:"):].strip()
+            if data == "[DONE]":
+                return
+            try:
+                obj = json.loads(data)
+            except json.JSONDecodeError:
+                continue
+            choices = obj.get("choices")
+            if not choices:
+                continue
+            delta = choices[0].get("delta") or {}
+            content = delta.get("content")
+            if content:
+                yield content
+
+    def _format_http_error(self, exc: httpx.HTTPError) -> str:
+        """Message lisible (timeout, quota 429, crédits 402, modèle inconnu…)."""
+        if isinstance(exc, httpx.TimeoutException):
+            return (
+                f"Erreur {self._provider_label} : délai dépassé (timeout {self._timeout}s). "
+                "Le modèle a mis trop de temps — réduis la taille des morceaux d'import ou "
+                "augmente le timeout."
+            )
+        detail = str(exc) or exc.__class__.__name__
+        return f"Erreur {self._provider_label} ({exc.__class__.__name__}) : {detail}"

brain/app/infrastructure/gemini_adapter.py

@@ -1,178 +1,66 @@
 """Adapter Google Gemini — implémente les ports LLMProvider / LLMChatProvider.
 
 Gemini expose un endpoint COMPATIBLE OpenAI
-(POST {base}/openai/chat/completions, SSE), donc cet adapter est un client
-"OpenAI-compatible" — même structure que les adapters OpenRouter / Mistral.
+(POST {base}/openai/chat/completions, SSE) : client "OpenAI-compatible" qui hérite
+de BaseOpenAICompatibleAdapter et ne fournit que ses spécificités (dont un message
+dédié quand Google refuse la clé en 401/403).
 
 Tier GRATUIT : clé API sur aistudio.google.com (sans CB). Atout majeur pour
 l'extraction de PDF : un CONTEXTE de ~1M tokens → un livre entier tient en 1-2
-appels, donc quasi aucun morceau perdu et peu de requêtes (limites jamais
-atteintes). Modèle conseillé : `gemini-2.0-flash` (rapide, gros contexte, fidèle).
+appels. Modèle conseillé : `gemini-2.0-flash` (rapide, gros contexte, fidèle).
 """
 from __future__ import annotations
 
-import asyncio
-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
-
-logger = logging.getLogger(__name__)
-
-_API_URL = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
-
-# Délai max pour le PREMIER token de contenu (échec rapide si le modèle ne produit
-# rien). Gemini répond vite ; 120s est large.
-_FIRST_TOKEN_TIMEOUT_SECONDS = 120.0
+from app.infrastructure.base_openai_adapter import (
+    _FIRST_TOKEN_TIMEOUT_SECONDS,
+    BaseOpenAICompatibleAdapter,
+)
 
 
-class GeminiLLMProvider:
+class GeminiLLMProvider(BaseOpenAICompatibleAdapter):
     """Adapter Gemini (OpenAI-compatible) — satisfait LLMProvider et LLMChatProvider."""
 
+    _provider_label = "Gemini"
+    _api_url = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
+    _supports_json_object = True
+
     def __init__(self, settings: Settings) -> None:
         if not settings.gemini_api_key:
             raise LLMProviderError(
                 "Clé API Gemini manquante. Configure-la depuis l'écran Paramètres "
                 "(clé gratuite sur aistudio.google.com)."
             )
-        self._api_key = settings.gemini_api_key
-        self._model = settings.gemini_model
-        self._timeout = settings.llm_timeout_seconds
-
-    def _headers(self) -> dict[str, str]:
-        return {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
-
-    async def generate(
-        self,
-        prompt: str,
-        *,
-        output_format: str | None = None,
-        temperature: float | None = None,
-    ) -> str:
-        """One-shot via streaming (puis recollage), avec garde-fous au temps écoulé."""
-        return await self._collect_with_timeouts(
-            [ChatMessage(role="user", content=prompt)], temperature, output_format
+        super().__init__(
+            settings.gemini_api_key, settings.gemini_model, settings.llm_timeout_seconds
         )
 
-    async def _collect_with_timeouts(
-        self,
-        messages: list[ChatMessage],
-        temperature: float | None,
-        output_format: str | None,
-    ) -> str:
-        """Collecte le stream avec deux garde-fous : 1er token borné (échec rapide
-        si rien ne sort) + ceiling global `self._timeout`."""
-        async def _collect() -> str:
-            chunks: list[str] = []
-            agen = self._stream(messages, None, temperature, output_format)
-            try:
-                while True:
-                    first = _FIRST_TOKEN_TIMEOUT_SECONDS if not chunks else None
-                    try:
-                        token = await asyncio.wait_for(agen.__anext__(), timeout=first)
-                    except StopAsyncIteration:
-                        break
-                    except asyncio.TimeoutError:
-                        raise LLMProviderError(
+    def _headers(self) -> dict[str, str]:
+        return {**super()._headers(), "Accept": "application/json"}
+
+    def _first_token_timeout_message(self) -> str:
+        return (
             f"Erreur Gemini : aucun contenu produit en "
             f"{int(_FIRST_TOKEN_TIMEOUT_SECONDS)}s. Réessayez ou vérifiez "
             "votre quota gratuit."
         )
-                    chunks.append(token)
-            finally:
-                await agen.aclose()
-            return "".join(chunks)
 
-        try:
-            return await asyncio.wait_for(_collect(), timeout=self._timeout)
-        except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
+    def _generation_timeout_message(self) -> str:
+        return (
             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
-
-    async def stream_chat(
-        self,
-        messages: list[ChatMessage],
-        *,
-        system_prompt: str | None = None,
-        temperature: float | None = None,
-    ) -> AsyncIterator[str]:
-        async for token in self._stream(messages, system_prompt, temperature):
-            yield token
-
-    async def _stream(
-        self,
-        messages: list[ChatMessage],
-        system_prompt: str | None,
-        temperature: float | None,
-        output_format: str | None = None,
-    ) -> AsyncIterator[str]:
-        payload_messages: list[dict[str, str]] = []
-        if system_prompt:
-            payload_messages.append({"role": "system", "content": system_prompt})
-        for m in messages:
-            payload_messages.append({"role": m.role, "content": m.content})
-
-        body: dict[str, object] = {
-            "model": self._model,
-            "messages": payload_messages,
-            "stream": True,
-        }
-        if temperature is not None:
-            body["temperature"] = temperature
-
-        async with httpx.AsyncClient(timeout=self._timeout) as client:
-            try:
-                async with client.stream(
-                    "POST", _API_URL, headers=self._headers(), json=body
-                ) as response:
-                    if response.status_code >= 400:
-                        detail = (await response.aread()).decode("utf-8", "replace").strip()
-                        raise LLMProviderError(
-                            f"Erreur Gemini (HTTP {response.status_code})"
-                            + (f" : {detail[:500]}" if detail else "")
         )
-                    async for token in self._parse_sse(response):
-                        yield token
-            except httpx.HTTPError as exc:
-                raise LLMProviderError(self._format_http_error(exc)) from exc
 
-    @staticmethod
-    async def _parse_sse(response: httpx.Response) -> AsyncIterator[str]:
-        """SSE OpenAI : lignes `data: {json}`, fin sur `data: [DONE]`."""
-        async for line in response.aiter_lines():
-            if not line or not line.startswith("data:"):
-                continue
-            data = line[len("data:"):].strip()
-            if data == "[DONE]":
-                return
-            try:
-                obj = json.loads(data)
-            except json.JSONDecodeError:
-                continue
-            choices = obj.get("choices")
-            if not choices:
-                continue
-            delta = choices[0].get("delta") or {}
-            content = delta.get("content")
-            if content:
-                yield content
-
-    def _format_http_error(self, exc: httpx.HTTPError) -> str:
-        if isinstance(exc, httpx.TimeoutException):
-            return (
-                f"Erreur Gemini : délai dépassé (timeout {self._timeout}s). Le modèle a "
-                "mis trop de temps — réduis la taille des morceaux d'import ou augmente le timeout."
+    def _error_for_status(self, status_code: int, detail: str) -> LLMProviderError:
+        # 401/403 = clé rejetée par GOOGLE (pas un problème LoreMind) : message
+        # actionnable plutôt que le JSON brut de l'API.
+        if status_code in (401, 403):
+            return LLMProviderError(
+                "Erreur Gemini : clé API refusée par Google "
+                f"(HTTP {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]}"
             )
-        detail = str(exc) or exc.__class__.__name__
-        return f"Erreur Gemini ({exc.__class__.__name__}) : {detail}"
+        return super()._error_for_status(status_code, detail)

brain/app/infrastructure/mistral_adapter.py

@@ -1,188 +1,48 @@
 """Adapter Mistral — implémente les ports LLMProvider / LLMChatProvider.
 
 Mistral (La Plateforme) expose l'API OpenAI standard (POST {base}/chat/completions,
-SSE), donc cet adapter est un client "OpenAI-compatible" — même structure que
-l'adapter OpenRouter. Le `generate` one-shot passe par le streaming (puis
-recollage) avec un timeout au temps écoulé pour ne jamais pendre à l'infini.
+SSE) : client "OpenAI-compatible" qui hérite de BaseOpenAICompatibleAdapter et ne
+fournit que ses spécificités.
 
 Tier GRATUIT : compte sur console.mistral.ai (tier « Experiment »), clé API à
 coller dans l'écran Paramètres. Modèles conseillés pour l'extraction : un grand
 contexte fidèle comme `mistral-large-latest` (128k) ou `mistral-small-latest`.
+
+Mode JSON natif : TOUS les modèles Mistral le supportent (`_supports_json_object`).
 """
 from __future__ import annotations
 
-import asyncio
-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
-
-logger = logging.getLogger(__name__)
-
-_API_URL = "https://api.mistral.ai/v1/chat/completions"
-
-# Délai max pour le PREMIER token de contenu (échec rapide si le modèle est en file
-# d'attente et n'envoie que des keep-alive). Généreux car la file d'un tier gratuit
-# peut être longue.
-_FIRST_TOKEN_TIMEOUT_SECONDS = 120.0
+from app.infrastructure.base_openai_adapter import (
+    _FIRST_TOKEN_TIMEOUT_SECONDS,
+    BaseOpenAICompatibleAdapter,
+)
 
 
-class MistralLLMProvider:
+class MistralLLMProvider(BaseOpenAICompatibleAdapter):
     """Adapter Mistral (OpenAI-compatible) — satisfait LLMProvider et LLMChatProvider."""
 
+    _provider_label = "Mistral"
+    _api_url = "https://api.mistral.ai/v1/chat/completions"
+    _supports_json_object = True
+
     def __init__(self, settings: Settings) -> None:
         if not settings.mistral_api_key:
             raise LLMProviderError(
                 "Clé API Mistral manquante. Configure-la depuis l'écran Paramètres."
             )
-        self._api_key = settings.mistral_api_key
-        self._model = settings.mistral_model
-        self._timeout = settings.llm_timeout_seconds
-
-    def _headers(self) -> dict[str, str]:
-        return {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
-
-    async def generate(
-        self,
-        prompt: str,
-        *,
-        output_format: str | None = None,
-        temperature: float | None = None,
-    ) -> str:
-        """One-shot via streaming (puis recollage) pour robustesse sur longues sorties.
-
-        Timeout au TEMPS ÉCOULÉ (asyncio) en plus du timeout réseau d'httpx :
-        si le provider envoyait des keep-alive sans contenu, l'appel pendrait à
-        l'infini. Ici on coupe net après `self._timeout` secondes.
-        """
-        return await self._collect_with_timeouts(
-            [ChatMessage(role="user", content=prompt)], temperature, output_format
+        super().__init__(
+            settings.mistral_api_key, settings.mistral_model, settings.llm_timeout_seconds
         )
 
-    async def _collect_with_timeouts(
-        self,
-        messages: list[ChatMessage],
-        temperature: float | None,
-        output_format: str | None,
-    ) -> str:
-        """Collecte le stream avec deux garde-fous au temps écoulé : 1er token borné
-        (file d'attente → échec rapide) + ceiling global `self._timeout`."""
-        async def _collect() -> str:
-            chunks: list[str] = []
-            agen = self._stream(messages, None, temperature, output_format)
-            try:
-                while True:
-                    first = _FIRST_TOKEN_TIMEOUT_SECONDS if not chunks else None
-                    try:
-                        token = await asyncio.wait_for(agen.__anext__(), timeout=first)
-                    except StopAsyncIteration:
-                        break
-                    except asyncio.TimeoutError:
-                        raise LLMProviderError(
+    def _headers(self) -> dict[str, str]:
+        return {**super()._headers(), "Accept": "application/json"}
+
+    def _first_token_timeout_message(self) -> str:
+        return (
             f"Erreur Mistral : aucun contenu produit en "
             f"{int(_FIRST_TOKEN_TIMEOUT_SECONDS)}s — le modèle est probablement "
             "en file d'attente (tier gratuit, 2 req/min). Réessayez plus tard ou "
             "choisissez un modèle plus disponible."
         )
-                    chunks.append(token)
-            finally:
-                await agen.aclose()
-            return "".join(chunks)
-
-        try:
-            return await asyncio.wait_for(_collect(), timeout=self._timeout)
-        except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
-                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
-
-    async def stream_chat(
-        self,
-        messages: list[ChatMessage],
-        *,
-        system_prompt: str | None = None,
-        temperature: float | None = None,
-    ) -> AsyncIterator[str]:
-        async for token in self._stream(messages, system_prompt, temperature):
-            yield token
-
-    async def _stream(
-        self,
-        messages: list[ChatMessage],
-        system_prompt: str | None,
-        temperature: float | None,
-        output_format: str | None = None,
-    ) -> AsyncIterator[str]:
-        payload_messages: list[dict[str, str]] = []
-        if system_prompt:
-            payload_messages.append({"role": "system", "content": system_prompt})
-        for m in messages:
-            payload_messages.append({"role": m.role, "content": m.content})
-
-        body: dict[str, object] = {
-            "model": self._model,
-            "messages": payload_messages,
-            "stream": True,
-        }
-        if temperature is not None:
-            body["temperature"] = temperature
-
-        async with httpx.AsyncClient(timeout=self._timeout) as client:
-            try:
-                async with client.stream(
-                    "POST", _API_URL, headers=self._headers(), json=body
-                ) as response:
-                    if response.status_code >= 400:
-                        # En streaming le corps n'est pas lu automatiquement : on le
-                        # lit pour exposer le détail de Mistral (modèle inconnu, clé
-                        # invalide 401, quota 429…), sinon on n'a que le code HTTP nu.
-                        detail = (await response.aread()).decode("utf-8", "replace").strip()
-                        raise LLMProviderError(
-                            f"Erreur Mistral (HTTP {response.status_code})"
-                            + (f" : {detail[:500]}" if detail else "")
-                        )
-                    async for token in self._parse_sse(response):
-                        yield token
-            except httpx.HTTPError as exc:
-                raise LLMProviderError(self._format_http_error(exc)) from exc
-
-    @staticmethod
-    async def _parse_sse(response: httpx.Response) -> AsyncIterator[str]:
-        """SSE OpenAI : lignes `data: {json}`, fin sur `data: [DONE]`."""
-        async for line in response.aiter_lines():
-            if not line or not line.startswith("data:"):
-                continue  # lignes vides ou keep-alive (`: ...`)
-            data = line[len("data:"):].strip()
-            if data == "[DONE]":
-                return
-            try:
-                obj = json.loads(data)
-            except json.JSONDecodeError:
-                continue
-            choices = obj.get("choices")
-            if not choices:
-                continue
-            delta = choices[0].get("delta") or {}
-            content = delta.get("content")
-            if content:
-                yield content
-
-    def _format_http_error(self, exc: httpx.HTTPError) -> str:
-        """Message lisible (timeout, quota 429, clé invalide 401, modèle inconnu…)."""
-        if isinstance(exc, httpx.TimeoutException):
-            return (
-                f"Erreur Mistral : délai dépassé (timeout {self._timeout}s). Le modèle a "
-                "mis trop de temps — réduis la taille des morceaux d'import ou augmente le timeout."
-            )
-        detail = str(exc) or exc.__class__.__name__
-        return f"Erreur Mistral ({exc.__class__.__name__}) : {detail}"

brain/app/infrastructure/mistral_embedding_adapter.py

@@ -28,7 +28,8 @@ class MistralEmbeddingProvider:
         self._model = settings.mistral_embedding_model
         self._timeout = settings.llm_timeout_seconds
 
-    async def embed(self, texts: list[str]) -> list[list[float]]:
+    async def embed(self, texts: list[str], kind: str = "document") -> list[list[float]]:
+        # `kind` ignoré : mistral-embed n'utilise pas de préfixe de tâche.
         if not texts:
             return []
         out: list[list[float]] = []

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/ollama_embedding_adapter.py

@@ -11,6 +11,14 @@ from app.application.embeddings import EmbeddingError
 from app.core.config import Settings
 
 
+# Préfixes de tâche des modèles nomic-embed : le modèle est ENTRAÎNÉ avec
+# (search_document pour le corpus, search_query pour la question). Sans eux,
+# la pertinence du retrieval est mesurablement dégradée. Ne s'applique qu'aux
+# modèles nomic — les autres (mxbai, bge…) ont leurs propres conventions ou
+# aucune ; on reste neutre pour eux.
+_NOMIC_PREFIXES = {"document": "search_document: ", "query": "search_query: "}
+
+
 class OllamaEmbeddingProvider:
     """Implémente EmbeddingProvider via Ollama /api/embed (batch)."""
 
@@ -19,11 +27,22 @@ class OllamaEmbeddingProvider:
         self._model = settings.ollama_embedding_model
         self._timeout = settings.llm_timeout_seconds
 
-    async def embed(self, texts: list[str]) -> list[list[float]]:
+    def _prepare(self, texts: list[str], kind: str) -> list[str]:
+        """Applique le préfixe de tâche si le modèle est de la famille nomic-embed.
+
+        NB : les sources indexées AVANT l'introduction des préfixes doivent être
+        ré-uploadées pour que documents et questions vivent dans le même espace.
+        """
+        if "nomic-embed" not in self._model:
+            return texts
+        prefix = _NOMIC_PREFIXES.get(kind, _NOMIC_PREFIXES["document"])
+        return [prefix + t for t in texts]
+
+    async def embed(self, texts: list[str], kind: str = "document") -> list[list[float]]:
         if not texts:
             return []
         url = f"{self._base_url}/api/embed"
-        payload = {"model": self._model, "input": texts}
+        payload = {"model": self._model, "input": self._prepare(texts, kind)}
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:
                 response = await client.post(url, json=payload)

brain/app/infrastructure/ollama_model_installer.py

@@ -0,0 +1,51 @@
+"""Auto-installation du modèle d'embeddings Ollama au démarrage du Brain.
+
+Adapter d'infrastructure : parle directement à l'API HTTP d'Ollama. Best-effort
+(Ollama peut être absent / la connexion limitée) — n'empêche jamais le démarrage.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+async def ensure_ollama_embedding_model(base_url: str, model: str) -> None:
+    """Télécharge `model` sur le serveur Ollama s'il n'y est pas déjà.
+
+    Attend qu'Ollama soit joignable (ordre de démarrage des conteneurs), puis
+    vérifie la présence du modèle avant de le tirer.
+    """
+    for attempt in range(10):
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                tags = await client.get(f"{base_url}/api/tags")
+                tags.raise_for_status()
+                names = [m.get("name", "") for m in tags.json().get("models", [])]
+            if any(n == model or n.startswith(model + ":") for n in names):
+                logger.info("Modèle d'embedding '%s' déjà présent.", model)
+                return
+            break  # Ollama joignable, modèle absent → on tire (ci-dessous)
+        except httpx.HTTPError:
+            await asyncio.sleep(min(5 * (attempt + 1), 30))
+    else:
+        logger.warning(
+            "Ollama injoignable au démarrage — modèle d'embedding '%s' non auto-installé "
+            "(il sera tirable manuellement : ollama pull %s).", model, model)
+        return
+
+    logger.info("Téléchargement automatique du modèle d'embedding '%s'…", model)
+    try:
+        async with httpx.AsyncClient(timeout=None) as client:
+            async with client.stream("POST", f"{base_url}/api/pull", json={"name": model}) as resp:
+                resp.raise_for_status()
+                async for _line in resp.aiter_lines():
+                    pass  # on draine la progression NDJSON jusqu'à la fin
+        logger.info("Modèle d'embedding '%s' prêt.", model)
+    except httpx.HTTPError as exc:
+        logger.warning(
+            "Auto-installation du modèle d'embedding '%s' échouée : %s "
+            "(tirage manuel possible : ollama pull %s).", model, exc, model)

brain/app/infrastructure/openrouter_adapter.py

@@ -1,205 +1,57 @@
 """Adapter OpenRouter — implémente les ports LLMProvider / LLMChatProvider.
 
 OpenRouter expose l'API OpenAI standard (POST {base}/chat/completions, SSE), donc
-cet adapter est en réalité un client "OpenAI-compatible". Le `generate` one-shot
-passe lui aussi par le streaming (puis recollage) pour éviter les coupures de
-passerelle sur les longues générations (cf. 1min.ai / Cloudflare 524).
+cet adapter est un client "OpenAI-compatible" : il hérite de toute la mécanique de
+BaseOpenAICompatibleAdapter et ne fournit que ses spécificités (URL, en-têtes
+d'attribution, messages, lecture de config).
 
 Modèles GRATUITS : utiliser un id finissant par `:free` (ex.
 `meta-llama/llama-3.3-70b-instruct:free`) ou le routeur `openrouter/free` (défaut)
 qui choisit automatiquement un modèle gratuit — aucun crédit consommé.
+
+NB : on n'impose PAS `response_format=json_object` (`_supports_json_object=False`).
+Beaucoup de modèles/providers GRATUITS ne le supportent pas et renvoient une
+réponse VIDE. On laisse le modèle répondre librement ; l'extraction JSON en aval
+(load_json_object + nettoyage du raisonnement) récupère le JSON dans la prose.
 """
 from __future__ import annotations
 
-import asyncio
-import json
-import logging
-from typing import AsyncIterator
-
-import httpx
-
 from app.core.config import Settings
-from app.domain.models import ChatMessage
-
-logger = logging.getLogger(__name__)
 from app.domain.ports import LLMProviderError
-
-_API_URL = "https://openrouter.ai/api/v1/chat/completions"
-
-# Délai max pour le PREMIER token de contenu. Un modèle gratuit "en file d'attente"
-# n'envoie que des keep-alive (aucun contenu) → on échoue vite et clairement au lieu
-# de pendre. Généreux (2 min) car la file d'attente d'un tier gratuit peut être longue.
-_FIRST_TOKEN_TIMEOUT_SECONDS = 120.0
+from app.infrastructure.base_openai_adapter import (
+    _FIRST_TOKEN_TIMEOUT_SECONDS,
+    BaseOpenAICompatibleAdapter,
+)
 
 
-class OpenRouterLLMProvider:
+class OpenRouterLLMProvider(BaseOpenAICompatibleAdapter):
     """Adapter OpenRouter (OpenAI-compatible) — satisfait LLMProvider et LLMChatProvider."""
 
+    _provider_label = "OpenRouter"
+    _api_url = "https://openrouter.ai/api/v1/chat/completions"
+    _supports_json_object = False
+
     def __init__(self, settings: Settings) -> None:
         if not settings.openrouter_api_key:
             raise LLMProviderError(
                 "Clé API OpenRouter manquante. Configure-la depuis l'écran Paramètres."
             )
-        self._api_key = settings.openrouter_api_key
-        self._model = settings.openrouter_model
-        self._timeout = settings.llm_timeout_seconds
+        super().__init__(
+            settings.openrouter_api_key, settings.openrouter_model, settings.llm_timeout_seconds
+        )
 
     def _headers(self) -> dict[str, str]:
         return {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
+            **super()._headers(),
             # Attribution facultative (classement OpenRouter) — sans impact fonctionnel.
             "HTTP-Referer": "https://loremind.app",
             "X-Title": "LoreMind",
         }
 
-    async def generate(
-        self,
-        prompt: str,
-        *,
-        output_format: str | None = None,
-        temperature: float | None = None,
-    ) -> str:
-        """One-shot via streaming (puis recollage) pour robustesse sur longues sorties.
-
-        Timeout au TEMPS ÉCOULÉ (asyncio) en plus du timeout réseau d'httpx : un
-        modèle gratuit saturé/en file d'attente envoie des keep-alive (`: OPENROUTER
-        PROCESSING`) mais AUCUN contenu → httpx ne déclenche jamais son read-timeout
-        (des octets arrivent) et l'appel pendrait à l'infini. Ici on coupe net après
-        `self._timeout` secondes, quoi qu'il arrive.
-        """
-        return await self._collect_with_timeouts(
-            [ChatMessage(role="user", content=prompt)], temperature, output_format, "OpenRouter"
-        )
-
-    async def _collect_with_timeouts(
-        self,
-        messages: list[ChatMessage],
-        temperature: float | None,
-        output_format: str | None,
-        provider: str,
-    ) -> str:
-        """Collecte le stream avec DEUX garde-fous au temps écoulé :
-        - 1er token borné (`_FIRST_TOKEN_TIMEOUT_SECONDS`) : détecte un modèle bloqué
-          en file d'attente (que des keep-alive, aucun contenu) → échec rapide ;
-        - ceiling global (`self._timeout`) : génération qui ne se termine jamais.
-        Le timeout réseau d'httpx ne suffit pas : des keep-alive font 'arriver des
-        octets' et empêchent son read-timeout de se déclencher.
-        """
-        async def _collect() -> str:
-            chunks: list[str] = []
-            agen = self._stream(messages, None, temperature, output_format)
-            try:
-                while True:
-                    # Borne SEULEMENT l'attente du 1er token (file d'attente) ; ensuite
-                    # on laisse générer (le ceiling global couvre le reste).
-                    first = _FIRST_TOKEN_TIMEOUT_SECONDS if not chunks else None
-                    try:
-                        token = await asyncio.wait_for(agen.__anext__(), timeout=first)
-                    except StopAsyncIteration:
-                        break
-                    except asyncio.TimeoutError:
-                        raise LLMProviderError(
-                            f"Erreur {provider} : aucun contenu produit en "
+    def _first_token_timeout_message(self) -> str:
+        return (
+            f"Erreur OpenRouter : aucun contenu produit en "
             f"{int(_FIRST_TOKEN_TIMEOUT_SECONDS)}s — le modèle gratuit est "
             "probablement en file d'attente / saturé. Réessayez plus tard ou "
             "choisissez un autre modèle (1min.ai, ou payant)."
         )
-                    chunks.append(token)
-            finally:
-                await agen.aclose()
-            return "".join(chunks)
-
-        try:
-            return await asyncio.wait_for(_collect(), timeout=self._timeout)
-        except asyncio.TimeoutError as exc:
-            raise LLMProviderError(
-                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
-
-    async def stream_chat(
-        self,
-        messages: list[ChatMessage],
-        *,
-        system_prompt: str | None = None,
-        temperature: float | None = None,
-    ) -> AsyncIterator[str]:
-        async for token in self._stream(messages, system_prompt, temperature):
-            yield token
-
-    async def _stream(
-        self,
-        messages: list[ChatMessage],
-        system_prompt: str | None,
-        temperature: float | None,
-        output_format: str | None = None,
-    ) -> AsyncIterator[str]:
-        payload_messages: list[dict[str, str]] = []
-        if system_prompt:
-            payload_messages.append({"role": "system", "content": system_prompt})
-        for m in messages:
-            payload_messages.append({"role": m.role, "content": m.content})
-
-        body: dict[str, object] = {
-            "model": self._model,
-            "messages": payload_messages,
-            "stream": True,
-        }
-        if temperature is not None:
-            body["temperature"] = temperature
-        # NB : on n'impose PAS `response_format=json_object`. Beaucoup de modèles/
-        # providers GRATUITS ne le supportent pas et renvoient une réponse VIDE.
-        # On laisse le modèle répondre librement ; l'extraction JSON en aval
-        # (load_json_object + nettoyage du raisonnement) récupère le JSON dans la prose.
-
-        async with httpx.AsyncClient(timeout=self._timeout) as client:
-            try:
-                async with client.stream(
-                    "POST", _API_URL, headers=self._headers(), json=body
-                ) as response:
-                    if response.status_code >= 400:
-                        # En streaming, le corps n'est pas lu automatiquement : on le
-                        # lit pour exposer le détail d'OpenRouter (ex. le 429 précise
-                        # "free-models-per-day" vs "per-minute"), sinon on n'a que le
-                        # code HTTP nu et le diagnostic est impossible.
-                        detail = (await response.aread()).decode("utf-8", "replace").strip()
-                        raise LLMProviderError(
-                            f"Erreur OpenRouter (HTTP {response.status_code})"
-                            + (f" : {detail[:500]}" if detail else "")
-                        )
-                    async for token in self._parse_sse(response):
-                        yield token
-            except httpx.HTTPError as exc:
-                raise LLMProviderError(self._format_http_error(exc)) from exc
-
-    @staticmethod
-    async def _parse_sse(response: httpx.Response) -> AsyncIterator[str]:
-        """SSE OpenAI : lignes `data: {json}`, fin sur `data: [DONE]`."""
-        async for line in response.aiter_lines():
-            if not line or not line.startswith("data:"):
-                continue  # lignes vides ou commentaires keep-alive (`: ...`)
-            data = line[len("data:"):].strip()
-            if data == "[DONE]":
-                return
-            try:
-                obj = json.loads(data)
-            except json.JSONDecodeError:
-                continue
-            choices = obj.get("choices")
-            if not choices:
-                continue
-            delta = choices[0].get("delta") or {}
-            content = delta.get("content")
-            if content:
-                yield content
-
-    def _format_http_error(self, exc: httpx.HTTPError) -> str:
-        """Message lisible (timeout, quota 429, crédits 402, modèle inconnu…)."""
-        if isinstance(exc, httpx.TimeoutException):
-            return (
-                f"Erreur OpenRouter : délai dépassé (timeout {self._timeout}s). Le modèle a "
-                "mis trop de temps — réduis la taille des morceaux d'import ou augmente le timeout."
-            )
-        detail = str(exc) or exc.__class__.__name__
-        return f"Erreur OpenRouter ({exc.__class__.__name__}) : {detail}"

brain/app/infrastructure/pdf_extractor.py

@@ -22,7 +22,7 @@ import pymupdf as fitz  # PyMuPDF — on importe par le nom canonique `pymupdf`
 # (et NON `import fitz`) pour éviter la collision avec le faux paquet PyPI "fitz"
 # qui échoue sur `from frontend import *`.
 
-from app.domain.models import ExtractedDocument, ExtractedPage
+from app.domain.models import ExtractedDocument, ExtractedPage, TocEntry
 from app.domain.ports import PdfExtractionError
 
 logger = logging.getLogger(__name__)
@@ -72,7 +72,18 @@ class PyMuPdfTextExtractor:
             raise PdfExtractionError(f"PDF illisible ou corrompu : {exc}") from exc
 
         pages: list[ExtractedPage] = []
+        toc: list[TocEntry] = []
         try:
+            # Bookmarks/outline du PDF : structure officielle du livre, gratuite
+            # (pas d'appel LLM). Sert de squelette de référence aux imports.
+            try:
+                for level, title, page_no in doc.get_toc(simple=True) or []:
+                    title = str(title or "").strip()
+                    if title:
+                        toc.append(TocEntry(level=int(level), title=title, page=int(page_no)))
+            except Exception as exc:  # noqa: BLE001 — TOC best-effort, jamais bloquante
+                logger.warning("Lecture de la table des matières impossible : %s", exc)
+
             for index, page in enumerate(doc):
                 text = (page.get_text() or "").strip()
                 used_ocr = False
@@ -85,7 +96,7 @@ class PyMuPdfTextExtractor:
         finally:
             doc.close()
 
-        return ExtractedDocument(pages=pages)
+        return ExtractedDocument(pages=pages, toc=toc)
 
     @staticmethod
     def _ocr_page(page: "fitz.Page") -> str:

brain/app/infrastructure/vector_store.py

@@ -5,6 +5,12 @@ Chaque SOURCE est persistée en un fichier JSON sur le volume `data/` du Brain :
 
 À l'échelle d'un livre (quelques centaines d'extraits), une recherche cosinus en
 Python pur est instantanée — inutile d'ajouter numpy/pgvector/une base vectorielle.
+Les fichiers sont mis en cache mémoire (invalidation par mtime) : le coûteux est
+le re-parse JSON des vecteurs, pas le cosinus.
+
+Recherche HYBRIDE : score = cosinus + bonus lexical (mots significatifs de la
+question présents dans l'extrait). Sur du JdR, les requêtes sont souvent des noms
+propres exacts (« Strahd », « Barovia ») où le lexical bat l'embedding.
 """
 from __future__ import annotations
 
@@ -16,6 +22,27 @@ from pathlib import Path
 _STORE_DIR = Path("data/notebooks")
 _SAFE_ID = re.compile(r"[^A-Za-z0-9_-]")
 
+# Cache mémoire {source_id: (mtime_ns, chunks)} — évite de relire/re-parser le JSON
+# (vecteurs = gros) à chaque question. Invalidé si le fichier change (mtime).
+_CACHE: dict[str, tuple[int, list[dict]]] = {}
+_CACHE_MAX_SOURCES = 32  # garde-fou mémoire : ~10 Mo par gros livre en cache
+
+# Poids du bonus lexical dans le score hybride. Le cosinus reste dominant ; le
+# bonus (0..0.15) sert surtout à départager / repêcher les correspondances exactes.
+_LEX_WEIGHT = 0.15
+_WORD_RE = re.compile(r"[a-z0-9àâäçéèêëîïôöùûüœæ]{3,}")
+# Mots-outils FR/EN fréquents (≥3 lettres) : sans eux, le bonus lexical serait
+# dominé par « les », « pour », « the »… au lieu des termes porteurs de sens.
+_STOPWORDS = frozenset({
+    "les", "des", "une", "est", "son", "ses", "aux", "par", "pour", "dans",
+    "sur", "avec", "qui", "que", "quoi", "dont", "mais", "comme", "plus",
+    "pas", "tout", "tous", "toute", "toutes", "ils", "elles", "leur", "leurs",
+    "nous", "vous", "cette", "ces", "cet", "ont", "sont", "fait", "etre",
+    "être", "avoir", "peut", "quel", "quelle", "quels", "quelles", "ainsi",
+    "the", "and", "for", "with", "this", "that", "are", "was", "has", "have",
+    "not", "you", "his", "her", "its", "they", "them", "from", "what", "which",
+})
+
 
 def _path(source_id: str) -> Path:
     safe = _SAFE_ID.sub("_", str(source_id))
@@ -42,6 +69,7 @@ def save(
         items.append(item)
     payload = {"dim": len(vectors[0]) if vectors else 0, "chunks": items}
     _path(source_id).write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+    _CACHE.pop(source_id, None)  # le mtime suffirait, mais soyons explicites
     return len(chunks)
 
 
@@ -50,18 +78,65 @@ def exists(source_id: str) -> bool:
 
 
 def delete(source_id: str) -> None:
+    _CACHE.pop(source_id, None)
     _path(source_id).unlink(missing_ok=True)
+    _summaries_path(source_id).unlink(missing_ok=True)
+
+
+# --- Index de résumés (analyse approfondie) ----------------------------------
+# Cache disque des résumés PAR LOT d'une source : construit paresseusement à la
+# première analyse approfondie, réutilisé ensuite pour ne relire que les lots
+# pertinents. Invalidé avec la source (delete) et si batch_tokens change.
+
+
+def _summaries_path(source_id: str) -> Path:
+    safe = _SAFE_ID.sub("_", str(source_id))
+    return _STORE_DIR / f"{safe}.summaries.json"
+
+
+def save_summaries(source_id: str, batch_tokens: int, entries: list[dict]) -> None:
+    """Persiste les résumés de lots ({"summary": str, "vector": [...]})."""
+    _STORE_DIR.mkdir(parents=True, exist_ok=True)
+    payload = {"batch_tokens": int(batch_tokens), "entries": entries}
+    _summaries_path(source_id).write_text(
+        json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+
+
+def load_summaries(source_id: str, batch_tokens: int) -> list[dict] | None:
+    """Résumés de lots d'une source, ou None si absents / construits avec une
+    autre taille de lot (le découpage ne correspondrait plus)."""
+    p = _summaries_path(source_id)
+    if not p.exists():
+        return None
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(data, dict) or data.get("batch_tokens") != int(batch_tokens):
+        return None
+    entries = data.get("entries")
+    return entries if isinstance(entries, list) else None
 
 
 def _load(source_id: str) -> list[dict]:
     p = _path(source_id)
-    if not p.exists():
+    try:
+        mtime = p.stat().st_mtime_ns
+    except OSError:
+        _CACHE.pop(source_id, None)
         return []
+    cached = _CACHE.get(source_id)
+    if cached is not None and cached[0] == mtime:
+        return cached[1]
     try:
         data = json.loads(p.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         return []
-    return data.get("chunks", []) if isinstance(data, dict) else []
+    chunks = data.get("chunks", []) if isinstance(data, dict) else []
+    if len(_CACHE) >= _CACHE_MAX_SOURCES:
+        _CACHE.pop(next(iter(_CACHE)))  # éviction FIFO simple
+    _CACHE[source_id] = (mtime, chunks)
+    return chunks
 
 
 def all_chunks(source_id: str) -> list[dict]:
@@ -85,20 +160,54 @@ def _cosine(a: list[float], b: list[float]) -> float:
     return dot / (math.sqrt(na) * math.sqrt(nb))
 
 
+def _significant_words(text: str) -> frozenset[str]:
+    """Mots porteurs de sens d'un texte (minuscules, ≥3 lettres, hors mots-outils)."""
+    return frozenset(w for w in _WORD_RE.findall(text.lower()) if w not in _STOPWORDS)
+
+
+def _chunk_words(chunk: dict) -> frozenset[str]:
+    """Mots significatifs d'un extrait, mémoïsés sur le dict caché (calculés à la
+    1ère recherche, réutilisés tant que la source reste en cache)."""
+    words = chunk.get("_words")
+    if words is None:
+        words = _significant_words(chunk.get("text", ""))
+        chunk["_words"] = words
+    return words
+
+
+# Alias public du cosinus (réutilisé par l'index de résumés de l'analyse
+# approfondie — même métrique que la recherche).
+cosine_similarity = _cosine
+
+
 def search(
     source_ids: list[str],
     query_vector: list[float],
     top_k: int = 6,
+    query_text: str = "",
+    min_score: float = 0.0,
 ) -> list[dict]:
     """Renvoie les `top_k` extraits les plus proches, toutes sources confondues.
 
-    Chaque résultat : {"text": str, "score": float, "source_id": str}.
+    Score HYBRIDE : cosinus + `_LEX_WEIGHT` × (part des mots significatifs de
+    `query_text` présents dans l'extrait). Les extraits dont le cosinus est sous
+    `min_score` sont écartés (peut donc renvoyer MOINS de `top_k` résultats —
+    mieux vaut aucun extrait que du bruit injecté dans le prompt).
+
+    Chaque résultat : {"text": str, "score": float, "source_id": str, "page": int|None}.
     """
+    query_words = _significant_words(query_text) if query_text else frozenset()
     scored: list[dict] = []
     for sid in source_ids:
         for chunk in _load(sid):
             vector = chunk.get("vector") or []
-            score = _cosine(query_vector, vector)
+            cos = _cosine(query_vector, vector)
+            if cos < min_score:
+                continue
+            score = cos
+            if query_words:
+                overlap = len(query_words & _chunk_words(chunk)) / len(query_words)
+                score += _LEX_WEIGHT * overlap
             scored.append({
                 "text": chunk.get("text", ""),
                 "score": score,

brain/pytest.ini

@@ -0,0 +1,7 @@
+[pytest]
+# Tests unitaires du brain. asyncio_mode=auto : les coroutines de test sont
+# exécutées sans décorateur @pytest.mark.asyncio explicite.
+asyncio_mode = auto
+# Ajoute la racine du brain au sys.path pour `import app...` sans installation.
+pythonpath = .
+testpaths = tests

brain/requirements-dev.txt

@@ -0,0 +1,11 @@
+# Dépendances de TEST uniquement (non embarquées dans l'image / le bundle desktop).
+# Installer avec : .venv/Scripts/python -m pip install -r requirements-dev.txt
+-r requirements.txt
+
+pytest>=8,<9
+pytest-asyncio>=0.24,<1
+# Mock du transport httpx (intercepte les appels aux API LLM dans les tests).
+respx>=0.21,<1
+# Couverture de tests (équivalent JaCoCo) : `pytest --cov=app --cov-report=html`
+# → rapport HTML dans htmlcov/. La CI ajoute --cov-fail-under pour le plancher.
+pytest-cov>=5,<7

brain/requirements.txt

@@ -1,4 +1,8 @@
-fastapi==0.115.*
+fastapi==0.136.*
+# Pin EXPLICITE : fastapi n'exige que starlette>=0.46.0 — sans ce pin, un
+# environnement existant peut garder une starlette vulnérable.
+# >= 0.49.1 : corrige CVE-2025-54121 et CVE-2025-62727.
+starlette>=0.49.1,<1.0
 uvicorn[standard]==0.32.*
 httpx==0.27.*
 pydantic-settings==2.6.*
@@ -20,4 +24,6 @@ tiktoken==0.8.*
 #     (le binaire tesseract-ocr est installe dans le Dockerfile, langues fra+eng)
 pymupdf==1.24.*
 pytesseract==0.3.*
-Pillow==11.*
+# 12.2+ : corrige 6 CVE de parsing d'images (surface critique : pages de PDF
+# uploadés par l'utilisateur rasterisées puis passées à l'OCR).
+Pillow==12.2.*

brain/run_local.py

@@ -0,0 +1,45 @@
+"""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
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, _HERE)
+
+# OCR : si un Tesseract est bundlé à côté (mode desktop), on y pointe pytesseract
+# AVANT que l'app n'importe le pdf_extractor (qui détecte la version au chargement).
+# tessdata (fra+eng) est embarqué dans tesseract/tessdata. Sans ce bloc, l'OCR
+# reste désactivé en dégradation gracieuse (PDF born-digital OK, scans signalés).
+# Binaire selon l'OS : tesseract.exe (Windows embeddable) ou tesseract (Linux/Mac).
+# Si aucun Tesseract n'est bundlé (cas Linux/AppImage par défaut), le bloc est
+# sauté et pytesseract retombe sur le tesseract SYSTÈME du PATH (ex. apt install
+# tesseract-ocr) — sinon OCR désactivé en dégradation gracieuse.
+_TESS = os.path.join(_HERE, "tesseract", "tesseract.exe" if os.name == "nt" else "tesseract")
+if os.path.exists(_TESS):
+    os.environ.setdefault("TESSDATA_PREFIX", os.path.join(_HERE, "tesseract"))
+    try:
+        import pytesseract
+        pytesseract.pytesseract.tesseract_cmd = _TESS
+    except ImportError:
+        pass
+
+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")

brain/scripts/sanity_rag_check.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""Sanity check temporaire : overlap du chunking + recherche hybride du vector store."""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.application.chunking import chunk_text
+
+# --- 1. Chunking avec overlap ---
+paras = [f"Paragraphe {i} : " + ("lorem ipsum dolor sit amet " * 8) for i in range(12)]
+text = "\n\n".join(paras)
+
+no_overlap = chunk_text(text, target_tokens=200)
+with_overlap = chunk_text(text, target_tokens=200, overlap_tokens=40)
+
+assert len(with_overlap) >= len(no_overlap), "l'overlap ne doit pas réduire le nb de chunks"
+# Chaque chunk (sauf le 1er) doit commencer par la fin du précédent
+overlapped = 0
+for prev, cur in zip(with_overlap, with_overlap[1:]):
+    first_para = cur.split("\n\n")[0]
+    if first_para in prev:
+        overlapped += 1
+assert overlapped >= len(with_overlap) - 2, f"overlap absent: {overlapped}/{len(with_overlap)-1}"
+# Pas de chunk composé uniquement de l'overlap (dernier chunk dupliqué)
+assert with_overlap[-1] != with_overlap[-2], "dernier chunk = pur overlap (dupliqué)"
+# overlap_tokens=0 → comportement identique à l'ancien
+assert no_overlap == chunk_text(text, target_tokens=200, overlap_tokens=0)
+print(f"[OK] chunking : {len(no_overlap)} chunks sans overlap, {len(with_overlap)} avec ({overlapped} recouvrements)")
+
+# --- Paragraphe géant ---
+giant = "mot " * 2000
+sub = chunk_text(giant, target_tokens=300, overlap_tokens=50)
+assert len(sub) > 1
+print(f"[OK] paragraphe géant coupé en {len(sub)} sous-blocs")
+
+# --- 2. Vector store : hybride + seuil + cache ---
+import tempfile, os
+from app.infrastructure import vector_store
+
+with tempfile.TemporaryDirectory() as tmp:
+    vector_store._STORE_DIR = Path(tmp)
+    chunks = [
+        "Strahd von Zarovich règne sur la sombre vallée de Barovia depuis son château.",
+        "Les règles de combat utilisent un d20 plus le modificateur de caractéristique.",
+        "La taverne du village sert un ragoût de navets aux voyageurs fatigués.",
+    ]
+    # Vecteurs factices : chunk 0 et 1 proches de la query, chunk 2 orthogonal
+    vectors = [[1.0, 0.1, 0.0], [0.9, 0.4, 0.1], [0.0, 0.0, 1.0]]
+    vector_store.save("src1", chunks, vectors, pages=[10, 20, 30])
+
+    q = [1.0, 0.2, 0.0]
+    # Sans seuil ni texte : 3 résultats, ordre cosinus
+    r = vector_store.search(["src1"], q, top_k=10)
+    assert len(r) == 3 and r[0]["page"] == 10
+
+    # Avec seuil : le chunk orthogonal (cos~0) est écarté
+    r = vector_store.search(["src1"], q, top_k=10, min_score=0.30)
+    assert len(r) == 2, f"seuil non appliqué: {len(r)}"
+    print(f"[OK] seuil : 2/3 extraits gardés (orthogonal écarté)")
+
+    # Bonus lexical : la query mentionne « Strahd Barovia » → chunk 0 doit dominer
+    r = vector_store.search(["src1"], q, top_k=10, query_text="Parle-moi de Strahd et de Barovia", min_score=0.30)
+    assert r[0]["text"].startswith("Strahd"), r[0]["text"]
+    assert r[0]["score"] > vector_store._cosine(q, vectors[0]), "bonus lexical absent"
+    print(f"[OK] hybride : bonus lexical appliqué (score={r[0]['score']:.3f})")
+
+    # Le set "_words" mémoïsé ne doit PAS fuiter dans les résultats
+    assert all("_words" not in res for res in r)
+
+    # Cache : 2e recherche sert depuis la mémoire (même objet liste)
+    c1 = vector_store._load("src1")
+    c2 = vector_store._load("src1")
+    assert c1 is c2, "cache mtime inopérant"
+    # save() invalide le cache
+    vector_store.save("src1", chunks[:1], vectors[:1], pages=[10])
+    c3 = vector_store._load("src1")
+    assert len(c3) == 1, "cache non invalidé après save"
+    # delete() purge cache + fichier
+    vector_store.delete("src1")
+    assert vector_store._load("src1") == []
+    print("[OK] cache mémoire : hit, invalidation save, purge delete")
+
+print("\nTous les sanity checks passent.")

brain/tests/test_adapt_campaign.py

@@ -0,0 +1,72 @@
+"""Tests du use case de conseils d'adaptation (app.application.adapt_campaign)."""
+from __future__ import annotations
+
+import pytest
+
+from app.application.adapt_campaign import AdaptCampaignUseCase
+from app.domain.models import ChatMessage, ExtractedDocument, ExtractedPage
+from app.domain.ports import PdfExtractionError
+
+
+class FakeExtractor:
+    def __init__(self, doc: ExtractedDocument) -> None:
+        self._doc = doc
+
+    def extract(self, pdf_bytes: bytes) -> ExtractedDocument:
+        return self._doc
+
+
+class FakeChatLLM:
+    def __init__(self, tokens: list[str]) -> None:
+        self._tokens = tokens
+        self.system_prompt: str | None = None
+        self.messages: list[ChatMessage] | None = None
+
+    async def stream_chat(self, messages, *, system_prompt=None, temperature=None):
+        self.messages = messages
+        self.system_prompt = system_prompt
+        for t in self._tokens:
+            yield t
+
+
+def _doc(text: str) -> ExtractedDocument:
+    return ExtractedDocument(pages=[ExtractedPage(index=0, text=text, used_ocr=False)])
+
+
+async def test_stream_yields_tokens_and_builds_context():
+    llm = FakeChatLLM(["con", "seil"])
+    uc = AdaptCampaignUseCase(llm, FakeExtractor(_doc("contenu du pdf")))
+    out = [t async for t in uc.stream(b"x", "mon brief de campagne",
+                                      [ChatMessage(role="user", content="aide")])]
+    assert out == ["con", "seil"]
+    assert "mon brief de campagne" in llm.system_prompt
+    assert "contenu du pdf" in llm.system_prompt
+
+
+async def test_stream_empty_pdf_text_raises():
+    uc = AdaptCampaignUseCase(FakeChatLLM([]), FakeExtractor(_doc("   ")))
+    with pytest.raises(PdfExtractionError):
+        [t async for t in uc.stream(b"x", "brief", [])]
+
+
+async def test_stream_injects_default_request_when_no_messages():
+    llm = FakeChatLLM(["ok"])
+    uc = AdaptCampaignUseCase(llm, FakeExtractor(_doc("texte du pdf")))
+    _ = [t async for t in uc.stream(b"x", "", [])]
+    assert llm.messages[0].role == "user"
+    assert "campagne" in llm.messages[0].content.lower()
+
+
+def test_fit_pdf_short_text_not_truncated():
+    uc = AdaptCampaignUseCase(None, None, max_input_tokens=10000)
+    text, truncated = uc._fit_pdf_to_budget("court texte", "brief")
+    assert truncated is False
+    assert text == "court texte"
+
+
+def test_fit_pdf_long_text_is_truncated():
+    uc = AdaptCampaignUseCase(None, None, max_input_tokens=2100)
+    long_text = "mot " * 5000
+    text, truncated = uc._fit_pdf_to_budget(long_text, "")
+    assert truncated is True
+    assert len(text) < len(long_text)

brain/tests/test_chat.py

@@ -0,0 +1,129 @@
+"""Tests de la construction du system prompt du chat (app.application.chat).
+
+Assertions par INCLUSION (présence des données/sections clés) plutôt que sur le
+texte exact des consignes : robuste aux retouches de formulation, tout en
+vérifiant que chaque contexte est bien injecté.
+"""
+from __future__ import annotations
+
+from app.application.chat import ChatUseCase
+from app.domain.models import (
+    ArcSummary,
+    CampaignStructuralContext,
+    ChapterSummary,
+    CharacterSummary,
+    ChatMessage,
+    GameSystemContext,
+    JournalEntrySummary,
+    LoreStructuralContext,
+    NarrativeEntityContext,
+    NpcSummary,
+    PageContext,
+    PageSummary,
+    SceneSummary,
+    SessionContext,
+)
+
+
+def _build(**kw) -> str:
+    return ChatUseCase(None).build_system_prompt(**kw)
+
+
+def _empty_lore() -> LoreStructuralContext:
+    return LoreStructuralContext(lore_name="L", lore_description=None, folders={}, tags=[])
+
+
+def test_base_prompt_without_context_is_non_empty():
+    assert len(_build()) > 0
+
+
+def test_lore_block_renders_pages_with_values_tags_and_links():
+    lore = LoreStructuralContext(
+        lore_name="Eldoria", lore_description="un monde sombre",
+        folders={"PNJ": [PageSummary(
+            title="Aragorn", template_name="Personnage",
+            values={"apparence": "grand et noble"}, tags=["héros"],
+            related_page_titles=["Gondor"])]},
+        tags=["dark-fantasy"])
+    p = _build(lore_context=lore)
+    assert "Eldoria" in p
+    assert "un monde sombre" in p
+    assert "Aragorn" in p
+    assert "apparence" in p and "grand et noble" in p
+    assert "héros" in p
+    assert "Gondor" in p
+
+
+def test_empty_lore_signals_vide():
+    assert "Lore vide" in _build(lore_context=_empty_lore())
+
+
+def test_page_context_block_lists_fields_and_empty_marker():
+    page = PageContext(title="Aragorn", template_name="Personnage",
+                       template_fields=["apparence", "histoire"],
+                       values={"apparence": "grand"})
+    p = _build(page_context=page)
+    assert "PAGE EN COURS" in p
+    assert "Aragorn" in p
+    assert "apparence" in p
+    assert "(vide)" in p  # 'histoire' sans valeur
+
+
+def test_campaign_block_with_arc_and_empty_pj_npc_and_no_lore_note():
+    camp = CampaignStructuralContext(
+        campaign_name="La Malédiction", campaign_description="horreur gothique",
+        arcs=[ArcSummary(name="Acte I", description="intro",
+                         chapters=[ChapterSummary(name="Ch1", description="",
+                                                  scenes=[SceneSummary(name="Sc1", description="")])])],
+        characters=[], npcs=[])
+    p = _build(campaign_context=camp)
+    assert "CAMPAGNE COURANTE" in p
+    assert "La Malédiction" in p
+    assert "Acte I" in p
+    assert "aucune fiche" in p       # pas de PJ
+    assert "aucun univers" in p      # pas de lore lié
+
+
+def test_campaign_with_characters_npcs_and_lore_present_note():
+    camp = CampaignStructuralContext(
+        campaign_name="C", campaign_description=None, arcs=[],
+        characters=[CharacterSummary(name="Tav", snippet="roublarde")],
+        npcs=[NpcSummary(name="Strahd", snippet="vampire de Barovia")])
+    p = _build(campaign_context=camp, lore_context=_empty_lore())
+    assert "Tav" in p and "roublarde" in p
+    assert "Strahd" in p and "vampire de Barovia" in p
+    assert "liée à l'univers" in p
+
+
+def test_game_system_narrative_and_session_sections_injected():
+    gs = GameSystemContext(system_name="Nimble", system_description=None,
+                           sections={"Combat": "règles de combat"})
+    narr = NarrativeEntityContext(entity_type="scene", title="L'auberge du Portail",
+                                  fields={"ambiance": "tendue"})
+    sess = SessionContext(
+        session_name="Séance 3", active=True, started_at=None,
+        entries=[JournalEntrySummary(type="EVENT", content="Le pont s'effondre", occurred_at=None)],
+        previous_events=[])
+    p = _build(lore_context=_empty_lore(), game_system_context=gs,
+               narrative_entity=narr, session_context=sess)
+    assert "Nimble" in p
+    assert "L'auberge du Portail" in p
+    assert "Séance 3" in p
+    assert "Le pont s'effondre" in p
+
+
+async def test_stream_passes_built_prompt_to_llm():
+    class FakeChatLLM:
+        def __init__(self) -> None:
+            self.system_prompt = None
+
+        async def stream_chat(self, messages, *, system_prompt=None, temperature=None):
+            self.system_prompt = system_prompt
+            yield "tok"
+
+    llm = FakeChatLLM()
+    out = [t async for t in ChatUseCase(llm).stream(
+        [ChatMessage(role="user", content="salut")],
+        lore_context=LoreStructuralContext("Eldoria", None, {}, []))]
+    assert out == ["tok"]
+    assert "Eldoria" in llm.system_prompt

brain/tests/test_chunking.py

@@ -0,0 +1,72 @@
+"""Tests du découpage de texte (app.application.chunking).
+
+Vérifie le découpage par paragraphes vers une cible de tokens, le découpage des
+paragraphes géants, le recouvrement (overlap), et le split_in_half du repli
+anti-troncature. tiktoken (cl100k_base) est déterministe → assertions stables.
+"""
+from __future__ import annotations
+
+from app.application.chunking import chunk_text, split_in_half
+
+
+def test_empty_text_returns_no_chunk():
+    assert chunk_text("") == []
+    assert chunk_text("   \n\n  ") == []
+
+
+def test_short_text_stays_single_chunk():
+    chunks = chunk_text("Paragraphe un.\n\nParagraphe deux.", target_tokens=1000)
+    assert len(chunks) == 1
+    assert "Paragraphe un." in chunks[0]
+    assert "Paragraphe deux." in chunks[0]
+
+
+def test_splits_into_several_chunks_when_exceeding_target():
+    paras = [f"Paragraphe numero {i} avec un peu de contenu." for i in range(20)]
+    full = "\n\n".join(paras)
+    chunks = chunk_text(full, target_tokens=20)
+    assert len(chunks) > 1
+    # Aucun paragraphe perdu : tous présents quelque part.
+    joined = "\n\n".join(chunks)
+    for p in paras:
+        assert p in joined
+
+
+def test_oversized_single_paragraph_is_split():
+    # Un seul paragraphe (aucun "\n\n") plus gros que la cible → plusieurs sous-blocs.
+    huge = "mot " * 500
+    chunks = chunk_text(huge, target_tokens=50)
+    assert len(chunks) > 1
+
+
+def test_overlap_repeats_content_without_losing_paragraphs():
+    paras = [f"Bloc {i} de texte distinct." for i in range(12)]
+    full = "\n\n".join(paras)
+    chunks = chunk_text(full, target_tokens=20, overlap_tokens=10)
+    assert len(chunks) > 1
+    joined = "\n\n".join(chunks)
+    for p in paras:
+        assert p in joined
+
+
+# --- split_in_half -------------------------------------------------------------
+
+def test_split_in_half_too_short_returns_empty():
+    assert split_in_half("court") == ("", "")
+
+
+def test_split_in_half_splits_on_newline_near_middle():
+    text = "A" * 300 + "\n" + "B" * 300
+    left, right = split_in_half(text)
+    assert left and right
+    assert left.startswith("A")
+    assert right.startswith("B")
+
+
+def test_split_in_half_halves_cover_all_content():
+    text = "\n".join(f"ligne {i} " + "x" * 20 for i in range(40))
+    left, right = split_in_half(text)
+    assert left and right
+    # Le découpage ne perd rien : la concaténation contient début et fin.
+    assert "ligne 0" in left
+    assert "ligne 39" in right

brain/tests/test_embedding_adapters.py

@@ -0,0 +1,102 @@
+"""Tests des adapters d'embeddings (Mistral cloud + Ollama local)."""
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+import respx
+
+from app.application.embeddings import EmbeddingError
+from app.core.config import Settings
+from app.infrastructure.mistral_embedding_adapter import MistralEmbeddingProvider
+from app.infrastructure.ollama_embedding_adapter import OllamaEmbeddingProvider
+
+_MISTRAL = "https://api.mistral.ai/v1/embeddings"
+_OLLAMA = "http://ollama:11434/api/embed"
+
+
+def _settings(**kw) -> Settings:
+    base = dict(_env_file=None, llm_timeout_seconds=30, ollama_base_url="http://ollama:11434")
+    base.update(kw)
+    return Settings(**base)
+
+
+# --- Mistral -------------------------------------------------------------------
+
+def test_mistral_missing_key_raises_at_construction():
+    with pytest.raises(EmbeddingError):
+        MistralEmbeddingProvider(_settings(mistral_api_key=""))
+
+
+async def test_mistral_empty_texts_short_circuits():
+    svc = MistralEmbeddingProvider(_settings(mistral_api_key="k"))
+    assert await svc.embed([]) == []
+
+
+@respx.mock
+async def test_mistral_returns_vectors():
+    respx.post(_MISTRAL).mock(return_value=httpx.Response(200, json={
+        "data": [{"embedding": [0.1, 0.2]}, {"embedding": [0.3, 0.4]}]
+    }))
+    svc = MistralEmbeddingProvider(_settings(mistral_api_key="k", mistral_embedding_model="mistral-embed"))
+    vectors = await svc.embed(["texte un", "texte deux"])
+    assert vectors == [[0.1, 0.2], [0.3, 0.4]]
+
+
+@respx.mock
+async def test_mistral_http_error_raises():
+    respx.post(_MISTRAL).mock(return_value=httpx.Response(429, text="rate limit"))
+    svc = MistralEmbeddingProvider(_settings(mistral_api_key="k"))
+    with pytest.raises(EmbeddingError) as exc:
+        await svc.embed(["x"])
+    assert "429" in str(exc.value)
+
+
+@respx.mock
+async def test_mistral_size_mismatch_raises():
+    respx.post(_MISTRAL).mock(return_value=httpx.Response(200, json={"data": [{"embedding": [0.1]}]}))
+    svc = MistralEmbeddingProvider(_settings(mistral_api_key="k"))
+    with pytest.raises(EmbeddingError):
+        await svc.embed(["a", "b"])  # 2 demandés, 1 reçu
+
+
+# --- Ollama --------------------------------------------------------------------
+
+async def test_ollama_empty_texts_short_circuits():
+    svc = OllamaEmbeddingProvider(_settings(ollama_embedding_model="nomic-embed-text"))
+    assert await svc.embed([]) == []
+
+
+@respx.mock
+async def test_ollama_returns_vectors():
+    respx.post(_OLLAMA).mock(return_value=httpx.Response(200, json={"embeddings": [[0.1], [0.2]]}))
+    svc = OllamaEmbeddingProvider(_settings(ollama_embedding_model="mxbai-embed-large"))
+    assert await svc.embed(["a", "b"]) == [[0.1], [0.2]]
+
+
+@respx.mock
+async def test_ollama_applies_nomic_task_prefix():
+    route = respx.post(_OLLAMA).mock(return_value=httpx.Response(200, json={"embeddings": [[0.0]]}))
+    svc = OllamaEmbeddingProvider(_settings(ollama_embedding_model="nomic-embed-text"))
+    await svc.embed(["question ?"], kind="query")
+    sent = json.loads(route.calls.last.request.content)["input"]
+    assert sent == ["search_query: question ?"]
+
+
+@respx.mock
+async def test_ollama_no_prefix_for_non_nomic_model():
+    route = respx.post(_OLLAMA).mock(return_value=httpx.Response(200, json={"embeddings": [[0.0]]}))
+    svc = OllamaEmbeddingProvider(_settings(ollama_embedding_model="mxbai-embed-large"))
+    await svc.embed(["doc"], kind="document")
+    sent = json.loads(route.calls.last.request.content)["input"]
+    assert sent == ["doc"]
+
+
+@respx.mock
+async def test_ollama_http_error_mentions_pull_hint():
+    respx.post(_OLLAMA).mock(return_value=httpx.Response(404, text="model not found"))
+    svc = OllamaEmbeddingProvider(_settings(ollama_embedding_model="nomic-embed-text"))
+    with pytest.raises(EmbeddingError) as exc:
+        await svc.embed(["x"])
+    assert "ollama pull" in str(exc.value)

brain/tests/test_generate_page.py

@@ -0,0 +1,65 @@
+"""Tests du use case de génération de page (app.application.generate_page)."""
+from __future__ import annotations
+
+import pytest
+
+from app.application.generate_page import GeneratePageUseCase
+from app.domain.models import PageGenerationContext
+from app.domain.ports import LLMProviderError
+
+_CTX = PageGenerationContext(
+    lore_name="Eldoria",
+    folder_name="PNJ",
+    template_name="Personnage",
+    template_fields=["apparence", "histoire"],
+    page_title="Aragorn",
+    lore_description="un monde sombre",
+)
+
+
+def test_build_prompt_includes_context_and_fields():
+    p = GeneratePageUseCase._build_prompt(_CTX, "fr")
+    assert "Eldoria" in p
+    assert "Aragorn" in p
+    assert '"apparence"' in p
+    assert "un monde sombre" in p
+
+
+def test_build_prompt_omits_lore_description_when_absent():
+    ctx = PageGenerationContext("L", "F", "T", ["a"], "Titre", None)
+    assert "Description de l'univers" not in GeneratePageUseCase._build_prompt(ctx)
+
+
+def test_parse_values_keeps_only_expected_fields():
+    out = GeneratePageUseCase._parse_values(
+        '{"apparence":"grand","histoire":"longue","extra":"ignoré"}',
+        ["apparence", "histoire"])
+    assert out == {"apparence": "grand", "histoire": "longue"}
+
+
+def test_parse_values_missing_field_becomes_empty_string():
+    out = GeneratePageUseCase._parse_values('{"apparence":"grand"}', ["apparence", "histoire"])
+    assert out == {"apparence": "grand", "histoire": ""}
+
+
+def test_parse_values_casts_to_str_and_strips():
+    out = GeneratePageUseCase._parse_values('{"n": 42, "s": "  x  "}', ["n", "s"])
+    assert out == {"n": "42", "s": "x"}
+
+
+def test_parse_values_bad_json_raises():
+    with pytest.raises(LLMProviderError):
+        GeneratePageUseCase._parse_values("pas du json", ["a"])
+
+
+def test_parse_values_non_object_raises():
+    with pytest.raises(LLMProviderError):
+        GeneratePageUseCase._parse_values("[1, 2]", ["a"])
+
+
+async def test_execute_returns_filtered_result():
+    class FakeLLM:
+        async def generate(self, prompt, *, output_format=None, temperature=None):
+            return '{"apparence":"grand","histoire":"épique","parasite":"x"}'
+    result = await GeneratePageUseCase(FakeLLM()).execute(_CTX)
+    assert result.values == {"apparence": "grand", "histoire": "épique"}

brain/tests/test_import_parsing.py

@@ -0,0 +1,95 @@
+"""Tests des parseurs robustes des use cases d'import (méthodes statiques).
+
+_parse_payload (campagne), _parse_sections / _parse_anchors (règles) : transforment
+la réponse brute du LLM en structure exploitable + un drapeau « tronqué » qui
+déclenche le re-découpage.
+"""
+from __future__ import annotations
+
+from app.application.import_campaign import ImportCampaignUseCase
+from app.application.import_rules import ImportRulesUseCase
+
+_parse_payload = ImportCampaignUseCase._parse_payload
+_parse_sections = ImportRulesUseCase._parse_sections
+_parse_anchors = ImportRulesUseCase._parse_anchors
+
+
+# --- campagne : _parse_payload -------------------------------------------------
+
+def test_parse_payload_valid():
+    payload, truncated = _parse_payload('{"arcs":[{"name":"A"}],"npcs":[{"name":"N"}]}', index=0)
+    assert truncated is False
+    assert payload == {"arcs": [{"name": "A"}], "npcs": [{"name": "N"}]}
+
+
+def test_parse_payload_truncated_flags_recut():
+    payload, truncated = _parse_payload('{"arcs":[{"name":"A"', index=0)
+    assert truncated is True
+    assert payload == {"arcs": [], "npcs": []}
+
+
+def test_parse_payload_prose_is_empty_not_truncated():
+    payload, truncated = _parse_payload('juste de la prose sans json', index=0)
+    assert truncated is False
+    assert payload == {"arcs": [], "npcs": []}
+
+
+def test_parse_payload_recovers_truncated_array():
+    raw = '{"arcs":[{"name":"A"},{"name":"B"},{"name":'
+    payload, truncated = _parse_payload(raw, index=0)
+    assert truncated is True
+    assert payload == {"arcs": [{"name": "A"}, {"name": "B"}], "npcs": []}
+
+
+def test_parse_payload_coerces_non_list_fields():
+    payload, _ = _parse_payload('{"arcs":"oops","npcs":null}', index=0)
+    assert payload == {"arcs": [], "npcs": []}
+
+
+# --- règles : _parse_sections --------------------------------------------------
+
+def test_parse_sections_valid_and_normalized():
+    sections, truncated = _parse_sections('{"sections":{"Combat":"texte"}}', index=0)
+    assert truncated is False
+    assert sections == {"Combat": "texte"}
+
+
+def test_parse_sections_truncated():
+    sections, truncated = _parse_sections('{"Combat":"texte non termin', index=0)
+    assert truncated is True
+    assert sections == {}
+
+
+def test_parse_sections_prose_is_empty():
+    sections, truncated = _parse_sections('pas de json ici', index=0)
+    assert truncated is False
+    assert sections == {}
+
+
+# --- règles (mode segmentation) : _parse_anchors -------------------------------
+
+def test_parse_anchors_locates_and_splits_text():
+    text = "Préambule.\nLE COMBAT commence ici, brutal.\nLA MAGIE ensuite, subtile."
+    raw = ('{"sections":[{"titre":"Combat","debut":"LE COMBAT commence"},'
+           '{"titre":"Magie","debut":"LA MAGIE ensuite"}]}')
+    sections, truncated = _parse_anchors(raw, text, index=0)
+    assert truncated is False
+    assert "Combat" in sections and "Magie" in sections
+    # La 1re section absorbe le préambule (avant la 1re ancre).
+    assert "Préambule." in sections["Combat"]
+    assert "LE COMBAT commence ici, brutal." in sections["Combat"]
+    assert "LA MAGIE ensuite, subtile." in sections["Magie"]
+
+
+def test_parse_anchors_unparseable_returns_empty():
+    sections, truncated = _parse_anchors("pas du json", "texte", index=0)
+    assert sections == {}
+    assert truncated is False
+
+
+def test_parse_anchors_anchor_not_found_is_dropped():
+    text = "Seulement ce paragraphe existe."
+    raw = '{"sections":[{"titre":"Fantôme","debut":"ancre absente du texte"}]}'
+    sections, _ = _parse_anchors(raw, text, index=0)
+    # Aucune ancre localisée → aucune section.
+    assert sections == {}

brain/tests/test_import_status.py

@@ -0,0 +1,30 @@
+"""Tests du canal de statut d'import (app.application.import_status)."""
+from __future__ import annotations
+
+import asyncio
+
+from app.application import import_status
+
+
+def test_notify_is_noop_without_queue():
+    # Hors import (aucune queue installée) : ne lève pas, ne fait rien.
+    import_status.notify_status("personne n'écoute")  # ne doit pas lever
+
+
+def test_notify_publishes_when_queue_installed():
+    queue: asyncio.Queue = asyncio.Queue()
+    token = import_status.set_status_queue(queue)
+    try:
+        import_status.notify_status("morceau re-découpé")
+        assert queue.get_nowait() == "morceau re-découpé"
+    finally:
+        import_status.reset_status_queue(token)
+
+
+def test_reset_restores_noop():
+    queue: asyncio.Queue = asyncio.Queue()
+    token = import_status.set_status_queue(queue)
+    import_status.reset_status_queue(token)
+    # Après reset : plus de queue active → no-op, la queue reste vide.
+    import_status.notify_status("ignoré")
+    assert queue.empty()

brain/tests/test_import_use_cases.py

@@ -0,0 +1,157 @@
+"""Tests des use cases d'import via FAKES (ports LLM + extracteur PDF).
+
+Exerce la chaîne map-reduce complète (extraction → chunking → MAP → REDUCE →
+streaming d'événements) SANS réseau ni vrai PDF. `chunk_text` est monkeypatché
+pour un découpage déterministe (le chunking est testé à part). `asyncio.sleep`
+est neutralisé pour que les backoffs de retry n'imposent aucune attente.
+"""
+from __future__ import annotations
+
+import pytest
+
+from app.application.import_campaign import ImportCampaignUseCase
+from app.application.import_rules import ImportRulesUseCase
+from app.domain.models import ExtractedDocument, ExtractedPage
+from app.domain.ports import LLMProviderError
+
+
+# --- fakes ---------------------------------------------------------------------
+
+class FakeExtractor:
+    def __init__(self, doc: ExtractedDocument) -> None:
+        self._doc = doc
+
+    def extract(self, pdf_bytes: bytes) -> ExtractedDocument:
+        return self._doc
+
+
+class ScriptedLLM:
+    """Rejoue une réponse par appel (la dernière est répétée si on dépasse)."""
+
+    def __init__(self, responses: list) -> None:
+        self._responses = list(responses)
+        self.calls = 0
+
+    async def generate(self, prompt: str, *, output_format=None, temperature=None) -> str:
+        r = self._responses[min(self.calls, len(self._responses) - 1)]
+        self.calls += 1
+        if isinstance(r, Exception):
+            raise r
+        return r
+
+
+class ContentLLM:
+    """Répond selon le CONTENU du prompt (chunk) : (sous-chaîne → réponse/exception)."""
+
+    def __init__(self, rules: list) -> None:
+        self._rules = rules
+
+    async def generate(self, prompt: str, *, output_format=None, temperature=None) -> str:
+        for sub, r in self._rules:
+            if sub in prompt:
+                if isinstance(r, Exception):
+                    raise r
+                return r
+        raise AssertionError(f"aucune règle ContentLLM ne matche : {prompt[:60]!r}")
+
+
+def _doc(text: str = "Texte du PDF.", *, ocr: bool = False) -> ExtractedDocument:
+    return ExtractedDocument(pages=[ExtractedPage(index=0, text=text, used_ocr=ocr)])
+
+
+@pytest.fixture
+def no_sleep(monkeypatch):
+    async def _noop(_d):
+        return None
+    monkeypatch.setattr("asyncio.sleep", _noop)
+
+
+@pytest.fixture
+def one_chunk(monkeypatch):
+    monkeypatch.setattr("app.application.import_rules.chunk_text", lambda *a, **k: ["chunk"])
+    monkeypatch.setattr("app.application.import_campaign.chunk_text", lambda *a, **k: ["chunk"])
+
+
+# --- import de règles ----------------------------------------------------------
+
+async def test_rules_execute_returns_merged_sections(one_chunk):
+    llm = ScriptedLLM(['{"Combat":"## Combat\\nrègles de combat"}'])
+    uc = ImportRulesUseCase(llm, FakeExtractor(_doc(ocr=True)))
+    result = await uc.execute(b"pdf")
+    assert result.sections == {"Combat": "## Combat\nrègles de combat"}
+    assert result.page_count == 1
+    assert result.ocr_page_count == 1
+
+
+async def test_rules_stream_emits_extracting_start_progress_done(one_chunk):
+    llm = ScriptedLLM(['{"Magie":"sorts"}'])
+    uc = ImportRulesUseCase(llm, FakeExtractor(_doc()))
+    events = [e async for e in uc.stream(b"pdf")]
+    types = [e["type"] for e in events]
+    assert types[0] == "extracting"
+    assert types[1] == "start"
+    assert "progress" in types
+    done = events[-1]
+    assert done["type"] == "done"
+    assert done["sections"] == {"Magie": "sorts"}
+
+
+async def test_rules_stream_skips_failed_chunk_but_continues(monkeypatch, no_sleep):
+    monkeypatch.setattr("app.application.import_rules.chunk_text",
+                        lambda *a, **k: ["AAA premier", "BBB second"])
+    llm = ContentLLM([
+        ("AAA premier", LLMProviderError("HTTP 503 saturé")),
+        ("BBB second", '{"Magie":"sorts"}'),
+    ])
+    uc = ImportRulesUseCase(llm, FakeExtractor(_doc()))
+    events = [e async for e in uc.stream(b"pdf")]
+    types = [e["type"] for e in events]
+    assert "chunk_failed" in types
+    done = events[-1]
+    assert done["type"] == "done"
+    assert done["sections"] == {"Magie": "sorts"}
+    assert done["skipped"] == 1
+
+
+async def test_rules_stream_all_chunks_fail_emits_error(one_chunk, no_sleep):
+    llm = ScriptedLLM([LLMProviderError("HTTP 500 panne")])
+    uc = ImportRulesUseCase(llm, FakeExtractor(_doc()))
+    events = [e async for e in uc.stream(b"pdf")]
+    assert events[-1]["type"] == "error"
+    assert "échoué" in events[-1]["message"]
+
+
+# --- import de campagne --------------------------------------------------------
+
+_TREE = ('{"arcs":[{"name":"Acte I","description":"intro",'
+         '"chapters":[{"name":"Ch1","scenes":[{"name":"Sc1"}]}]}],'
+         '"npcs":[{"name":"Gandalf","description":"magicien"}]}')
+
+
+async def test_campaign_execute_builds_tree_and_npcs(one_chunk):
+    uc = ImportCampaignUseCase(ScriptedLLM([_TREE]), FakeExtractor(_doc()))
+    result = await uc.execute(b"pdf")
+    assert result.counts() == (1, 1, 1)
+    assert result.arcs[0].name == "Acte I"
+    assert result.arcs[0].chapters[0].scenes[0].name == "Sc1"
+    assert [n.name for n in result.npcs] == ["Gandalf"]
+
+
+async def test_campaign_stream_emits_done_with_serialized_tree(one_chunk):
+    uc = ImportCampaignUseCase(ScriptedLLM([_TREE]), FakeExtractor(_doc()))
+    events = [e async for e in uc.stream(b"pdf")]
+    types = [e["type"] for e in events]
+    assert types[0] == "extracting"
+    assert types[1] == "start"
+    assert "progress" in types
+    done = events[-1]
+    assert done["type"] == "done"
+    assert done["arcs"][0]["name"] == "Acte I"
+    assert done["arcs"][0]["chapters"][0]["scenes"][0]["name"] == "Sc1"
+    assert done["npcs"] == [{"name": "Gandalf", "description": "magicien"}]
+
+
+async def test_campaign_stream_all_fail_emits_error(one_chunk, no_sleep):
+    uc = ImportCampaignUseCase(ScriptedLLM([LLMProviderError("502")]), FakeExtractor(_doc()))
+    events = [e async for e in uc.stream(b"pdf")]
+    assert events[-1]["type"] == "error"

brain/tests/test_language.py

@@ -0,0 +1,39 @@
+"""Tests de la normalisation de langue (app.core.language)."""
+from __future__ import annotations
+
+import pytest
+
+from app.core import language
+
+
+@pytest.mark.parametrize("raw, expected", [
+    ("fr", "fr"),
+    ("en", "en"),
+    ("EN", "en"),
+    ("en-US", "en"),
+    ("fr-FR,fr;q=0.9,en;q=0.8", "fr"),
+    ("en-GB,en;q=0.9", "en"),
+    ("de", "fr"),          # non supporté → défaut
+    ("", "fr"),
+    (None, "fr"),
+    ("  EN-gb ", "en"),    # casse + espaces tolérés
+])
+def test_normalize(raw, expected):
+    assert language.normalize(raw) == expected
+
+
+def test_language_name_known_and_fallback():
+    assert language.language_name("fr") == "français"
+    assert language.language_name("en") == "anglais"
+    # Code inconnu → nom de la langue par défaut.
+    assert language.language_name("xx") == "français"
+
+
+def test_instruction_mentions_target_language():
+    assert "anglais" in language.instruction("en")
+    assert "français" in language.instruction("fr")
+
+
+def test_get_user_language_uses_normalize():
+    assert language.get_user_language("en-US") == "en"
+    assert language.get_user_language(None) == "fr"

brain/tests/test_llm_json.py

@@ -0,0 +1,130 @@
+"""Tests de la lecture robuste de JSON depuis une réponse LLM (app.application.llm_json).
+
+Couvre l'extraction du premier objet équilibré (en ignorant les accolades dans
+les chaînes), la réparation d'un JSON tronqué, la détection « ça ressemble à du
+JSON coupé », et le strip des blocs de raisonnement <think>…</think>.
+"""
+from __future__ import annotations
+
+from app.application.llm_json import (
+    extract_json_object,
+    load_json_object,
+    looks_like_truncated_json,
+    repair_truncated_json,
+)
+
+
+# --- extract_json_object -------------------------------------------------------
+
+def test_extract_simple_object():
+    assert extract_json_object('{"a": 1}') == '{"a": 1}'
+
+
+def test_extract_ignores_surrounding_prose_and_fences():
+    raw = 'Voici le JSON :\n```json\n{"a": 1}\n```\nMerci.'
+    assert extract_json_object(raw) == '{"a": 1}'
+
+
+def test_extract_stops_at_first_balanced_object():
+    assert extract_json_object('{"a": 1} et puis {"b": 2}') == '{"a": 1}'
+
+
+def test_extract_keeps_nested_object_whole():
+    assert extract_json_object('{"a": {"b": 1}}') == '{"a": {"b": 1}}'
+
+
+def test_extract_ignores_braces_inside_strings():
+    raw = '{"a": "}{ pas du json "}'
+    assert extract_json_object(raw) == raw
+
+
+def test_extract_handles_escaped_quote_in_string():
+    raw = '{"a": "x\\"y"}'
+    assert extract_json_object(raw) == raw
+
+
+def test_extract_returns_none_when_unclosed():
+    assert extract_json_object('{"a": 1') is None
+
+
+def test_extract_returns_none_without_brace():
+    assert extract_json_object('aucune accolade ici') is None
+
+
+def test_extract_returns_none_on_empty():
+    assert extract_json_object('') is None
+
+
+# --- load_json_object ----------------------------------------------------------
+
+def test_load_valid_object_not_recovered():
+    obj, recovered = load_json_object('{"x": 42}')
+    assert obj == {"x": 42}
+    assert recovered is False
+
+
+def test_load_tolerates_raw_control_chars_in_strings():
+    # Retour à la ligne BRUT dans une chaîne : invalide en strict, accepté ici.
+    obj, recovered = load_json_object('{"a": "ligne1\nligne2"}')
+    assert obj == {"a": "ligne1\nligne2"}
+    assert recovered is False
+
+
+def test_load_strips_reasoning_block_before_parsing():
+    raw = '<think>je réfléchis { ] [ }</think>{"ok": true}'
+    obj, recovered = load_json_object(raw)
+    assert obj == {"ok": True}
+    assert recovered is False
+
+
+def test_load_repairs_truncated_array_and_flags_recovered():
+    raw = '{"items": [{"a": 1}, {"b": 2}, {"c":'
+    obj, recovered = load_json_object(raw)
+    assert obj == {"items": [{"a": 1}, {"b": 2}]}
+    assert recovered is True
+
+
+def test_load_returns_none_on_garbage():
+    obj, recovered = load_json_object('juste de la prose sans json')
+    assert obj is None
+    assert recovered is False
+
+
+# --- looks_like_truncated_json -------------------------------------------------
+
+def test_truncated_detection_no_brace_is_false():
+    assert looks_like_truncated_json('rien') is False
+
+
+def test_truncated_detection_short_object_start_unbalanced_is_true():
+    # Démarre par '{' et déséquilibré → coupé net, même très court.
+    assert looks_like_truncated_json('{"') is True
+
+
+def test_truncated_detection_balanced_object_is_false():
+    assert looks_like_truncated_json('{"a": 1}') is False
+
+
+def test_truncated_detection_short_prose_with_braces_is_false():
+    assert looks_like_truncated_json('texte { incomplet') is False
+
+
+def test_truncated_detection_long_prose_unbalanced_is_true():
+    raw = 'prose ' * 30 + '{ structure ouverte mais jamais refermée'
+    assert len(raw) >= 100
+    assert looks_like_truncated_json(raw) is True
+
+
+# --- repair_truncated_json -----------------------------------------------------
+
+def test_repair_closes_open_containers_after_last_complete_element():
+    repaired = repair_truncated_json('{"items": [{"a": 1}, {"b": 2}, {"c":')
+    assert repaired == '{"items": [{"a": 1}, {"b": 2}]}'
+
+
+def test_repair_returns_none_when_nothing_complete():
+    assert repair_truncated_json('{"a": "jamais fermé') is None
+
+
+def test_repair_returns_none_without_brace():
+    assert repair_truncated_json('pas de json') is None

brain/tests/test_llm_retry.py

@@ -0,0 +1,112 @@
+"""Tests du retry des appels LLM one-shot (app.application.llm_retry).
+
+`asyncio.sleep` est neutralisé (et enregistré) pour que les backoffs n'imposent
+aucune attente réelle tout en vérifiant les durées choisies.
+"""
+from __future__ import annotations
+
+import pytest
+
+from app.application import llm_retry
+from app.application.llm_retry import (
+    _is_daily_quota,
+    _is_rate_limit,
+    _suggested_retry_after,
+    generate_with_retry,
+)
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
+
+
+class FakeLLM:
+    """LLM factice : rejoue une liste de comportements (exception ou texte)."""
+
+    def __init__(self, behaviors: list) -> None:
+        self._behaviors = list(behaviors)
+        self.calls = 0
+
+    async def generate(self, prompt: str, *, output_format=None, temperature=None) -> str:
+        b = self._behaviors[self.calls]
+        self.calls += 1
+        if isinstance(b, Exception):
+            raise b
+        return b
+
+
+@pytest.fixture
+def slept(monkeypatch):
+    """Neutralise asyncio.sleep et enregistre les durées demandées."""
+    recorded: list[float] = []
+
+    async def fake_sleep(d):
+        recorded.append(d)
+
+    monkeypatch.setattr("asyncio.sleep", fake_sleep)
+    return recorded
+
+
+# --- helpers de classification -------------------------------------------------
+
+def test_is_rate_limit():
+    assert _is_rate_limit(LLMProviderError("HTTP 429 Too Many Requests"))
+    assert _is_rate_limit(LLMProviderError("rate limit reached"))
+    assert not _is_rate_limit(LLMProviderError("HTTP 500"))
+
+
+def test_is_daily_quota():
+    assert _is_daily_quota(LLMProviderError("free-models-per-day limit"))
+    assert _is_daily_quota(LLMProviderError("quota per day exceeded"))
+    assert not _is_daily_quota(LLMProviderError("429 per-minute"))
+
+
+def test_suggested_retry_after():
+    assert _suggested_retry_after(LLMProviderError('{"retry_after_seconds": 8}')) == 8.0
+    assert _suggested_retry_after(LLMProviderError('Retry-After: 12')) == 12.0
+    assert _suggested_retry_after(LLMProviderError("pas de hint")) is None
+
+
+# --- generate_with_retry -------------------------------------------------------
+
+async def test_returns_on_first_success(slept):
+    llm = FakeLLM(["réponse"])
+    assert await generate_with_retry(llm, "p") == "réponse"
+    assert llm.calls == 1
+    assert slept == []
+
+
+async def test_retries_transient_error_then_succeeds(slept):
+    llm = FakeLLM([LLMProviderError("HTTP 503"), "ok"])
+    assert await generate_with_retry(llm, "p") == "ok"
+    assert llm.calls == 2
+    assert slept == [3.0]  # _BASE_DELAY_SECONDS
+
+
+async def test_timeout_raises_immediately_without_retry(slept):
+    llm = FakeLLM([LLMGenerationTimeout("trop lent")])
+    with pytest.raises(LLMGenerationTimeout):
+        await generate_with_retry(llm, "p")
+    assert llm.calls == 1
+    assert slept == []
+
+
+async def test_daily_quota_aborts_immediately(slept):
+    llm = FakeLLM([LLMProviderError("free-models-per-day exceeded")])
+    with pytest.raises(LLMProviderError):
+        await generate_with_retry(llm, "p")
+    assert llm.calls == 1
+    assert slept == []
+
+
+async def test_exhausts_attempts_then_raises_last(slept):
+    llm = FakeLLM([LLMProviderError("503 a"), LLMProviderError("503 b"), LLMProviderError("503 c")])
+    with pytest.raises(LLMProviderError, match="503 c"):
+        await generate_with_retry(llm, "p")
+    assert llm.calls == 3
+    # 2 attentes entre 3 tentatives (backoff exponentiel 3s puis 6s).
+    assert slept == [3.0, 6.0]
+
+
+async def test_rate_limit_respects_suggested_retry_after(slept):
+    llm = FakeLLM([LLMProviderError('429 {"retry_after_seconds": 8}'), "ok"])
+    assert await generate_with_retry(llm, "p") == "ok"
+    # min(8 + 2, 60) = 10
+    assert slept == [10.0]

brain/tests/test_models.py

@@ -0,0 +1,52 @@
+"""Tests de la logique portée par les modèles de domaine (app.domain.models)."""
+from __future__ import annotations
+
+from app.domain.models import (
+    ArcProposal,
+    CampaignImportResult,
+    ChapterProposal,
+    ExtractedDocument,
+    ExtractedPage,
+    RulesImportResult,
+    SceneProposal,
+)
+
+
+def test_extracted_document_properties():
+    doc = ExtractedDocument(pages=[
+        ExtractedPage(index=0, text="page un", used_ocr=False),
+        ExtractedPage(index=1, text="page deux", used_ocr=True),
+        ExtractedPage(index=2, text="   ", used_ocr=False),  # vide → exclue de full_text
+    ])
+    assert doc.page_count == 3
+    assert doc.ocr_page_count == 1
+    assert doc.full_text == "page un\n\npage deux"
+
+
+def test_rules_import_result_to_markdown():
+    result = RulesImportResult(
+        sections={"Combat": "règles de combat", "Magie": "règles de magie"},
+        page_count=10, ocr_page_count=0,
+    )
+    md = result.to_markdown()
+    assert "## Combat\n\nrègles de combat" in md
+    assert "## Magie\n\nrègles de magie" in md
+    assert md.endswith("\n")
+
+
+def test_campaign_import_result_counts():
+    arcs = [
+        ArcProposal("A1", "", chapters=[
+            ChapterProposal("C1", "", scenes=[SceneProposal("S1", ""), SceneProposal("S2", "")]),
+            ChapterProposal("C2", "", scenes=[SceneProposal("S3", "")]),
+        ]),
+        ArcProposal("A2", "", chapters=[]),
+    ]
+    result = CampaignImportResult(arcs=arcs, page_count=1, ocr_page_count=0)
+    assert result.counts() == (2, 2, 3)
+
+
+def test_arc_proposal_defaults():
+    arc = ArcProposal("Acte", "synopsis")
+    assert arc.arc_type == "LINEAR"
+    assert arc.chapters == []

brain/tests/test_ollama_adapter.py

@@ -0,0 +1,95 @@
+"""Tests de caractérisation de l'adapter Ollama (protocole propre : /api/generate
+one-shot + /api/chat NDJSON streamé)."""
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+import respx
+
+from app.core.config import Settings
+from app.domain.models import ChatMessage
+from app.domain.ports import LLMGenerationTimeout, LLMProviderError
+from app.infrastructure.ollama_adapter import OllamaLLMProvider
+
+_GEN = "http://ollama:11434/api/generate"
+_CHAT = "http://ollama:11434/api/chat"
+
+
+def _svc() -> OllamaLLMProvider:
+    s = Settings(_env_file=None, ollama_base_url="http://ollama:11434",
+                 llm_model="gemma", llm_timeout_seconds=30, llm_num_ctx=8192)
+    return OllamaLLMProvider(s)
+
+
+@respx.mock
+async def test_generate_returns_response_field():
+    respx.post(_GEN).mock(return_value=httpx.Response(200, json={"response": "texte", "done_reason": "stop"}))
+    assert await _svc().generate("prompt") == "texte"
+
+
+@respx.mock
+async def test_generate_payload_always_sends_num_ctx_and_omits_temperature():
+    route = respx.post(_GEN).mock(return_value=httpx.Response(200, json={"response": "x"}))
+    await _svc().generate("p")
+    body = json.loads(route.calls.last.request.content)
+    assert body["model"] == "gemma"
+    assert body["stream"] is False
+    assert body["options"] == {"num_ctx": 8192}
+    assert "format" not in body
+
+
+@respx.mock
+async def test_generate_payload_includes_temperature_and_format_when_given():
+    route = respx.post(_GEN).mock(return_value=httpx.Response(200, json={"response": "x"}))
+    await _svc().generate("p", output_format="json", temperature=0.1)
+    body = json.loads(route.calls.last.request.content)
+    assert body["options"]["temperature"] == 0.1
+    assert body["format"] == "json"
+
+
+@respx.mock
+async def test_generate_http_error_surfaces_ollama_message():
+    respx.post(_GEN).mock(return_value=httpx.Response(404, json={"error": "model 'x' not found"}))
+    with pytest.raises(LLMProviderError) as exc:
+        await _svc().generate("p")
+    assert "not found" in str(exc.value)
+    assert "404" in str(exc.value)
+
+
+@respx.mock
+async def test_generate_read_timeout_is_generation_timeout():
+    respx.post(_GEN).mock(side_effect=httpx.ReadTimeout("trop lent"))
+    with pytest.raises(LLMGenerationTimeout):
+        await _svc().generate("p")
+
+
+@respx.mock
+async def test_generate_connect_timeout_is_provider_error():
+    respx.post(_GEN).mock(side_effect=httpx.ConnectTimeout("injoignable"))
+    with pytest.raises(LLMProviderError) as exc:
+        await _svc().generate("p")
+    assert not isinstance(exc.value, LLMGenerationTimeout)
+
+
+@respx.mock
+async def test_stream_chat_yields_tokens_until_done():
+    body = (
+        '{"message":{"content":"Bon"},"done":false}\n'
+        '{"message":{"content":"jour"},"done":false}\n'
+        '{"done":true}\n'
+    )
+    respx.post(_CHAT).mock(return_value=httpx.Response(200, text=body))
+    tokens = [t async for t in _svc().stream_chat([ChatMessage(role="user", content="hi")])]
+    assert tokens == ["Bon", "jour"]
+
+
+@respx.mock
+async def test_stream_chat_prepends_system_prompt():
+    route = respx.post(_CHAT).mock(return_value=httpx.Response(200, text='{"done":true}\n'))
+    _ = [t async for t in _svc().stream_chat(
+        [ChatMessage(role="user", content="Q")], system_prompt="SYS")]
+    body = json.loads(route.calls.last.request.content)
+    assert body["messages"][0] == {"role": "system", "content": "SYS"}
+    assert body["messages"][-1] == {"role": "user", "content": "Q"}

brain/tests/test_onemin_adapter.py

@@ -0,0 +1,110 @@
+"""Tests de l'adapter 1min.ai (API propriétaire : prompt unique aplati, SSE
+`event: content`/`data:{content}`)."""
+from __future__ import annotations
+
+import httpx
+import pytest
+import respx
+
+from app.core.config import Settings
+from app.domain.models import ChatMessage
+from app.domain.ports import LLMProviderError
+from app.infrastructure.onemin_adapter import OneMinAiLLMProvider
+
+_URL = "https://api.1min.ai/api/chat-with-ai?isStreaming=true"
+
+
+def _svc() -> OneMinAiLLMProvider:
+    s = Settings(_env_file=None, onemin_api_key="k", onemin_model="gpt-4o-mini",
+                 llm_timeout_seconds=30)
+    return OneMinAiLLMProvider(s)
+
+
+def _sse(*blocks: str) -> str:
+    return "".join(blocks)
+
+
+# --- streaming -----------------------------------------------------------------
+
+@respx.mock
+async def test_generate_collects_content_chunks():
+    body = _sse(
+        "event: content\ndata: {\"content\": \"Bon\"}\n\n",
+        "event: content\ndata: {\"content\": \"jour\"}\n\n",
+        "event: done\ndata: {}\n\n",
+    )
+    respx.post(_URL).mock(return_value=httpx.Response(200, text=body))
+    assert await _svc().generate("salut") == "Bonjour"
+
+
+@respx.mock
+async def test_generate_sends_api_key_header_and_prompt_payload():
+    route = respx.post(_URL).mock(return_value=httpx.Response(
+        200, text="event: done\ndata: {}\n\n"))
+    await _svc().generate("ma question")
+    req = route.calls.last.request
+    assert req.headers["API-KEY"] == "k"
+    import json
+    body = json.loads(req.content)
+    assert body["model"] == "gpt-4o-mini"
+    assert body["promptObject"]["prompt"] == "ma question"
+
+
+@respx.mock
+async def test_error_event_raises_provider_error():
+    body = "event: error\ndata: {\"message\": \"quota dépassé\"}\n\n"
+    respx.post(_URL).mock(return_value=httpx.Response(200, text=body))
+    with pytest.raises(LLMProviderError) as exc:
+        await _svc().generate("p")
+    assert "quota dépassé" in str(exc.value)
+
+
+@respx.mock
+async def test_http_error_is_translated():
+    respx.post(_URL).mock(return_value=httpx.Response(502, text="bad gateway"))
+    with pytest.raises(LLMProviderError) as exc:
+        await _svc().generate("p")
+    assert "1min.ai" in str(exc.value)
+
+
+@respx.mock
+async def test_stream_chat_flattens_and_streams():
+    route = respx.post(_URL).mock(return_value=httpx.Response(
+        200, text="event: content\ndata: {\"content\": \"R\"}\n\nevent: done\ndata: {}\n\n"))
+    tokens = [t async for t in _svc().stream_chat(
+        [ChatMessage(role="user", content="Q")], system_prompt="SYS")]
+    assert tokens == ["R"]
+    import json
+    prompt = json.loads(route.calls.last.request.content)["promptObject"]["prompt"]
+    assert "[SYSTEM]" in prompt and "SYS" in prompt
+    assert "[USER]" in prompt and "Q" in prompt
+
+
+# --- helpers purs --------------------------------------------------------------
+
+def test_flatten_messages_structure():
+    out = OneMinAiLLMProvider._flatten_messages(
+        [ChatMessage(role="user", content="Q1"), ChatMessage(role="assistant", content="R1")],
+        "instructions système",
+    )
+    assert "[SYSTEM]\ninstructions système" in out
+    assert "[USER]\nQ1" in out
+    assert "[ASSISTANT]\nR1" in out
+    assert out.rstrip().endswith("[ASSISTANT]")
+
+
+def test_extract_content_chunk_json_and_fallback():
+    assert OneMinAiLLMProvider._extract_content_chunk('{"content": "x"}') == "x"
+    assert OneMinAiLLMProvider._extract_content_chunk('{"token": "y"}') == "y"
+    # Non-JSON : filet de sécurité, on renvoie le brut.
+    assert OneMinAiLLMProvider._extract_content_chunk("texte brut") == "texte brut"
+
+
+def test_extract_result_reads_nested_result_object():
+    payload = {"aiRecord": {"aiRecordDetail": {"resultObject": ["partie 1", "partie 2"]}}}
+    assert OneMinAiLLMProvider._extract_result(payload) == "partie 1partie 2"
+
+
+def test_extract_result_raises_on_unexpected_schema():
+    with pytest.raises(LLMProviderError):
+        OneMinAiLLMProvider._extract_result({"unexpected": True})

brain/tests/test_openai_compatible_adapters.py

@@ -0,0 +1,204 @@
+"""Tests de caractérisation des adapters LLM « OpenAI-compatible »
+(OpenRouter, Gemini, Mistral).
+
+But : VERROUILLER le comportement observable AVANT d'extraire une classe de base
+commune (les trois adapters partageaient ~80 % de code). On couvre via respx
+(mock du transport httpx) : collecte du stream, payload envoyé, en-têtes, parsing
+SSE, et traduction des erreurs HTTP — sans aucun appel réseau réel.
+
+Ces tests doivent rester verts à l'identique après le refactor.
+"""
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+import respx
+
+from app.core.config import Settings
+from app.domain.models import ChatMessage
+from app.domain.ports import LLMProviderError
+from app.infrastructure.gemini_adapter import GeminiLLMProvider
+from app.infrastructure.mistral_adapter import MistralLLMProvider
+from app.infrastructure.openrouter_adapter import OpenRouterLLMProvider
+
+
+def _settings(**kw) -> Settings:
+    return Settings(_env_file=None, llm_timeout_seconds=30, **kw)
+
+
+def _sse(*contents: str) -> str:
+    """Construit un corps SSE OpenAI : une trame `data: {choices:[{delta:{content}}]}`
+    par fragment, terminé par `data: [DONE]`."""
+    lines: list[str] = []
+    for c in contents:
+        lines.append("data: " + json.dumps({"choices": [{"delta": {"content": c}}]}))
+        lines.append("")
+    lines += ["data: [DONE]", ""]
+    return "\n".join(lines)
+
+
+# (id, classe, url, kwargs settings (clé+modèle), supporte response_format=json_object)
+CASES = [
+    pytest.param(
+        OpenRouterLLMProvider,
+        "https://openrouter.ai/api/v1/chat/completions",
+        dict(openrouter_api_key="k", openrouter_model="m"),
+        False,
+        "OpenRouter",
+        id="openrouter",
+    ),
+    pytest.param(
+        GeminiLLMProvider,
+        "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+        dict(gemini_api_key="k", gemini_model="m"),
+        True,
+        "Gemini",
+        id="gemini",
+    ),
+    pytest.param(
+        MistralLLMProvider,
+        "https://api.mistral.ai/v1/chat/completions",
+        dict(mistral_api_key="k", mistral_model="m"),
+        True,
+        "Mistral",
+        id="mistral",
+    ),
+]
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_generate_collects_full_stream(cls, url, skw, supports_json, label):
+    respx.post(url).mock(return_value=httpx.Response(200, text=_sse("Bonjour", " le", " monde")))
+    svc = cls(_settings(**skw))
+    assert await svc.generate("salut") == "Bonjour le monde"
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_stream_chat_yields_tokens(cls, url, skw, supports_json, label):
+    respx.post(url).mock(return_value=httpx.Response(200, text=_sse("A", "B", "C")))
+    svc = cls(_settings(**skw))
+    tokens = [t async for t in svc.stream_chat([ChatMessage(role="user", content="hi")])]
+    assert tokens == ["A", "B", "C"]
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_payload_system_prompt_and_temperature(cls, url, skw, supports_json, label):
+    route = respx.post(url).mock(return_value=httpx.Response(200, text=_sse("x")))
+    svc = cls(_settings(**skw))
+    _ = [t async for t in svc.stream_chat(
+        [ChatMessage(role="user", content="Q")],
+        system_prompt="SYS",
+        temperature=0.5,
+    )]
+    body = json.loads(route.calls.last.request.content)
+    assert body["model"] == "m"
+    assert body["stream"] is True
+    assert body["messages"][0] == {"role": "system", "content": "SYS"}
+    assert body["messages"][-1] == {"role": "user", "content": "Q"}
+    assert body["temperature"] == 0.5
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_payload_omits_temperature_when_none(cls, url, skw, supports_json, label):
+    route = respx.post(url).mock(return_value=httpx.Response(200, text=_sse("x")))
+    svc = cls(_settings(**skw))
+    await svc.generate("p")
+    body = json.loads(route.calls.last.request.content)
+    assert "temperature" not in body
+    # Sans system_prompt, generate envoie un unique message user.
+    assert body["messages"] == [{"role": "user", "content": "p"}]
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_response_format_json_only_when_supported(cls, url, skw, supports_json, label):
+    route = respx.post(url).mock(return_value=httpx.Response(200, text=_sse("{}")))
+    svc = cls(_settings(**skw))
+    await svc.generate("p", output_format="json")
+    body = json.loads(route.calls.last.request.content)
+    if supports_json:
+        assert body["response_format"] == {"type": "json_object"}
+    else:
+        assert "response_format" not in body
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_authorization_header_bearer(cls, url, skw, supports_json, label):
+    route = respx.post(url).mock(return_value=httpx.Response(200, text=_sse("x")))
+    svc = cls(_settings(**skw))
+    await svc.generate("p")
+    assert route.calls.last.request.headers["Authorization"] == "Bearer k"
+
+
+@respx.mock
+async def test_openrouter_attribution_headers():
+    route = respx.post("https://openrouter.ai/api/v1/chat/completions").mock(
+        return_value=httpx.Response(200, text=_sse("x")))
+    svc = OpenRouterLLMProvider(_settings(openrouter_api_key="k", openrouter_model="m"))
+    await svc.generate("p")
+    headers = route.calls.last.request.headers
+    assert headers["HTTP-Referer"] == "https://loremind.app"
+    assert headers["X-Title"] == "LoreMind"
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_http_error_translated_to_provider_error(cls, url, skw, supports_json, label):
+    respx.post(url).mock(return_value=httpx.Response(429, text="quota exceeded"))
+    svc = cls(_settings(**skw))
+    with pytest.raises(LLMProviderError) as exc:
+        await svc.generate("p")
+    msg = str(exc.value)
+    assert label in msg
+    assert "429" in msg
+    assert "quota exceeded" in msg
+
+
+@respx.mock
+async def test_gemini_rejected_key_gives_actionable_message():
+    respx.post(
+        "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
+    ).mock(return_value=httpx.Response(403, text="API key not valid"))
+    svc = GeminiLLMProvider(_settings(gemini_api_key="k", gemini_model="m"))
+    with pytest.raises(LLMProviderError) as exc:
+        await svc.generate("p")
+    assert "refusée par Google" in str(exc.value)
+
+
+@pytest.mark.parametrize("cls, url, skw, supports_json, label", CASES)
+@respx.mock
+async def test_sse_skips_keepalive_and_malformed_lines(cls, url, skw, supports_json, label):
+    body = "\n".join([
+        ": OPENROUTER PROCESSING",  # commentaire keep-alive
+        "",
+        "data: not-json",            # JSON invalide -> ignoré
+        "",
+        "data: " + json.dumps({"choices": []}),  # pas de choix -> ignoré
+        "",
+        "data: " + json.dumps({"choices": [{"delta": {}}]}),  # delta sans content -> ignoré
+        "",
+        "data: " + json.dumps({"choices": [{"delta": {"content": "OK"}}]}),
+        "",
+        "data: [DONE]",
+        "",
+    ])
+    respx.post(url).mock(return_value=httpx.Response(200, text=body))
+    svc = cls(_settings(**skw))
+    assert await svc.generate("p") == "OK"
+
+
+@pytest.mark.parametrize("cls, skw", [
+    pytest.param(OpenRouterLLMProvider, dict(openrouter_api_key=""), id="openrouter"),
+    pytest.param(GeminiLLMProvider, dict(gemini_api_key=""), id="gemini"),
+    pytest.param(MistralLLMProvider, dict(mistral_api_key=""), id="mistral"),
+])
+def test_missing_api_key_raises_at_construction(cls, skw):
+    with pytest.raises(LLMProviderError):
+        cls(_settings(**skw))

brain/tests/test_query_rewrite.py

@@ -0,0 +1,54 @@
+"""Tests de la réécriture de question autonome (app.application.query_rewrite)."""
+from __future__ import annotations
+
+from app.application.query_rewrite import standalone_question
+from app.domain.models import ChatMessage
+
+
+class FakeLLM:
+    def __init__(self, response: str | None = None, exc: Exception | None = None) -> None:
+        self.response = response
+        self.exc = exc
+        self.called = False
+
+    async def generate(self, prompt, *, temperature=None, output_format=None) -> str:
+        self.called = True
+        if self.exc:
+            raise self.exc
+        return self.response
+
+
+async def test_single_turn_returns_last_user_without_calling_llm():
+    llm = FakeLLM()
+    q = await standalone_question(llm, [ChatMessage(role="user", content="Qui est Strahd ?")])
+    assert q == "Qui est Strahd ?"
+    assert llm.called is False
+
+
+async def test_multi_turn_uses_llm_rewrite_and_strips_quotes():
+    llm = FakeLLM(response='"Quelles sont les faiblesses de Strahd ?"')
+    msgs = [
+        ChatMessage(role="user", content="Qui est Strahd ?"),
+        ChatMessage(role="assistant", content="Un vampire."),
+        ChatMessage(role="user", content="Et ses faiblesses ?"),
+    ]
+    assert await standalone_question(llm, msgs) == "Quelles sont les faiblesses de Strahd ?"
+    assert llm.called is True
+
+
+async def test_llm_failure_falls_back_to_last_user():
+    llm = FakeLLM(exc=RuntimeError("LLM HS"))
+    msgs = [ChatMessage(role="user", content="A"), ChatMessage(role="user", content="B")]
+    assert await standalone_question(llm, msgs) == "B"
+
+
+async def test_suspiciously_long_rewrite_falls_back():
+    llm = FakeLLM(response="x" * 500)
+    msgs = [ChatMessage(role="user", content="A"), ChatMessage(role="user", content="B")]
+    assert await standalone_question(llm, msgs) == "B"
+
+
+async def test_empty_messages_returns_empty_string():
+    llm = FakeLLM()
+    assert await standalone_question(llm, []) == ""
+    assert llm.called is False

brain/tests/test_rerank.py

@@ -0,0 +1,60 @@
+"""Tests du reranking LLM des passages RAG (app.application.rerank)."""
+from __future__ import annotations
+
+from app.application.rerank import pool_size, rerank
+
+
+class FakeLLM:
+    def __init__(self, response: str | None = None, exc: Exception | None = None) -> None:
+        self.response = response
+        self.exc = exc
+
+    async def generate(self, prompt, *, temperature=None, output_format=None) -> str:
+        if self.exc:
+            raise self.exc
+        return self.response
+
+
+def test_pool_size():
+    assert pool_size(8) == 24          # min(max(24, 8), 24)
+    assert pool_size(4) == 12          # 4 * 3
+    assert pool_size(10) == 24         # plafonné à POOL_MAX
+    assert pool_size(1) == 3
+
+
+async def test_rerank_skips_when_pool_not_larger_than_top_k():
+    passages = [{"text": "a"}, {"text": "b"}]
+    # len <= top_k → renvoyé tel quel, sans appel LLM.
+    assert await rerank(FakeLLM(exc=AssertionError("ne doit pas être appelé")),
+                        "q", passages, top_k=3) == passages
+
+
+async def test_rerank_reorders_by_llm_scores():
+    passages = [{"text": "a"}, {"text": "b"}, {"text": "c"}]
+    out = await rerank(FakeLLM(response='{"scores":[1, 9, 5]}'), "q", passages, top_k=2)
+    assert [p["text"] for p in out] == ["b", "c"]
+
+
+async def test_rerank_stable_on_score_ties():
+    passages = [{"text": "a"}, {"text": "b"}, {"text": "c"}]
+    # Notes égales → ordre cosinus d'origine préservé.
+    out = await rerank(FakeLLM(response='{"scores":[5, 5, 5]}'), "q", passages, top_k=2)
+    assert [p["text"] for p in out] == ["a", "b"]
+
+
+async def test_rerank_llm_failure_falls_back_to_cosine_order():
+    passages = [{"text": "a"}, {"text": "b"}, {"text": "c"}]
+    out = await rerank(FakeLLM(exc=RuntimeError("LLM HS")), "q", passages, top_k=2)
+    assert [p["text"] for p in out] == ["a", "b"]
+
+
+async def test_rerank_wrong_score_count_falls_back():
+    passages = [{"text": "a"}, {"text": "b"}, {"text": "c"}]
+    out = await rerank(FakeLLM(response='{"scores":[1, 2]}'), "q", passages, top_k=2)
+    assert [p["text"] for p in out] == ["a", "b"]
+
+
+async def test_rerank_non_numeric_scores_fall_back():
+    passages = [{"text": "a"}, {"text": "b"}, {"text": "c"}]
+    out = await rerank(FakeLLM(response='{"scores":["x","y","z"]}'), "q", passages, top_k=2)
+    assert [p["text"] for p in out] == ["a", "b"]

brain/tests/test_section_merger.py

@@ -0,0 +1,107 @@
+"""Tests des helpers de l'import de règles (app.application.import_rules) :
+_SectionMerger, _normalize_sections, _coerce_markdown, _find_anchor, _combine_sections.
+"""
+from __future__ import annotations
+
+from app.application.import_rules import (
+    _SectionMerger,
+    _coerce_markdown,
+    _combine_sections,
+    _find_anchor,
+    _normalize_sections,
+)
+
+
+# --- _SectionMerger ------------------------------------------------------------
+
+def test_section_merger_case_insensitive_and_joins():
+    m = _SectionMerger()
+    touched = m.add({"Combat": "règle A", "combat": "règle B"})
+    assert touched == ["Combat"]            # clé canonique = 1re vue
+    res = m.result()
+    assert list(res.keys()) == ["Combat"]
+    assert res["Combat"] == "règle A\n\nrègle B"
+
+
+def test_section_merger_skips_empty_title_or_content():
+    m = _SectionMerger()
+    touched = m.add({"": "x", "Titre": "   ", "Vrai": "contenu"})
+    assert touched == ["Vrai"]
+    assert m.result() == {"Vrai": "contenu"}
+
+
+def test_section_merger_accumulates_across_chunks():
+    m = _SectionMerger()
+    m.add({"Combat": "p1"})
+    m.add({"Combat": "p2", "Magie": "sorts"})
+    res = m.result()
+    assert res["Combat"] == "p1\n\np2"
+    assert res["Magie"] == "sorts"
+
+
+# --- _normalize_sections -------------------------------------------------------
+
+def test_normalize_unwraps_known_envelope():
+    assert _normalize_sections({"sections": {"Combat": "x"}}) == {"Combat": "x"}
+    assert _normalize_sections({"règles": {"A": "y"}}) == {"A": "y"}
+
+
+def test_normalize_title_content_schema():
+    assert _normalize_sections({"title": "Combat", "content": "texte"}) == {"Combat": "texte"}
+
+
+def test_normalize_strips_meta_keys():
+    assert _normalize_sections({"Combat": "x", "thought": "bla", "notes": "y"}) == {"Combat": "x"}
+
+
+def test_normalize_passthrough_plain_sections():
+    assert _normalize_sections({"A": "1", "B": "2"}) == {"A": "1", "B": "2"}
+
+
+# --- _coerce_markdown ----------------------------------------------------------
+
+def test_coerce_markdown_string_passthrough():
+    assert _coerce_markdown("texte") == "texte"
+
+
+def test_coerce_markdown_none_is_empty():
+    assert _coerce_markdown(None) == ""
+
+
+def test_coerce_markdown_list_joined():
+    assert _coerce_markdown(["a", "b"]) == "a\n\nb"
+
+
+def test_coerce_markdown_dict_flattened():
+    out = _coerce_markdown({"Sous-titre": "contenu"})
+    assert "Sous-titre" in out
+    assert "contenu" in out
+
+
+# --- _find_anchor --------------------------------------------------------------
+
+def test_find_anchor_exact():
+    text = "Chapitre 1. Le héros entre."
+    assert _find_anchor(text, "Le héros entre", 0) == text.index("Le héros entre")
+
+
+def test_find_anchor_whitespace_flexible():
+    text = "Le   héros\nentre dans la taverne."
+    # Espaces multiples / saut de ligne dans le texte source, anchor normalisé.
+    assert _find_anchor(text, "Le héros entre dans la taverne", 0) is not None
+
+
+def test_find_anchor_case_insensitive():
+    assert _find_anchor("LE DONJON s'ouvre", "le donjon", 0) is not None
+
+
+def test_find_anchor_not_found():
+    assert _find_anchor("texte quelconque", "introuvable xyz", 0) is None
+
+
+# --- _combine_sections ---------------------------------------------------------
+
+def test_combine_sections_case_insensitive_concat():
+    out = _combine_sections({"Combat": "p1"}, {"combat": "p2", "Magie": "sorts"})
+    assert out["Combat"] == "p1\n\np2"
+    assert out["Magie"] == "sorts"

brain/tests/test_settings_store.py

@@ -0,0 +1,57 @@
+"""Tests des overrides runtime persistés (app.core.settings_store).
+
+Le chemin du fichier est redirigé vers un tmp_path pour isoler chaque test.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from app.core import settings_store
+
+
+@pytest.fixture(autouse=True)
+def isolated_store(tmp_path, monkeypatch):
+    monkeypatch.setattr(settings_store, "_OVERRIDES_PATH", tmp_path / "settings.json")
+    return tmp_path / "settings.json"
+
+
+def test_load_missing_file_returns_empty():
+    assert settings_store.load_overrides() == {}
+
+
+def test_save_filters_to_allowlist_and_persists(isolated_store):
+    result = settings_store.save_overrides({
+        "llm_model": "gemma3:12b",
+        "internal_shared_secret": "HACK",   # hors allow-list → ignoré
+        "champ_inconnu": "x",               # hors allow-list → ignoré
+    })
+    assert result == {"llm_model": "gemma3:12b"}
+    on_disk = json.loads(Path(isolated_store).read_text(encoding="utf-8"))
+    assert on_disk == {"llm_model": "gemma3:12b"}
+
+
+def test_save_merges_with_existing():
+    settings_store.save_overrides({"llm_model": "a"})
+    merged = settings_store.save_overrides({"llm_provider": "ollama"})
+    assert merged == {"llm_model": "a", "llm_provider": "ollama"}
+
+
+def test_load_ignores_non_allowlisted_keys_on_disk(isolated_store):
+    Path(isolated_store).write_text(
+        json.dumps({"llm_model": "ok", "internal_shared_secret": "leak"}),
+        encoding="utf-8",
+    )
+    assert settings_store.load_overrides() == {"llm_model": "ok"}
+
+
+def test_load_corrupted_file_returns_empty(isolated_store):
+    Path(isolated_store).write_text("{ pas du json", encoding="utf-8")
+    assert settings_store.load_overrides() == {}
+
+
+def test_load_non_dict_json_returns_empty(isolated_store):
+    Path(isolated_store).write_text("[1, 2, 3]", encoding="utf-8")
+    assert settings_store.load_overrides() == {}

brain/tests/test_streaming.py

@@ -0,0 +1,48 @@
+"""Tests des heartbeats SSE (app.application.streaming.with_heartbeat)."""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from app.application.streaming import with_heartbeat
+
+
+async def _collect(agen) -> list[tuple[str, object]]:
+    return [ev async for ev in agen]
+
+
+async def test_fast_coro_emits_only_result():
+    async def quick() -> int:
+        return 42
+    events = await _collect(with_heartbeat(quick(), interval=0.05))
+    assert events == [("result", 42)]
+
+
+async def test_slow_coro_emits_heartbeats_then_result():
+    async def slow() -> str:
+        await asyncio.sleep(0.06)
+        return "fini"
+    events = await _collect(with_heartbeat(slow(), interval=0.02))
+    assert ("heartbeat", None) in events
+    assert events[-1] == ("result", "fini")
+
+
+async def test_relays_status_messages_from_queue():
+    queue: asyncio.Queue = asyncio.Queue()
+
+    async def work() -> str:
+        await asyncio.sleep(0.05)
+        return "ok"
+
+    queue.put_nowait("fournisseur saturé, nouvel essai")
+    events = await _collect(with_heartbeat(work(), interval=0.02, status_queue=queue))
+    assert ("status", "fournisseur saturé, nouvel essai") in events
+    assert events[-1] == ("result", "ok")
+
+
+async def test_propagates_coro_exception():
+    async def boom() -> None:
+        raise ValueError("échec interne")
+    with pytest.raises(ValueError, match="échec interne"):
+        await _collect(with_heartbeat(boom(), interval=0.05))

brain/tests/test_tree_merger.py

@@ -0,0 +1,149 @@
+"""Tests du _TreeMerger de l'import de campagne (app.application.import_campaign).
+
+Cœur du REDUCE : fusion par nom (insensible à la casse) des sous-arbres
+arc→chapitre→scène→pièce produits morceau par morceau, + accumulation des PNJ.
+"""
+from __future__ import annotations
+
+from app.application.import_campaign import _TreeMerger
+
+
+def test_single_chunk_builds_full_tree():
+    m = _TreeMerger()
+    m.add([{
+        "name": "Acte I", "description": "intro",
+        "chapters": [{
+            "name": "Ch1", "description": "d",
+            "scenes": [{
+                "name": "Sc1", "description": "s",
+                "player_narration": "PN", "gm_notes": "GM",
+                "rooms": [{"name": "R1", "description": "rd", "enemies": "gob", "loot": "or"}],
+            }],
+        }],
+    }])
+    arcs = m.result()
+    assert len(arcs) == 1
+    arc = arcs[0]
+    assert arc.name == "Acte I"
+    assert arc.arc_type == "LINEAR"
+    sc = arc.chapters[0].scenes[0]
+    assert sc.player_narration == "PN"
+    assert sc.gm_notes == "GM"
+    room = sc.rooms[0]
+    assert (room.name, room.enemies, room.loot) == ("R1", "gob", "or")
+
+
+def test_case_insensitive_arc_and_chapter_merge():
+    m = _TreeMerger()
+    m.add([{"name": "Acte I", "chapters": [{"name": "Ch1", "scenes": []}]}])
+    m.add([{"name": "acte i", "chapters": [{"name": "ch1", "scenes": []},
+                                           {"name": "Ch2", "scenes": []}]}])
+    arcs = m.result()
+    assert len(arcs) == 1
+    assert {c.name for c in arcs[0].chapters} == {"Ch1", "Ch2"}
+
+
+def test_description_first_non_empty_wins():
+    m = _TreeMerger()
+    m.add([{"name": "A", "description": "", "chapters": []}])
+    m.add([{"name": "A", "description": "vraie", "chapters": []}])
+    m.add([{"name": "A", "description": "autre", "chapters": []}])
+    assert m.result()[0].description == "vraie"
+
+
+def test_hub_type_wins_if_any_chunk_signals_it():
+    m = _TreeMerger()
+    m.add([{"name": "A", "type": "LINEAR", "chapters": []}])
+    m.add([{"name": "A", "type": "HUB", "chapters": []}])
+    assert m.result()[0].arc_type == "HUB"
+
+
+def _scene(narr=None, gm=None):
+    s = {"name": "S"}
+    if narr is not None:
+        s["player_narration"] = narr
+    if gm is not None:
+        s["gm_notes"] = gm
+    return {"name": "A", "chapters": [{"name": "C", "scenes": [s]}]}
+
+
+def test_scene_narration_concatenated_across_chunks():
+    m = _TreeMerger()
+    m.add([_scene(narr="début")])
+    m.add([_scene(narr="suite")])
+    sc = m.result()[0].chapters[0].scenes[0]
+    assert sc.player_narration == "début\n\nsuite"
+
+
+def test_scene_field_dedups_exact_overlap():
+    m = _TreeMerger()
+    m.add([_scene(gm="texte identique")])
+    m.add([_scene(gm="texte identique")])
+    assert m.result()[0].chapters[0].scenes[0].gm_notes == "texte identique"
+
+
+def test_scene_field_takes_superset_version():
+    m = _TreeMerger()
+    m.add([_scene(gm="court")])
+    m.add([_scene(gm="court et bien plus long")])
+    assert m.result()[0].chapters[0].scenes[0].gm_notes == "court et bien plus long"
+
+
+def test_npcs_longest_description_wins():
+    m = _TreeMerger()
+    m.add_npcs([{"name": "Thorin", "description": "court"}])
+    m.add_npcs([{"name": "thorin", "description": "une description bien plus complète"}])
+    npcs = m.npcs()
+    assert len(npcs) == 1
+    assert npcs[0].name == "Thorin"
+    assert npcs[0].description == "une description bien plus complète"
+
+
+def test_counts():
+    m = _TreeMerger()
+    m.add([{"name": "A", "chapters": [
+        {"name": "C1", "scenes": [{"name": "S1"}, {"name": "S2"}]},
+        {"name": "C2", "scenes": []},
+    ]}])
+    assert m.counts() == (1, 2, 2)
+
+
+def test_blank_names_are_skipped():
+    m = _TreeMerger()
+    m.add([{"name": "", "chapters": []},
+           {"name": "   ", "chapters": []},
+           {"name": "OK", "chapters": [{"name": "", "scenes": []}]}])
+    arcs = m.result()
+    assert len(arcs) == 1
+    assert arcs[0].name == "OK"
+    assert arcs[0].chapters == []
+
+
+def test_merge_chapters_consolidation():
+    m = _TreeMerger()
+    m.add([{"name": "A", "chapters": [
+        {"name": "Intro", "scenes": [{"name": "S1"}]},
+        {"name": "Introduction", "scenes": [{"name": "S2"}]},
+    ]}])
+    assert m.merge_chapters("Intro", ["Introduction"]) is True
+    chapters = m.result()[0].chapters
+    assert len(chapters) == 1
+    assert {s.name for s in chapters[0].scenes} == {"S1", "S2"}
+
+
+def test_merge_chapters_unknown_target_returns_false():
+    m = _TreeMerger()
+    m.add([{"name": "A", "chapters": [{"name": "Intro", "scenes": []}]}])
+    assert m.merge_chapters("Inexistant", ["Intro"]) is False
+
+
+def test_merge_scenes_consolidation():
+    m = _TreeMerger()
+    m.add([{"name": "A", "chapters": [{"name": "C", "scenes": [
+        {"name": "Combat", "gm_notes": "x"},
+        {"name": "Le combat", "gm_notes": "y"},
+    ]}]}])
+    assert m.merge_scenes("C", "Combat", ["Le combat"]) is True
+    scenes = m.result()[0].chapters[0].scenes
+    assert len(scenes) == 1
+    assert scenes[0].name == "Combat"

brain/tests/test_vector_store.py

@@ -0,0 +1,119 @@
+"""Tests du stockage vectoriel fichier + recherche hybride (app.infrastructure.vector_store).
+
+Le répertoire de stockage est redirigé vers un tmp_path et le cache mémoire est
+vidé avant chaque test pour une isolation totale.
+"""
+from __future__ import annotations
+
+import pytest
+
+from app.infrastructure import vector_store
+
+
+@pytest.fixture(autouse=True)
+def isolated_store(tmp_path, monkeypatch):
+    monkeypatch.setattr(vector_store, "_STORE_DIR", tmp_path)
+    vector_store._CACHE.clear()
+    yield
+    vector_store._CACHE.clear()
+
+
+# --- cosinus -------------------------------------------------------------------
+
+def test_cosine_identical_is_one():
+    assert vector_store._cosine([1.0, 0.0], [2.0, 0.0]) == pytest.approx(1.0)
+
+
+def test_cosine_orthogonal_is_zero():
+    assert vector_store._cosine([1.0, 0.0], [0.0, 1.0]) == 0.0
+
+
+def test_cosine_mismatched_or_zero_is_zero():
+    assert vector_store._cosine([1.0], [1.0, 2.0]) == 0.0
+    assert vector_store._cosine([0.0, 0.0], [1.0, 1.0]) == 0.0
+    assert vector_store.cosine_similarity([], [1.0]) == 0.0  # alias public
+
+
+# --- mots significatifs --------------------------------------------------------
+
+def test_significant_words_filters_stopwords_and_short():
+    words = vector_store._significant_words("Le dragon DORT dans la caverne avec les gobelins")
+    assert "dragon" in words
+    assert "caverne" in words
+    assert "gobelins" in words
+    assert "les" not in words and "avec" not in words and "la" not in words
+
+
+# --- save / exists / delete ----------------------------------------------------
+
+def test_save_then_exists_and_delete():
+    vector_store.save("src1", ["chunk a"], [[1.0, 0.0]])
+    assert vector_store.exists("src1") is True
+    vector_store.delete("src1")
+    assert vector_store.exists("src1") is False
+
+
+def test_save_rejects_mismatched_lengths():
+    with pytest.raises(ValueError):
+        vector_store.save("s", ["a", "b"], [[1.0]])
+    with pytest.raises(ValueError):
+        vector_store.save("s", ["a"], [[1.0]], pages=[1, 2])
+
+
+def test_all_chunks_returns_text_and_page():
+    vector_store.save("s", ["t1", "t2"], [[1.0], [2.0]], pages=[3, 7])
+    chunks = vector_store.all_chunks("s")
+    assert chunks == [{"text": "t1", "page": 3}, {"text": "t2", "page": 7}]
+
+
+# --- recherche -----------------------------------------------------------------
+
+def test_search_ranks_by_cosine():
+    vector_store.save("s", ["proche", "loin"], [[1.0, 0.0], [0.0, 1.0]])
+    results = vector_store.search(["s"], [1.0, 0.0], top_k=2)
+    assert [r["text"] for r in results] == ["proche", "loin"]
+    assert results[0]["score"] > results[1]["score"]
+
+
+def test_search_respects_top_k():
+    vector_store.save("s", ["a", "b", "c"], [[1.0], [0.9], [0.8]])
+    assert len(vector_store.search(["s"], [1.0], top_k=2)) == 2
+
+
+def test_search_min_score_filters_out_weak_matches():
+    vector_store.save("s", ["proche", "orthogonal"], [[1.0, 0.0], [0.0, 1.0]])
+    results = vector_store.search(["s"], [1.0, 0.0], top_k=5, min_score=0.5)
+    assert [r["text"] for r in results] == ["proche"]
+
+
+def test_search_lexical_bonus_promotes_exact_term_match():
+    # Deux extraits de cosinus IDENTIQUE : le bonus lexical départage celui qui
+    # contient le mot exact de la question.
+    vector_store.save(
+        "s",
+        ["Strahd règne sur Barovia", "un texte neutre sans rapport"],
+        [[1.0, 0.0], [1.0, 0.0]],
+    )
+    results = vector_store.search(["s"], [1.0, 0.0], top_k=2, query_text="Strahd")
+    assert results[0]["text"] == "Strahd règne sur Barovia"
+    assert results[0]["score"] > results[1]["score"]
+
+
+def test_search_includes_source_id_and_page():
+    vector_store.save("livre", ["extrait"], [[1.0]], pages=[42])
+    [res] = vector_store.search(["livre"], [1.0], top_k=1)
+    assert res["source_id"] == "livre"
+    assert res["page"] == 42
+
+
+# --- résumés (analyse approfondie) ---------------------------------------------
+
+def test_summaries_roundtrip_keyed_by_batch_tokens():
+    vector_store.save_summaries("s", 1000, [{"summary": "résumé", "vector": [1.0]}])
+    assert vector_store.load_summaries("s", 1000) == [{"summary": "résumé", "vector": [1.0]}]
+    # Taille de lot différente → invalidé (le découpage ne correspondrait plus).
+    assert vector_store.load_summaries("s", 2000) is None
+
+
+def test_load_summaries_absent_returns_none():
+    assert vector_store.load_summaries("inconnu", 1000) is None

core/.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip

core/mvnw

@@ -0,0 +1,295 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.4
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
+
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
+  fi
+fi
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
+    fi
+  done
+  set -f
+fi
+
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
+fi
+
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"

core/mvnw.cmd

@@ -0,0 +1,189 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

core/pom.xml

@@ -8,18 +8,35 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.2.12</version>
+        <version>3.5.14</version>
         <relativePath/>
     </parent>
 
     <groupId>com.loremind</groupId>
     <artifactId>loremind-core</artifactId>
-    <version>0.11.2-beta</version>
+    <version>1.0.3</version>
     <name>LoreMind Core</name>
     <description>Backend Core - Architecture Hexagonale</description>
 
     <properties>
         <java.version>17</java.version>
+        <!-- Override de la transitive minio → commons-compress → commons-lang3 3.17.
+             >= 3.18 : corrige CVE-2025-48924 (recursion infinie ClassUtils.getClass).
+             Propriete reconnue par le BOM Spring Boot → s'applique partout. -->
+        <commons-lang3.version>3.20.0</commons-lang3.version>
+        <!-- Overrides CVE (detectes par Trivy en CI — job quality.yml) :
+             proprietes reconnues par le BOM Spring Boot, comme ci-dessus. -->
+        <!-- >= 2.21.4 : CVE-2026-54512 / CVE-2026-54513 (execution de code
+             arbitraire via contournement du PolymorphicTypeValidator). -->
+        <jackson-bom.version>2.21.4</jackson-bom.version>
+        <!-- >= 4.1.135 : lot de CVE netty (DoS codec/handler, bypass de
+             verification hostname CVE-2026-50010, DNS CVE-2026-45674/47691). -->
+        <netty.version>4.1.135.Final</netty.version>
+        <!-- >= 10.1.55 : 3 CRITICAL Tomcat (CVE-2026-41293 headers HTTP/2 non
+             valides, CVE-2026-43512 bypass auth digest, CVE-2026-43515). -->
+        <tomcat.version>10.1.55</tomcat.version>
+        <!-- >= 42.7.11 : CVE-2026-42198 (DoS client via SCRAM-SHA-256). -->
+        <postgresql.version>42.7.11</postgresql.version>
     </properties>
 
     <dependencies>
@@ -56,11 +73,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) -->
@@ -77,38 +114,113 @@
             <scope>test</scope>
         </dependency>
 
-        <!-- MinIO — client S3-compatible pour le stockage d'images (Shared Kernel images). -->
+        <!-- MinIO — client S3-compatible pour le stockage d'images (Shared Kernel images).
+             8.6.x = derniere ligne 8.x (la 9.x change l'API) ; transitives a jour. -->
         <dependency>
             <groupId>io.minio</groupId>
             <artifactId>minio</artifactId>
-            <version>8.5.11</version>
+            <version>8.6.0</version>
+            <exclusions>
+                <!-- OkHttp 5 : l'artefact `okhttp` est un alias multiplateforme dont la
+                     resolution vers les classes JVM passe par les metadonnees Gradle —
+                     que Maven ignore. On exclut l'alias et on declare `okhttp-jvm`
+                     (les vraies classes) explicitement ci-dessous. -->
+                <exclusion>
+                    <groupId>com.squareup.okhttp3</groupId>
+                    <artifactId>okhttp</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp-jvm</artifactId>
+            <version>5.1.0</version>
         </dependency>
 
         <!-- Nimbus JOSE+JWT — verification des JWT Ed25519 (EdDSA) emis par le relais
-             Patreon. Supporte nativement les cles Ed25519 via BouncyCastle. -->
+             Patreon. Supporte nativement les cles Ed25519 via BouncyCastle.
+             >= 10.0.2 : corrige CVE-2025-53864 (DoS par JSON profondement imbrique
+             dans le claim set — surface critique : JWT colle par l'utilisateur). -->
         <dependency>
             <groupId>com.nimbusds</groupId>
             <artifactId>nimbus-jose-jwt</artifactId>
-            <version>9.40</version>
+            <version>10.9.1</version>
         </dependency>
         <dependency>
             <groupId>org.bouncycastle</groupId>
             <artifactId>bcprov-jdk18on</artifactId>
-            <version>1.78.1</version>
+            <version>1.84</version>
         </dependency>
         <!-- Google Tink : runtime requis par com.nimbusds.jose.crypto.Ed25519Verifier
              (depuis Nimbus 9.x, la verification EdDSA delegue a Tink.subtle.Ed25519Verify).
              Tink n'est PAS une dependance transitive de nimbus-jose-jwt → il faut
-             l'ajouter explicitement, sinon NoClassDefFoundError au premier verify(). -->
+             l'ajouter explicitement, sinon NoClassDefFoundError au premier verify().
+             >= 1.15 : embarque un protobuf-java corrige (CVE-2024-7254). -->
         <dependency>
             <groupId>com.google.crypto.tink</groupId>
             <artifactId>tink</artifactId>
-            <version>1.14.1</version>
+            <version>1.21.0</version>
+        </dependency>
+
+        <!-- openhtmltopdf — rendu XHTML+CSS -> PDF, 100 % JVM (pas de binaire natif :
+             compatible distribution bureau locale via jpackage). Sert l'export PDF
+             d'une campagne (livret). -->
+        <dependency>
+            <groupId>com.openhtmltopdf</groupId>
+            <artifactId>openhtmltopdf-pdfbox</artifactId>
+            <version>1.0.10</version>
+        </dependency>
+        <!-- TwelveMonkeys imageio-webp — décodeur WebP pur Java pour ImageIO. Sans lui,
+             ImageIO (et donc openhtmltopdf/PDFBox) ne sait pas lire le WebP : les
+             portraits/illustrations WebP seraient absents du PDF. -->
+        <dependency>
+            <groupId>com.twelvemonkeys.imageio</groupId>
+            <artifactId>imageio-webp</artifactId>
+            <version>3.12.0</version>
         </dependency>
     </dependencies>
 
     <build>
         <plugins>
+            <!-- Declare EXPLICITEMENT le processor d'annotations Lombok : sinon javac
+                 avertit que l'annotation processing implicite (processeur trouve sur le
+                 classpath sans etre declare) sera desactivee dans un futur JDK. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <!-- Expose le chemin du jar mockito-core dans la propriete
+                 ${org.mockito:mockito-core:jar}, consommee par surefire ci-dessous. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>properties</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <!-- Charge Mockito comme un VRAI -javaagent (au lieu de l'auto-attachement
+                 dynamique de byte-buddy, qui imprime un avertissement et sera interdit
+                 dans un futur JDK). `@{argLine}` preserve l'argLine pose par JaCoCo. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>@{argLine} -javaagent:${org.mockito:mockito-core:jar} -Xshare:off</argLine>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
@@ -152,8 +264,79 @@
                             <goal>report</goal>
                         </goals>
                     </execution>
+                    <!-- Plancher ANTI-REGRESSION : `mvn test` echoue si la couverture
+                         d'instructions du bundle passe sous 60% (mesure actuelle ~68%).
+                         A remonter au fil du temps. N'impacte PAS le build Docker
+                         (qui passe -DskipTests) : le gating est porte par la CI. -->
+                    <execution>
+                        <id>check</id>
+                        <phase>test</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <rule>
+                                    <element>BUNDLE</element>
+                                    <limits>
+                                        <limit>
+                                            <counter>INSTRUCTION</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <minimum>0.60</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
                 </executions>
             </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>