Mise en place d'un composant permettant d'améliorer l'experience de mise à jour (via un rafraichissement de l'appli).

Modification de la partie web pour prendre la modification en compte

.env.example

@@ -38,3 +38,15 @@ LLM_MODEL=gemma4:26b
 # 1min.ai (si LLM_PROVIDER=onemin)
 ONEMIN_API_KEY=
 ONEMIN_MODEL=gpt-4o-mini
+
+# --- Mises a jour automatiques (Watchtower) ------------------------------
+# Watchtower verifie les nouvelles versions de core/brain/web et permet
+# le declenchement manuel via l'UI (bouton "Mettre a jour"). Postgres et
+# MinIO sont exclus volontairement.
+#
+# Activer : COMPOSE_PROFILES=autoupdate + WATCHTOWER_TOKEN non vide.
+# COMPOSE_PROFILES=autoupdate
+# WATCHTOWER_TOKEN=change-me-use-openssl-rand-hex-32
+# WATCHTOWER_MONITOR_ONLY=false   # true = detecter sans appliquer
+# WATCHTOWER_SCHEDULE=0 0 4 * * *
+# TZ=Europe/Paris

.gitea/workflows/e2e.yml

@@ -0,0 +1,95 @@
+name: E2E Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+          cache-dependency-path: web/package-lock.json
+
+      - name: Create .env for stack
+        run: |
+          cat > .env <<'EOF'
+          POSTGRES_PASSWORD=ci-postgres-pass
+          BRAIN_INTERNAL_SECRET=ci-brain-secret
+          ADMIN_USERNAME=admin
+          ADMIN_PASSWORD=ci-admin-pass
+          WEB_PORT=8081
+          LLM_PROVIDER=ollama
+          EOF
+
+      - name: Build & start stack
+        run: |
+          docker compose -f docker-compose.yml -f docker-compose.e2e.yml up -d --build
+
+      - name: Attach runner to compose network
+        run: |
+          NET=$(docker network ls --format '{{.Name}}' | grep -E '(^|_)loremind(_|$)' | grep -i default | head -1)
+          if [ -z "$NET" ]; then
+            echo "Compose network not found" >&2
+            docker network ls
+            exit 1
+          fi
+          echo "Connecting $(hostname) to network $NET"
+          docker network connect "$NET" "$(hostname)"
+
+      - name: Wait for web to be ready
+        run: |
+          timeout 180 bash -c 'until curl -sf http://web/ > /dev/null; do echo "waiting..."; sleep 3; done'
+
+      - name: Install web deps
+        working-directory: web
+        run: npm ci
+
+      - name: Work around runner clock skew for apt
+        run: |
+          sudo tee /etc/apt/apt.conf.d/99no-check-valid-until >/dev/null <<'EOF'
+          Acquire::Check-Valid-Until "false";
+          Acquire::Check-Date "false";
+          EOF
+
+      - name: Install Playwright browsers
+        working-directory: web
+        run: npx playwright install --with-deps chromium
+
+      - name: Run Playwright tests
+        working-directory: web
+        env:
+          E2E_BASE_URL: http://web
+          CI: 'true'
+        run: npm run e2e
+
+      - name: Dump container logs on failure
+        if: failure()
+        run: docker compose -f docker-compose.yml -f docker-compose.e2e.yml logs --no-color
+
+      - name: Upload Playwright report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report
+          path: web/playwright-report/
+          retention-days: 14
+
+      - name: Stop stack
+        if: always()
+        run: docker compose -f docker-compose.yml -f docker-compose.e2e.yml down -v

.gitea/workflows/release.yml

@@ -6,8 +6,10 @@ on:
       - 'v*'
 
 env:
-  REGISTRY: git.igmlcreation.fr
+  GITEA_REGISTRY: git.igmlcreation.fr
-  REGISTRY_USER: ietm64
+  GITEA_REGISTRY_USER: ietm64
+  GHCR_REGISTRY: ghcr.io
+  GHCR_NAMESPACE: igmlcreation
 
 jobs:
   build:
@@ -26,19 +28,39 @@ jobs:
       - name: Login to Gitea Registry
         uses: docker/login-action@v3
         with:
-          registry: ${{ env.REGISTRY }}
+          registry: ${{ env.GITEA_REGISTRY }}
-          username: ${{ env.REGISTRY_USER }}
+          username: ${{ env.GITEA_REGISTRY_USER }}
           password: ${{ secrets.DOCKER_PAT }}
 
+      # Login to GHCR (GitHub Container Registry) pour distribuer les images
+      # publiquement aux utilisateurs finaux. Reputation domaine plus elevee
+      # que git.igmlcreation.fr (mieux pour les antivirus / SmartScreen).
+      - name: Login to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GHCR_REGISTRY }}
+          username: ${{ env.GHCR_NAMESPACE }}
+          password: ${{ secrets.GHCR_TOKEN }}
+
       - name: Extract version
         id: meta
         run: echo "version=${GITHUB_REF_NAME#v}" >> $GITHUB_OUTPUT
 
+      # Push vers les deux registries en un seul build (build-push-action
+      # accepte une liste de tags ; aucun build supplementaire necessaire).
+      # Naming :
+      #   - Gitea : conserve l'ancien pattern ietm64/<component> pour ne pas
+      #             casser les installs existantes qui ont REGISTRY=git.igmlcreation.fr
+      #             dans leur .env.
+      #   - GHCR  : nouveau pattern igmlcreation/loremind-<component> qui evite
+      #             la collision avec d'autres projets de l'org.
       - name: Build & push ${{ matrix.component }}
         uses: docker/build-push-action@v5
         with:
           context: ./${{ matrix.component }}
           push: true
           tags: |
-            ${{ env.REGISTRY }}/${{ env.REGISTRY_USER }}/${{ matrix.component }}:latest
+            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/${{ matrix.component }}:latest
-            ${{ env.REGISTRY }}/${{ env.REGISTRY_USER }}/${{ matrix.component }}:${{ steps.meta.outputs.version }}
+            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/${{ matrix.component }}:${{ steps.meta.outputs.version }}
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-${{ matrix.component }}:latest
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-${{ matrix.component }}:${{ steps.meta.outputs.version }}

.gitignore

@@ -7,6 +7,11 @@
 brain/data/settings.json
 *.key
 *.pem
+# Exception : la cle PUBLIQUE JWT du relais Patreon est destinee a etre
+# embarquee dans le binaire. Pas de risque a la committer (c'est une cle
+# publique par construction). Sans cette exception, le module licensing
+# est silencieusement desactive dans les builds CI.
+!core/src/main/resources/licensing/jwt-public-key.pem
 
 # ============================================================================
 # Java / Spring Boot / Maven
@@ -53,6 +58,12 @@ yarn-error.log*
 .pnpm-debug.log*
 coverage/
 
+# Playwright (E2E)
+web/test-results/
+web/playwright-report/
+web/blob-report/
+web/playwright/.cache/
+
 # ============================================================================
 # IDE / Editeurs
 # ============================================================================
@@ -85,8 +96,14 @@ Thumbs.db
 # Documentation hors-code (conservee hors du repo)
 # ============================================================================
 docs/
+loremind-docs/
 
 # ============================================================================
 # Docker Compose override (dev uniquement, non-distribue aux end users)
 # ============================================================================
 docker-compose.override.yml
+
+# ============================================================================
+# Relais OAuth Patreon (repo Gitea separe, clone localement pour facilite)
+# ============================================================================
+relay/

INSTALL.md

@@ -1,311 +0,0 @@
-# Installation de LoreMindMJ
-
-Ce document decrit la procedure d'installation de LoreMindMJ. Temps estime :
-5 a 10 minutes selon la qualite de la connexion reseau.
-
-## 1. Prerequis
-
-- **Docker Desktop** ([Windows](https://www.docker.com/products/docker-desktop/) /
-  [Mac](https://www.docker.com/products/docker-desktop/)) ou
-  **Docker Engine + Compose v2** (Linux). Verification :
-  ```
-  docker --version
-  docker compose version
-  ```
-  Compose v2 est requis : la commande est `docker compose`, non `docker-compose`.
-
-- **Un fournisseur LLM**, au choix :
-  - **[Ollama](https://ollama.com/)** installe sur la machine hote (gratuit,
-    local, necessite environ 6 Go de RAM libre pour les modeles recommandes).
-  - **Une cle API [1min.ai](https://1min.ai)** (hebergement cloud, facturation
-    a l'usage, aucune installation supplementaire requise).
-
-- Environ **2 Go d'espace disque** pour les images Docker, auxquels s'ajoute
-  la taille des modeles Ollama si l'option locale est retenue.
-
-## 2. Recuperation des fichiers
-
-Telecharger les deux fichiers suivants depuis la
-[derniere release](https://git.igmlcreation.fr/ietm64/LoreMindMJ/releases) et
-les placer dans un dossier dedie (par exemple `~/loremind/` ou
-`C:\Programs\loremind\`) :
-
-- `docker-compose.yml`
-- `.env.example`
-
-Le code source n'est pas necessaire : les images sont pre-construites et
-publiees sur le registry Gitea `git.igmlcreation.fr` (non Docker Hub). Le
-premier `docker compose pull` les telechargera automatiquement.
-
-## 3. Configuration du fichier `.env`
-
-Renommer `.env.example` en `.env` et l'ouvrir dans un editeur de texte. **Trois
-variables sont obligatoires** ; sans elles, `docker compose up` refusera de
-demarrer. Ce comportement est volontaire afin d'eviter tout deploiement
-non-securise par defaut.
-
-### `POSTGRES_PASSWORD`
-
-Mot de passe de la base de donnees PostgreSQL. Choisir une valeur robuste.
-Seuls les conteneurs utilisent cette valeur : il n'est pas necessaire de la
-memoriser au-dela du fichier `.env`.
-
-### `ADMIN_PASSWORD`
-
-Protege l'ecran **Parametres** de l'application via HTTP Basic. Cette valeur
-sera demandee par le navigateur lors de toute modification de la configuration
-(changement de modele LLM, saisie de cle API, etc.). Le nom d'utilisateur par
-defaut est `admin`, modifiable via la variable `ADMIN_USERNAME`.
-
-### `BRAIN_INTERNAL_SECRET`
-
-Secret partage entre le service Java (`core`) et le service Python (`brain`).
-Empeche toute requete externe d'atteindre directement le service Brain.
-Generer une valeur aleatoire de 64 caracteres hexadecimaux :
-
-```
-openssl rand -hex 32
-```
-
-Sous Windows sans `openssl`, utiliser PowerShell :
-
-```powershell
--join ((48..57) + (97..102) | Get-Random -Count 64 | % {[char]$_})
-```
-
-### Variables optionnelles
-
-- `WEB_PORT` (defaut `8081`) : port d'ecoute de l'interface web.
-- `ADMIN_USERNAME` (defaut `admin`) : identifiant de la popup Parametres.
-- `LLM_PROVIDER` (defaut `ollama`) : choix du fournisseur LLM (voir
-  section 5).
-
-Les autres variables (`MINIO_USER`/`MINIO_PASSWORD`, `POSTGRES_DB`,
-`POSTGRES_USER`) disposent de valeurs par defaut adaptees a un deploiement
-personnel et peuvent etre conservees en l'etat.
-
-## 4. Lancement de la stack
-
-Depuis le dossier contenant `docker-compose.yml` et `.env` :
-
-```
-docker compose up -d
-```
-
-Le premier demarrage telecharge les images (environ 1 a 2 Go au total) et
-initialise la base. Compter 2 a 5 minutes selon la qualite de la connexion.
-La progression peut etre suivie via :
-
-```
-docker compose logs -f
-```
-
-(`Ctrl+C` pour quitter l'affichage ; les services continuent de fonctionner
-en arriere-plan.)
-
-Une fois les services en etat `healthy`, ouvrir **http://localhost:8081**
-dans un navigateur.
-
-### Verification du fonctionnement
-
-```
-docker compose ps
-```
-
-Cinq conteneurs doivent apparaitre en etat `Up` ou `healthy` :
-`loremind-postgres`, `loremind-minio`, `loremind-core`, `loremind-brain`,
-`loremind-web`. Le conteneur `loremind-minio-init` s'arrete automatiquement
-apres creation du bucket d'images : ce comportement est normal.
-
-## 5. Configuration du fournisseur LLM
-
-### Ollama (local, gratuit)
-
-Installer Ollama sur la machine hote (pas dans Docker), puis telecharger un
-modele :
-
-```
-ollama pull gemma4:26b
-```
-
-Dans `.env` :
-
-```
-LLM_PROVIDER=ollama
-LLM_MODEL=gemma4:26b
-OLLAMA_BASE_URL=http://host.docker.internal:11434
-```
-
-L'adresse `host.docker.internal` permet au conteneur `brain` d'atteindre
-Ollama sur la machine hote. Cette resolution est native sous Docker Desktop
-(Mac / Windows). Sous Linux, le fichier `docker-compose.yml` declare un
-`extra_hosts` equivalent.
-
-### 1min.ai (cloud, paye)
-
-Dans `.env` :
-
-```
-LLM_PROVIDER=onemin
-ONEMIN_API_KEY=sk-...
-ONEMIN_MODEL=gpt-4o-mini
-```
-
-### Modification a chaud
-
-Le fournisseur, le modele et la cle API peuvent etre modifies a chaud depuis
-l'ecran **Parametres** de l'application. Les modifications sont persistees
-dans un volume Docker et survivent aux redemarrages. Les variables d'env du
-fichier `.env` sont uniquement utilisees comme valeurs initiales au premier
-demarrage.
-
-## 6. Mise a jour
-
-```
-docker compose pull
-docker compose up -d
-```
-
-Les donnees (base PostgreSQL, images MinIO, configuration Brain) sont
-stockees dans des volumes Docker et survivent aux mises a jour.
-
-## 7. Sauvegarde
-
-Les donnees sont reparties dans trois volumes Docker :
-
-- `loremindmj_postgres-data` — ensemble des donnees applicatives (lores,
-  campagnes, pages, templates, branches narratives, etc.).
-- `loremindmj_minio-data` — images uploadees.
-- `loremindmj_brain-data` — parametres IA (fournisseur courant, cle API
-  1min.ai).
-
-### Export SQL de la base
-
-```
-docker compose exec postgres pg_dump -U loremind loremind > backup.sql
-```
-
-### Sauvegarde complete des volumes
-
-Arreter la stack au prealable afin de garantir la coherence des donnees :
-
-```
-docker compose stop
-docker run --rm -v loremindmj_postgres-data:/data -v $(pwd):/backup alpine tar czf /backup/postgres-data.tar.gz -C /data .
-docker run --rm -v loremindmj_minio-data:/data -v $(pwd):/backup alpine tar czf /backup/minio-data.tar.gz -C /data .
-docker compose start
-```
-
-Sous Windows PowerShell, remplacer `$(pwd)` par `${PWD}`.
-
-## 8. Resolution des problemes
-
-### Port 8081 deja utilise
-
-Modifier `WEB_PORT=8082` (ou toute autre valeur libre) dans `.env`, puis
-relancer :
-
-```
-docker compose up -d
-```
-
-### Erreur "set POSTGRES_PASSWORD in .env" (ou variable equivalente) au lancement
-
-Une des trois variables obligatoires de l'etape 3 est manquante. Verifier le
-contenu du fichier `.env`.
-
-### Popup "Ce site vous demande de vous connecter" sur l'ecran Parametres
-
-Comportement attendu : il s'agit de l'authentification HTTP Basic. Utiliser
-la valeur de `ADMIN_USERNAME` (par defaut `admin`) et celle de
-`ADMIN_PASSWORD`.
-
-### Erreurs `password authentication failed` en boucle dans les logs Postgres
-
-Si la variable `POSTGRES_PASSWORD` a ete modifiee apres un premier lancement,
-le volume Postgres conserve l'ancien mot de passe (initialise une seule fois).
-Deux options :
-
-- **Redemarrer avec un volume vierge** (entraine la perte des donnees) :
-  ```
-  docker compose down -v
-  docker compose up -d
-  ```
-- **Modifier le mot de passe en base** sans toucher au volume :
-  ```
-  docker compose exec postgres psql -U postgres
-  ```
-  Puis dans le prompt `psql` :
-  ```sql
-  ALTER USER loremind WITH PASSWORD 'valeur_exacte_du_env';
-  \q
-  ```
-  Redemarrer ensuite le Core : `docker compose restart core`.
-
-### Erreur "502 Bad Gateway" ou message d'erreur IA dans l'interface
-
-Le service Brain ne parvient pas a contacter le fournisseur LLM. Verifier :
-
-- **Ollama** : `ollama serve` est-il actif ? Le modele est-il telecharge
-  (`ollama list`) ? La valeur de `LLM_MODEL` correspond-elle exactement au
-  nom d'un modele liste ?
-- **1min.ai** : la cle API est-elle valide ? Le modele existe-t-il ?
-- Consulter les logs du Brain :
-  ```
-  docker compose logs brain
-  ```
-
-### Un service ne demarre pas ou reste en etat `unhealthy`
-
-Consulter les logs du service concerne :
-
-```
-docker compose logs <service>
-```
-
-Services disponibles : `postgres`, `minio`, `core`, `brain`, `web`.
-
-### Redemarrage d'un service apres modification du `.env`
-
-```
-docker compose up -d <service>
-```
-
-Redemarrage complet : `docker compose restart`.
-
-### Remise a zero complete (PERTE DES DONNEES)
-
-```
-docker compose down -v
-```
-
-L'option `-v` supprime les volumes. L'ensemble des lores, campagnes, images
-et parametres est perdu de maniere definitive.
-
-### "No such image" ou "pull access denied" au premier lancement
-
-Le registry Gitea peut necessiter une authentification selon la visibilite
-configuree pour les images. Contacter l'editeur du projet.
-
-## 9. Exposition reseau des services
-
-- **Interface web** : http://localhost:8081 (port configurable via
-  `WEB_PORT`).
-- **PostgreSQL** : accessible uniquement via le reseau Docker interne, non
-  expose vers l'hote.
-- **MinIO** : accessible uniquement via le reseau Docker interne. Les images
-  transitent par le reverse-proxy Java sur `/api/images/{id}/content`. Le
-  binding `127.0.0.1:9000/9001` defini dans `docker-compose.override.yml`
-  n'est actif qu'en developpement.
-- **Brain Python** : accessible uniquement via le reseau Docker interne.
-  Toute requete doit porter l'en-tete `X-Internal-Secret`, injectee
-  automatiquement par le Core Java et jamais exposee au navigateur.
-
-## 10. Desinstallation
-
-```
-docker compose down -v
-docker image rm git.igmlcreation.fr/ietm64/core git.igmlcreation.fr/ietm64/brain git.igmlcreation.fr/ietm64/web
-```
-
-Supprimer ensuite le dossier contenant `docker-compose.yml` et `.env`.

README.md

@@ -1,69 +1,31 @@
 # LoreMind
 
-Application web d'aide aux Maîtres de Jeu (JDR) pour centraliser la gestion de l'univers (Lore) et le suivi des campagnes, avec un moteur IA intégré pour générer du contenu structuré.
+![Tableau de bord](https://raw.githubusercontent.com/IGMLcreation/loremind-docs/main/static/img/screenshots/dashboard.png)
+
+Loremind est une application web angular auto-hébergable afin de venir en aide aux Maîtres de jeu qui souhaitent centraliser leur univers et leurs campagnes.
+Cette dernière intègre un moteur IA qui va ingérer le contenu du lore et de la campagne afin de pouvoir répondre à des questions précises sur l'univers ou la campagne, mais également proposer des idées de création dans le contexte de la campagne et du lore.
+Pour le moment seul Ollama est supporté pour la partie locale, il y-a également une intégration pour 1min.ai. Plus tard, d'autres moteurs seront supportés.
+
+## Documentation
+
+La documentation complète est accessible sur le site [loremind-docs](https://loremind-docs.igmlcreation.fr/)
+
+Pour l'installation, consultez le guide dans cette dernière .
 
 ## Fonctionnalités
 
 - Gestion centralisée du Lore : Lieux, Factions, PNJ, et tous les éléments de votre univers
 - Suivi de campagnes : Sessions, actions des joueurs, chronologie
 - Moteur IA intégré : Génération automatique de contenu (PNJ, Villes, Quêtes) à partir de templates
-- Export vers FoundryVTT : Transfert structuré des données vers votre VTT préféré (en développement)
 
-## Captures d'écran
+## Démo
 
-### Page d'accueil
+Une démo est disponible sur le site [loremind-demo](https://loremind-demo.igmlcreation.fr/)
-![Accueil](docs/maquettes/général/Accueil.png)
 
-### Recherche
+!! Attention, la démo est uniquement accessible à 10 personnes à la fois (instances personnalisées). Cette limite est mise en place pour éviter l'overhead sur les ressources serveur.
-![Recherche](docs/maquettes/général/Ecran de recherche.png)
 
-## Stack Technologique
+Cette dernière est utilisable 20 minutes maximum par session avant d'être réinitialiser.
-
+Vous comprendrez également qu'elle ne contient pas de démo pour la partie IA, pour laquelle il faut configurer un serveur Ollama (et qui ferait donc exploser le serveur) ou utiliser 1min.ai.
-LoreMind utilise une architecture distribuée pour séparer les responsabilités :
-
-- **Frontend** : Angular (Interface utilisateur, affichage du lore, formulaires de templates)
-- **Backend Core** : Java (Spring Boot) - Orchestration, persistance, export VTT
-- **Backend IA** : Python - Traitement des LLM et génération de contenu
-- **Base de données** : PostgreSQL avec JSONB pour les templates flexibles
-
-## Architecture
-
-### Backend Java (Domain-Driven Design & Hexagonal)
-
-Le Backend Core respecte strictement :
-- **Domain-Driven Design (DDD)** : Séparation en Bounded Contexts autonomes
-- **Architecture Hexagonale (Ports et Adaptateurs)** : Domaine pur sans dépendances techniques
-
-#### Bounded Contexts
-- **LoreContext** : Gestion de l'encyclopédie de l'univers
-- **CampaignContext** : Suivi des sessions et chronologie
-- **GenerationContext** : Gestion des requêtes IA et templates
-
-#### Couches
-- **Domaine (Core)** : Entités métier pures et interfaces (Ports)
-- **Application** : Orchestration des flux (Use Cases)
-- **Infrastructure** : Implémentation technique (Adapters)
-
-## Installation
-
-Pour installer LoreMind chez vous (Docker requis), suivez le guide **[INSTALL.md](INSTALL.md)** — 3 étapes, 5 minutes chrono :
-
-1. Télécharger `docker-compose.yml` + `.env.example` depuis la [dernière release](https://git.igmlcreation.fr/ietm64/LoreMindMJ/releases)
-2. Renommer `.env.example` → `.env` et changer `POSTGRES_PASSWORD`
-3. `docker compose up -d` → ouvrir http://localhost:8081
-
-Mise à jour : `docker compose pull && docker compose up -d`.
-
-## Développement (contributeurs)
-
-Pour builder les images localement depuis les sources :
-
-```bash
-git clone https://git.igmlcreation.fr/ietm64/LoreMindMJ.git
-cd LoreMindMJ
-# Créer un docker-compose.override.yml local (voir docs de contrib)
-docker compose up -d --build
-```
 
 ## License
 

brain/app/application/chat.py

@@ -21,6 +21,7 @@ from app.domain.models import (
     ChatMessage,
     ChapterSummary,
     CharacterSummary,
+    NpcSummary,
     GameSystemContext,
     LoreStructuralContext,
     NarrativeEntityContext,
@@ -198,10 +199,12 @@ class ChatUseCase:
             else "\n(Cette campagne n'est associée à aucun univers — tu peux proposer des éléments d'ambiance libres.)"
         )
         characters_block = ChatUseCase._format_characters(ctx.characters)
+        npcs_block = ChatUseCase._format_npcs(ctx.npcs)
         return (
             "--- CAMPAGNE COURANTE ---\n"
             f"Nom : {ctx.campaign_name}{desc}{lore_note}\n"
-            f"{characters_block}\n"
+            f"{characters_block}"
+            f"{npcs_block}\n"
             "Structure narrative (les flèches → indiquent des transitions de scène "
             "déclenchées par un choix des joueurs) :\n"
             f"{arcs_block}"
@@ -231,6 +234,33 @@ class ChatUseCase:
         )
         return "\n".join(lines) + "\n"
 
+    @staticmethod
+    def _format_npcs(npcs: list[NpcSummary]) -> str:
+        """Bloc PNJ — symétrique aux PJ avec sa propre instruction anti-halluci.
+
+        Distinction importante : pour les PNJ, l'IA est ENCOURAGÉE à proposer de
+        nouveaux PNJ (création créative = OK). En revanche, elle ne doit pas
+        référencer comme existant un PNJ qui n'est pas dans la liste ci-dessous.
+        """
+        if not npcs:
+            return (
+                "\nPersonnages non-joueurs (PNJ) : aucun défini pour l'instant. "
+                "Tu peux librement proposer de nouveaux PNJ au MJ, mais ne "
+                "fais pas comme s'ils existaient déjà dans la campagne.\n"
+            )
+        lines = ["\nPersonnages non-joueurs (PNJ) connus :"]
+        for n in npcs:
+            if n.snippet:
+                lines.append(f"- **{n.name}** — {n.snippet}")
+            else:
+                lines.append(f"- **{n.name}** (fiche vide)")
+        lines.append(
+            "Pour une fiche complète d'un PNJ existant (apparence, motivations), "
+            "n'invente rien : demande au MJ d'ouvrir l'éditeur du PNJ. Tu peux "
+            "en revanche proposer librement de NOUVEAUX PNJ."
+        )
+        return "\n".join(lines) + "\n"
+
     @staticmethod
     def _format_arcs(arcs: list[ArcSummary]) -> str:
         if not arcs:
@@ -319,7 +349,8 @@ class ChatUseCase:
             "arc": "ARC",
             "chapter": "CHAPITRE",
             "scene": "SCÈNE",
-            "character": "FICHE DE PERSONNAGE",
+            "character": "FICHE DE PERSONNAGE (PJ)",
+            "npc": "FICHE DE PNJ",
         }.get(ne.entity_type.lower(), ne.entity_type.upper())
         if ne.fields:
             fields_block = "\n".join(

brain/app/domain/models.py

@@ -170,6 +170,7 @@ class CampaignStructuralContext:
     campaign_description: str | None
     arcs: list[ArcSummary]
     characters: list["CharacterSummary"] = field(default_factory=list)
+    npcs: list["NpcSummary"] = field(default_factory=list)
 
 
 @dataclass(frozen=True)
@@ -185,6 +186,19 @@ class CharacterSummary:
     snippet: str
 
 
+@dataclass(frozen=True)
+class NpcSummary:
+    """Résumé d'un PNJ : symétrique à CharacterSummary.
+
+    Permet à l'IA de connaître les PNJ d'une campagne (nom + snippet) sans
+    injecter leurs fiches complètes. Évolution prévue : entity_type="npc"
+    pour focus sur la fiche complète.
+    """
+
+    name: str
+    snippet: str
+
+
 @dataclass(frozen=True)
 class NarrativeEntityContext:
     """Contexte d'une entité narrative précise en cours d'édition.

brain/app/infrastructure/ollama_adapter.py

@@ -61,7 +61,16 @@ class OllamaLLMProvider:
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:
                 response = await client.post(url, json=payload)
-                response.raise_for_status()
+                if response.status_code >= 400:
+                    body = response.text
+                    try:
+                        err_obj = json.loads(body)
+                        err_msg = err_obj.get("error") or body
+                    except json.JSONDecodeError:
+                        err_msg = body
+                    raise LLMProviderError(
+                        f"Ollama HTTP {response.status_code} : {err_msg.strip()[:500]}"
+                    )
             except httpx.HTTPError as exc:
                 raise LLMProviderError(
                     f"Erreur lors de l'appel à Ollama : {exc}"
@@ -105,7 +114,20 @@ class OllamaLLMProvider:
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:
                 async with client.stream("POST", url, json=payload) as response:
-                    response.raise_for_status()
+                    if response.status_code >= 400:
+                        # On lit le body d'erreur pour le remonter a l'utilisateur,
+                        # sinon on ne voit que "500 Internal Server Error" sans
+                        # savoir POURQUOI Ollama refuse (modele introuvable, OOM,
+                        # num_ctx trop grand pour la VRAM, etc.).
+                        body = (await response.aread()).decode("utf-8", errors="replace")
+                        try:
+                            err_obj = json.loads(body)
+                            err_msg = err_obj.get("error") or body
+                        except json.JSONDecodeError:
+                            err_msg = body
+                        raise LLMProviderError(
+                            f"Ollama HTTP {response.status_code} : {err_msg.strip()[:500]}"
+                        )
                     async for line in response.aiter_lines():
                         if not line.strip():
                             continue

brain/app/main.py

@@ -23,6 +23,7 @@ from app.domain.models import (
     CampaignStructuralContext,
     ChapterSummary,
     CharacterSummary,
+    NpcSummary,
     ChatMessage,
     GameSystemContext,
     LoreStructuralContext,
@@ -40,7 +41,7 @@ from app.infrastructure.onemin_adapter import OneMinAiLLMProvider
 app = FastAPI(
     title="LoreMind Brain",
     description="Backend IA pour la génération de contenu narratif.",
-    version="0.5.0",
+    version="0.6.6",
 )
 
 
@@ -205,6 +206,13 @@ class CharacterSummaryDTO(BaseModel):
     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."""
 
@@ -212,12 +220,13 @@ class CampaignContextDTO(BaseModel):
     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)$")
+    entity_type: str = Field(pattern="^(arc|chapter|scene|character|npc)$")
     title: str
     fields: dict[str, str] = Field(default_factory=dict)
 
@@ -553,11 +562,16 @@ def _to_campaign_context(dto: CampaignContextDTO | None) -> CampaignStructuralCo
         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,
     )
 
 
@@ -689,6 +703,76 @@ async def get_ollama_model_info(
     return OllamaModelInfoDTO(context_length=0)
 
 
+@app.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")
+
+
+@app.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}
+
+
 @app.get("/models/onemin")
 def list_onemin_models() -> dict[str, list[dict[str, object]]]:
     """Catalogue statique des modeles 1min.ai, groupes par fournisseur.

core/pom.xml

@@ -14,7 +14,7 @@
 
     <groupId>com.loremind</groupId>
     <artifactId>loremind-core</artifactId>
-    <version>0.5.0</version>
+    <version>0.8.1</version>
     <name>LoreMind Core</name>
     <description>Backend Core - Architecture Hexagonale</description>
 
@@ -83,6 +83,19 @@
             <artifactId>minio</artifactId>
             <version>8.5.11</version>
         </dependency>
+
+        <!-- Nimbus JOSE+JWT — verification des JWT Ed25519 (EdDSA) emis par le relais
+             Patreon. Supporte nativement les cles Ed25519 via BouncyCastle. -->
+        <dependency>
+            <groupId>com.nimbusds</groupId>
+            <artifactId>nimbus-jose-jwt</artifactId>
+            <version>9.40</version>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+            <version>1.78.1</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -98,6 +111,16 @@
                         </exclude>
                     </excludes>
                 </configuration>
+                <executions>
+                    <!-- Genere META-INF/build-info.properties (project.version)
+                         consomme par Spring BuildProperties pour exposer la
+                         version courante a l'application (UpdateCheckService). -->
+                    <execution>
+                        <goals>
+                            <goal>build-info</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
 
             <!-- JaCoCo : rapport de couverture des tests unitaires.

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

@@ -2,12 +2,14 @@ package com.loremind;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 /**
  * Classe principale de l'application LoreMind.
  * Point d'entrée Spring Boot qui démarre l'application.
  */
 @SpringBootApplication
+@EnableScheduling
 public class LoreMindApplication {
 
     public static void main(String[] args) {

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

@@ -1,9 +1,13 @@
 package com.loremind.application.campaigncontext;
 
 import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Optional;
@@ -17,17 +21,31 @@ import java.util.Optional;
 public class ArcService {
 
     private final ArcRepository arcRepository;
+    private final ChapterRepository chapterRepository;
+    private final SceneRepository sceneRepository;
 
-    public ArcService(ArcRepository arcRepository) {
+    public ArcService(ArcRepository arcRepository,
+                      ChapterRepository chapterRepository,
+                      SceneRepository sceneRepository) {
         this.arcRepository = arcRepository;
+        this.chapterRepository = chapterRepository;
+        this.sceneRepository = sceneRepository;
     }
 
+    /** Compte des entités qui seront supprimées en cascade avec l'arc. */
+    public record DeletionImpact(int chapters, int scenes) {}
+
     public Arc createArc(String name, String description, String campaignId, int order) {
+        return createArc(name, description, campaignId, order, null);
+    }
+
+    public Arc createArc(String name, String description, String campaignId, int order, String icon) {
         Arc arc = Arc.builder()
                 .name(name)
                 .description(description)
                 .campaignId(campaignId)
                 .order(order)
+                .icon(icon)
                 .build();
         return arcRepository.save(arc);
     }
@@ -59,7 +77,31 @@ public class ArcService {
         return arcRepository.save(arc);
     }
 
+    /**
+     * Calcule l'impact d'une suppression en cascade : chapitres + scènes
+     * qui disparaîtront avec l'arc.
+     */
+    public DeletionImpact getDeletionImpact(String id) {
+        List<Chapter> chapters = chapterRepository.findByArcId(id);
+        int sceneTotal = 0;
+        for (Chapter chapter : chapters) {
+            sceneTotal += sceneRepository.findByChapterId(chapter.getId()).size();
+        }
+        return new DeletionImpact(chapters.size(), sceneTotal);
+    }
+
+    /**
+     * Supprime l'arc et toutes ses entités dépendantes (chapitres → scènes).
+     * Transactionnel : atomique.
+     */
+    @Transactional
     public void deleteArc(String id) {
+        for (Chapter chapter : chapterRepository.findByArcId(id)) {
+            for (var scene : sceneRepository.findByChapterId(chapter.getId())) {
+                sceneRepository.deleteById(scene.getId());
+            }
+            chapterRepository.deleteById(chapter.getId());
+        }
         arcRepository.deleteById(id);
     }
 

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

@@ -1,8 +1,15 @@
 package com.loremind.application.campaigncontext;
 
+import com.loremind.domain.campaigncontext.Arc;
 import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Optional;
@@ -16,9 +23,22 @@ import java.util.Optional;
 public class CampaignService {
 
     private final CampaignRepository campaignRepository;
+    private final ArcRepository arcRepository;
+    private final ChapterRepository chapterRepository;
+    private final SceneRepository sceneRepository;
+    private final CharacterRepository characterRepository;
 
-    public CampaignService(CampaignRepository campaignRepository) {
+    public CampaignService(
+            CampaignRepository campaignRepository,
+            ArcRepository arcRepository,
+            ChapterRepository chapterRepository,
+            SceneRepository sceneRepository,
+            CharacterRepository characterRepository) {
         this.campaignRepository = campaignRepository;
+        this.arcRepository = arcRepository;
+        this.chapterRepository = chapterRepository;
+        this.sceneRepository = sceneRepository;
+        this.characterRepository = characterRepository;
     }
 
     /**
@@ -30,6 +50,12 @@ public class CampaignService {
      */
     public record CampaignData(String name, String description, String loreId, String gameSystemId) {}
 
+    /**
+     * Compte des entités qui seront supprimées en cascade si la campagne est effacée.
+     * Utilisé par l'UI pour afficher un récapitulatif dans le dialogue de confirmation.
+     */
+    public record DeletionImpact(int arcs, int chapters, int scenes, int characters) {}
+
     public Campaign createCampaign(CampaignData data) {
         Campaign campaign = Campaign.builder()
                 .name(data.name())
@@ -71,7 +97,48 @@ public class CampaignService {
         return (id == null || id.isBlank()) ? null : id;
     }
 
+    /**
+     * Calcule l'impact d'une suppression en cascade : nombre d'arcs, chapitres,
+     * scènes et personnages qui disparaîtront avec la campagne. Utilisé par l'UI
+     * pour afficher "X arcs, Y chapitres, Z scènes seront supprimés".
+     */
+    public DeletionImpact getDeletionImpact(String id) {
+        List<Arc> arcs = arcRepository.findByCampaignId(id);
+        int chapterTotal = 0;
+        int sceneTotal = 0;
+        for (Arc arc : arcs) {
+            List<Chapter> chapters = chapterRepository.findByArcId(arc.getId());
+            chapterTotal += chapters.size();
+            for (Chapter chapter : chapters) {
+                sceneTotal += sceneRepository.findByChapterId(chapter.getId()).size();
+            }
+        }
+        int characterTotal = characterRepository.findByCampaignId(id).size();
+        return new DeletionImpact(arcs.size(), chapterTotal, sceneTotal, characterTotal);
+    }
+
+    /**
+     * Supprime la campagne et toutes ses entités dépendantes (arcs → chapitres →
+     * scènes, plus les personnages). L'opération est transactionnelle : soit
+     * tout disparaît, soit rien ne change. Les FKs applicatives n'ayant pas
+     * de contrainte CASCADE au niveau DB, on orchestre la cascade ici.
+     */
+    @Transactional
     public void deleteCampaign(String id) {
+        List<Arc> arcs = arcRepository.findByCampaignId(id);
+        for (Arc arc : arcs) {
+            List<Chapter> chapters = chapterRepository.findByArcId(arc.getId());
+            for (Chapter chapter : chapters) {
+                for (var scene : sceneRepository.findByChapterId(chapter.getId())) {
+                    sceneRepository.deleteById(scene.getId());
+                }
+                chapterRepository.deleteById(chapter.getId());
+            }
+            arcRepository.deleteById(arc.getId());
+        }
+        for (var character : characterRepository.findByCampaignId(id)) {
+            characterRepository.deleteById(character.getId());
+        }
         campaignRepository.deleteById(id);
     }
 

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

@@ -2,8 +2,10 @@ package com.loremind.application.campaigncontext;
 
 import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Optional;
@@ -17,17 +19,27 @@ import java.util.Optional;
 public class ChapterService {
 
     private final ChapterRepository chapterRepository;
+    private final SceneRepository sceneRepository;
 
-    public ChapterService(ChapterRepository chapterRepository) {
+    public ChapterService(ChapterRepository chapterRepository, SceneRepository sceneRepository) {
         this.chapterRepository = chapterRepository;
+        this.sceneRepository = sceneRepository;
     }
 
+    /** Compte des scènes qui seront supprimées en cascade avec le chapitre. */
+    public record DeletionImpact(int scenes) {}
+
     public Chapter createChapter(String name, String description, String arcId, int order) {
+        return createChapter(name, description, arcId, order, null);
+    }
+
+    public Chapter createChapter(String name, String description, String arcId, int order, String icon) {
         Chapter chapter = Chapter.builder()
                 .name(name)
                 .description(description)
                 .arcId(arcId)
                 .order(order)
+                .icon(icon)
                 .build();
         return chapterRepository.save(chapter);
     }
@@ -58,7 +70,17 @@ public class ChapterService {
         return chapterRepository.save(chapter);
     }
 
+    /** Compte des scènes qui tomberont avec le chapitre. */
+    public DeletionImpact getDeletionImpact(String id) {
+        return new DeletionImpact(sceneRepository.findByChapterId(id).size());
+    }
+
+    /** Supprime le chapitre et toutes ses scènes. Transactionnel : atomique. */
+    @Transactional
     public void deleteChapter(String id) {
+        for (var scene : sceneRepository.findByChapterId(id)) {
+            sceneRepository.deleteById(scene.getId());
+        }
         chapterRepository.deleteById(id);
     }
 

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

@@ -0,0 +1,71 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour les fiches de PNJ (campagne).
+ */
+@Service
+public class NpcService {
+
+    private final NpcRepository npcRepository;
+
+    public NpcService(NpcRepository npcRepository) {
+        this.npcRepository = npcRepository;
+    }
+
+    /**
+     * Parameter Object pour la création / mise à jour d'un Npc.
+     * `order` est fourni par le controller ; si absent, le service le calcule.
+     */
+    public record NpcData(String name, String markdownContent, String campaignId, Integer order) {}
+
+    public Npc createNpc(NpcData data) {
+        int order = data.order() != null
+                ? data.order()
+                : nextOrderFor(data.campaignId());
+        Npc npc = Npc.builder()
+                .name(data.name())
+                .markdownContent(data.markdownContent())
+                .campaignId(data.campaignId())
+                .order(order)
+                .build();
+        return npcRepository.save(npc);
+    }
+
+    public Optional<Npc> getNpcById(String id) {
+        return npcRepository.findById(id);
+    }
+
+    public List<Npc> getNpcsByCampaignId(String campaignId) {
+        return npcRepository.findByCampaignId(campaignId);
+    }
+
+    public Npc updateNpc(String id, NpcData data) {
+        Npc existing = npcRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Npc non trouvé avec l'ID: " + id));
+        existing.setName(data.name());
+        existing.setMarkdownContent(data.markdownContent());
+        if (data.order() != null) {
+            existing.setOrder(data.order());
+        }
+        return npcRepository.save(existing);
+    }
+
+    public void deleteNpc(String id) {
+        npcRepository.deleteById(id);
+    }
+
+    /** Renvoie la prochaine position libre — append en fin de liste. */
+    private int nextOrderFor(String campaignId) {
+        return npcRepository.findByCampaignId(campaignId).stream()
+                .mapToInt(Npc::getOrder)
+                .max()
+                .orElse(-1) + 1;
+    }
+}

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

@@ -26,11 +26,16 @@ public class SceneService {
     }
 
     public Scene createScene(String name, String description, String chapterId, int order) {
+        return createScene(name, description, chapterId, order, null);
+    }
+
+    public Scene createScene(String name, String description, String chapterId, int order, String icon) {
         Scene scene = Scene.builder()
                 .name(name)
                 .description(description)
                 .chapterId(chapterId)
                 .order(order)
+                .icon(icon)
                 .build();
         return sceneRepository.save(scene);
     }
@@ -93,7 +98,7 @@ public class SceneService {
                 .collect(Collectors.toSet());
 
         for (SceneBranch b : branches) {
-            String target = b.getTargetSceneId();
+            String target = b.targetSceneId();
             if (target == null || target.isBlank()) {
                 throw new IllegalArgumentException("Une branche doit avoir une scène de destination");
             }

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

@@ -45,11 +45,7 @@ public class GameSystemContextBuilder {
     private GameSystemContext build(GameSystem gs, GenerationIntent intent) {
         Map<String, String> allSections = parseH2Sections(gs.getRulesMarkdown());
         Map<String, String> filtered = filterByIntent(allSections, intent);
-        return GameSystemContext.builder()
+        return new GameSystemContext(gs.getName(), gs.getDescription(), filtered);
-                .systemName(gs.getName())
-                .systemDescription(gs.getDescription())
-                .sections(filtered)
-                .build();
     }
 
     /**

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

@@ -4,17 +4,20 @@ import com.loremind.domain.campaigncontext.Arc;
 import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.domain.campaigncontext.Character;
+import com.loremind.domain.campaigncontext.Npc;
 import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
 import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import com.loremind.domain.generationcontext.CampaignStructuralContext;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.ArcSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.BranchHint;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.ChapterSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.CharacterSummary;
+import com.loremind.domain.generationcontext.CampaignStructuralContext.NpcSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.SceneSummary;
 import org.springframework.stereotype.Component;
 
@@ -42,21 +45,24 @@ public class CampaignStructuralContextBuilder {
     private final ChapterRepository chapterRepository;
     private final SceneRepository sceneRepository;
     private final CharacterRepository characterRepository;
+    private final NpcRepository npcRepository;
 
     public CampaignStructuralContextBuilder(
             CampaignRepository campaignRepository,
             ArcRepository arcRepository,
             ChapterRepository chapterRepository,
             SceneRepository sceneRepository,
-            CharacterRepository characterRepository) {
+            CharacterRepository characterRepository,
+            NpcRepository npcRepository) {
         this.campaignRepository = campaignRepository;
         this.arcRepository = arcRepository;
         this.chapterRepository = chapterRepository;
         this.sceneRepository = sceneRepository;
         this.characterRepository = characterRepository;
+        this.npcRepository = npcRepository;
     }
 
-    /** Longueur max du snippet de PJ injecté dans le contexte (coût tokens maîtrisé). */
+    /** Longueur max du snippet de PJ/PNJ injecté dans le contexte (coût tokens maîtrisé). */
     private static final int CHARACTER_SNIPPET_MAX_LEN = 160;
 
     /**
@@ -79,12 +85,17 @@ public class CampaignStructuralContextBuilder {
                 .map(this::toCharacterSummary)
                 .collect(Collectors.toList());
 
-        return CampaignStructuralContext.builder()
+        List<NpcSummary> npcs = npcRepository.findByCampaignId(campaignId).stream()
-                .campaignName(campaign.getName())
+                .sorted(Comparator.comparingInt(Npc::getOrder))
-                .campaignDescription(campaign.getDescription())
+                .map(this::toNpcSummary)
-                .arcs(arcs)
+                .collect(Collectors.toList());
-                .characters(characters)
+
-                .build();
+        return new CampaignStructuralContext(
+                campaign.getName(),
+                campaign.getDescription(),
+                arcs,
+                characters,
+                npcs);
     }
 
     /**
@@ -93,10 +104,12 @@ public class CampaignStructuralContextBuilder {
      * sans injecter toute sa fiche.
      */
     private CharacterSummary toCharacterSummary(Character c) {
-        return CharacterSummary.builder()
+        return new CharacterSummary(c.getName(), extractSnippet(c.getMarkdownContent()));
-                .name(c.getName())
+    }
-                .snippet(extractSnippet(c.getMarkdownContent()))
+
-                .build();
+    /** Symétrique à {@link #toCharacterSummary} pour les PNJ. */
+    private NpcSummary toNpcSummary(Npc n) {
+        return new NpcSummary(n.getName(), extractSnippet(n.getMarkdownContent()));
     }
 
     private static String extractSnippet(String markdown) {
@@ -115,12 +128,11 @@ public class CampaignStructuralContextBuilder {
                 .sorted(Comparator.comparingInt(Chapter::getOrder))
                 .map(this::toChapterSummary)
                 .collect(Collectors.toList());
-        return ArcSummary.builder()
+        return new ArcSummary(
-                .name(arc.getName())
+                arc.getName(),
-                .description(arc.getDescription())
+                arc.getDescription(),
-                .illustrationCount(countImages(arc.getIllustrationImageIds()))
+                countImages(arc.getIllustrationImageIds()),
-                .chapters(chapters)
+                chapters);
-                .build();
     }
 
     private ChapterSummary toChapterSummary(Chapter chapter) {
@@ -137,32 +149,28 @@ public class CampaignStructuralContextBuilder {
                 .map(s -> toSceneSummary(s, nameById))
                 .collect(Collectors.toList());
 
-        return ChapterSummary.builder()
+        return new ChapterSummary(
-                .name(chapter.getName())
+                chapter.getName(),
-                .description(chapter.getDescription())
+                chapter.getDescription(),
-                .illustrationCount(countImages(chapter.getIllustrationImageIds()))
+                countImages(chapter.getIllustrationImageIds()),
-                .scenes(summaries)
+                summaries);
-                .build();
     }
 
     private SceneSummary toSceneSummary(Scene scene, Map<String, String> nameById) {
         List<BranchHint> hints = scene.getBranches() == null
                 ? List.of()
                 : scene.getBranches().stream()
-                    .map(b -> BranchHint.builder()
+                    .map(b -> new BranchHint(
-                            .label(b.getLabel())
+                            b.label(),
-                            .targetSceneName(nameById.getOrDefault(
+                            nameById.getOrDefault(b.targetSceneId(), "(scène inconnue)"),
-                                    b.getTargetSceneId(), "(scène inconnue)"))
+                            b.condition()))
-                            .condition(b.getCondition())
-                            .build())
                     .collect(Collectors.toList());
 
-        return SceneSummary.builder()
+        return new SceneSummary(
-                .name(scene.getName())
+                scene.getName(),
-                .description(scene.getDescription())
+                scene.getDescription(),
-                .illustrationCount(countImages(scene.getIllustrationImageIds()))
+                countImages(scene.getIllustrationImageIds()),
-                .branches(hints)
+                hints);
-                .build();
     }
 
     /** Helper defensif : compte les illustrations attachees (null-safe). */

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

@@ -67,16 +67,15 @@ public class GeneratePageValuesUseCase {
 
         requireNonEmptyFields(template);
 
-        GenerationContext context = GenerationContext.builder()
-                .loreName(lore.getName())
-                .loreDescription(lore.getDescription())
-                .folderName(folder.getName())
-                .templateName(template.getName())
         // Seuls les champs TEXT sont envoyes a l'IA : les champs IMAGE
         // necessitent un workflow different (pas de generation LLM texte).
-                .templateFields(template.textFieldNames())
+        GenerationContext context = new GenerationContext(
-                .pageTitle(page.getTitle())
+                lore.getName(),
-                .build();
+                lore.getDescription(),
+                folder.getName(),
+                template.getName(),
+                template.textFieldNames(),
+                page.getTitle());
 
         GenerationResult result = aiProvider.generatePage(context);
         return result.values();

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

@@ -82,12 +82,11 @@ public class LoreStructuralContextBuilder {
         Map<String, String> pageTitleById = pages.stream()
                 .collect(Collectors.toMap(Page::getId, Page::getTitle, (a, b) -> a));
 
-        return LoreStructuralContext.builder()
+        return new LoreStructuralContext(
-                .loreName(lore.getName())
+                lore.getName(),
-                .loreDescription(lore.getDescription())
+                lore.getDescription(),
-                .folders(buildFoldersMap(nodes, pages, templateNameById, pageTitleById))
+                buildFoldersMap(nodes, pages, templateNameById, pageTitleById),
-                .tags(extractUniqueTags(pages))
+                extractUniqueTags(pages));
-                .build();
     }
 
     private Map<String, List<PageSummary>> buildFoldersMap(
@@ -118,13 +117,12 @@ public class LoreStructuralContextBuilder {
             Page page,
             Map<String, String> templateNameById,
             Map<String, String> pageTitleById) {
-        return PageSummary.builder()
+        return new PageSummary(
-                .title(page.getTitle())
+                page.getTitle(),
-                .templateName(templateNameById.getOrDefault(page.getTemplateId(), "?"))
+                templateNameById.getOrDefault(page.getTemplateId(), "?"),
-                .values(truncatedValues(page.getValues()))
+                truncatedValues(page.getValues()),
-                .tags(page.getTags() != null ? List.copyOf(page.getTags()) : Collections.emptyList())
+                page.getTags() != null ? List.copyOf(page.getTags()) : Collections.emptyList(),
-                .relatedPageTitles(resolveRelatedTitles(page.getRelatedPageIds(), pageTitleById))
+                resolveRelatedTitles(page.getRelatedPageIds(), pageTitleById));
-                .build();
     }
 
     /**

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

@@ -3,10 +3,12 @@ package com.loremind.application.generationcontext;
 import com.loremind.domain.campaigncontext.Arc;
 import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.domain.campaigncontext.Character;
+import com.loremind.domain.campaigncontext.Npc;
 import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
 import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import com.loremind.domain.generationcontext.NarrativeEntityContext;
 import org.springframework.stereotype.Component;
@@ -29,22 +31,25 @@ public class NarrativeEntityContextBuilder {
     private final ChapterRepository chapterRepository;
     private final SceneRepository sceneRepository;
     private final CharacterRepository characterRepository;
+    private final NpcRepository npcRepository;
 
     public NarrativeEntityContextBuilder(
             ArcRepository arcRepository,
             ChapterRepository chapterRepository,
             SceneRepository sceneRepository,
-            CharacterRepository characterRepository) {
+            CharacterRepository characterRepository,
+            NpcRepository npcRepository) {
         this.arcRepository = arcRepository;
         this.chapterRepository = chapterRepository;
         this.sceneRepository = sceneRepository;
         this.characterRepository = characterRepository;
+        this.npcRepository = npcRepository;
     }
 
     /**
      * Charge l'entité narrative ciblée et la projette vers un VO du GenerationContext.
      *
-     * @param entityType "arc", "chapter", "scene" ou "character" (insensible à la casse)
+     * @param entityType "arc", "chapter", "scene", "character" ou "npc" (insensible à la casse)
      * @param entityId   l'ID de l'entité
      * @throws IllegalArgumentException si le type est inconnu ou l'entité introuvable
      */
@@ -55,6 +60,7 @@ public class NarrativeEntityContextBuilder {
             case "chapter" -> fromChapter(loadChapter(entityId));
             case "scene" -> fromScene(loadScene(entityId));
             case "character" -> fromCharacter(loadCharacter(entityId));
+            case "npc" -> fromNpc(loadNpc(entityId));
             default -> throw new IllegalArgumentException("Type d'entité narrative inconnu: " + entityType);
         };
     }
@@ -81,6 +87,11 @@ public class NarrativeEntityContextBuilder {
                 .orElseThrow(() -> new IllegalArgumentException("Personnage non trouvé: " + id));
     }
 
+    private Npc loadNpc(String id) {
+        return npcRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("PNJ non trouvé: " + id));
+    }
+
     // --- Mapping entité → VO ------------------------------------------------
 
     private NarrativeEntityContext fromArc(Arc a) {
@@ -91,11 +102,7 @@ public class NarrativeEntityContextBuilder {
         putField(fields, "rewards",    a.getRewards());
         putField(fields, "resolution", a.getResolution());
         putField(fields, "gmNotes",    a.getGmNotes());
-        return NarrativeEntityContext.builder()
+        return new NarrativeEntityContext("arc", a.getName(), fields);
-                .entityType("arc")
-                .title(a.getName())
-                .fields(fields)
-                .build();
     }
 
     private NarrativeEntityContext fromChapter(Chapter c) {
@@ -104,11 +111,7 @@ public class NarrativeEntityContextBuilder {
         putField(fields, "playerObjectives", c.getPlayerObjectives());
         putField(fields, "narrativeStakes", c.getNarrativeStakes());
         putField(fields, "gmNotes",          c.getGmNotes());
-        return NarrativeEntityContext.builder()
+        return new NarrativeEntityContext("chapter", c.getName(), fields);
-                .entityType("chapter")
-                .title(c.getName())
-                .fields(fields)
-                .build();
     }
 
     private NarrativeEntityContext fromScene(Scene s) {
@@ -122,21 +125,19 @@ public class NarrativeEntityContextBuilder {
         putField(fields, "combatDifficulty",     s.getCombatDifficulty());
         putField(fields, "enemies",              s.getEnemies());
         putField(fields, "gmSecretNotes",        s.getGmSecretNotes());
-        return NarrativeEntityContext.builder()
+        return new NarrativeEntityContext("scene", s.getName(), fields);
-                .entityType("scene")
-                .title(s.getName())
-                .fields(fields)
-                .build();
     }
 
     private NarrativeEntityContext fromCharacter(Character c) {
         Map<String, String> fields = new LinkedHashMap<>();
         putField(fields, "fiche complète (markdown)", c.getMarkdownContent());
-        return NarrativeEntityContext.builder()
+        return new NarrativeEntityContext("character", c.getName(), fields);
-                .entityType("character")
+    }
-                .title(c.getName())
+
-                .fields(fields)
+    private NarrativeEntityContext fromNpc(Npc n) {
-                .build();
+        Map<String, String> fields = new LinkedHashMap<>();
+        putField(fields, "fiche complète (markdown)", n.getMarkdownContent());
+        return new NarrativeEntityContext("npc", n.getName(), fields);
     }
 
     /** Null/blank devient chaîne vide — uniforme côté prompt, pas de NPE côté LLM. */

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

@@ -107,11 +107,6 @@ public class StreamChatForLoreUseCase {
                 ? page.getValues()
                 : Collections.emptyMap();
 
-        return PageContext.builder()
+        return new PageContext(page.getTitle(), templateName, templateFields, values);
-                .title(page.getTitle())
-                .templateName(templateName)
-                .templateFields(templateFields)
-                .values(values)
-                .build();
     }
 }

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

@@ -0,0 +1,261 @@
+package com.loremind.application.licensing;
+
+import com.loremind.domain.licensing.License;
+import com.loremind.domain.licensing.LicenseClaims;
+import com.loremind.domain.licensing.LicenseSnapshot;
+import com.loremind.domain.licensing.LicenseStatus;
+import com.loremind.domain.licensing.RegistryCredentials;
+import com.loremind.domain.licensing.ports.JwtVerifier;
+import com.loremind.domain.licensing.ports.LicenseRelay;
+import com.loremind.domain.licensing.ports.LicenseRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Service application pour la gestion de la licence Patreon.
+ * <p>
+ * Responsabilites :
+ * <ul>
+ *   <li>Installer un nouveau JWT recu du relais (apres OAuth utilisateur)</li>
+ *   <li>Calculer le {@link LicenseStatus} courant en respectant la grace period</li>
+ *   <li>Renouveler le JWT avant expiration en appelant le relais</li>
+ *   <li>Activer/desactiver le toggle "canal beta" cote utilisateur</li>
+ *   <li>Distribuer les credentials registry pour le pull beta</li>
+ * </ul>
+ */
+@Service
+public class LicenseService {
+
+    private static final Logger log = LoggerFactory.getLogger(LicenseService.class);
+
+    private final LicenseRepository repository;
+    private final JwtVerifier jwtVerifier;
+    private final LicenseRelay relay;
+    private final long gracePeriodSeconds;
+    private final long refreshBeforeExpirySeconds;
+
+    public LicenseService(
+            LicenseRepository repository,
+            JwtVerifier jwtVerifier,
+            LicenseRelay relay,
+            @Value("${licensing.grace-period-days:14}") int gracePeriodDays,
+            @Value("${licensing.refresh-before-expiry-days:2}") int refreshBeforeExpiryDays) {
+        this.repository = repository;
+        this.jwtVerifier = jwtVerifier;
+        this.relay = relay;
+        this.gracePeriodSeconds = (long) gracePeriodDays * 86_400L;
+        this.refreshBeforeExpirySeconds = (long) refreshBeforeExpiryDays * 86_400L;
+    }
+
+    /**
+     * @return true si le verifier est configure (cle publique presente).
+     *         L'UI peut masquer toute la section Patreon si false.
+     */
+    public boolean isLicensingEnabled() {
+        return jwtVerifier.isConfigured();
+    }
+
+    /**
+     * Genere ou retourne l'instance_id stable de cette installation.
+     * Stocke dans la licence elle-meme. Si pas de licence, en cree un volatil
+     * (sera persiste a la prochaine connexion).
+     */
+    public String getOrCreateInstanceId() {
+        return repository.findCurrent()
+                .map(License::getInstanceId)
+                .orElseGet(() -> "li-" + UUID.randomUUID());
+    }
+
+    /**
+     * Construit l'URL OAuth pour ouvrir dans le navigateur de l'utilisateur.
+     */
+    public String buildConnectUrl() {
+        return relay.buildConnectUrl(getOrCreateInstanceId());
+    }
+
+    /**
+     * Installe un JWT recu du relais (l'utilisateur l'a colle dans l'UI ou
+     * recu via deep-link). Verifie la signature, extrait les claims, persiste.
+     */
+    public LicenseSnapshot installToken(String rawJwt) throws InstallException {
+        if (!jwtVerifier.isConfigured()) {
+            throw new InstallException("Licensing feature not enabled (no public key configured)");
+        }
+        LicenseClaims claims;
+        try {
+            claims = jwtVerifier.verify(rawJwt);
+        } catch (JwtVerifier.JwtVerificationException e) {
+            throw new InstallException("Invalid JWT: " + e.getMessage());
+        }
+
+        Instant now = Instant.now();
+        if (claims.expiresAt().isBefore(now)) {
+            throw new InstallException("JWT already expired");
+        }
+
+        Optional<License> existing = repository.findCurrent();
+        License toSave = License.builder()
+                .id("current")
+                .rawJwt(rawJwt)
+                .patreonUserId(claims.subject())
+                .tierId(claims.tierId())
+                .instanceId(claims.instanceId())
+                .issuedAt(claims.issuedAt())
+                .expiresAt(claims.expiresAt())
+                .lastRefreshAttemptAt(now)
+                .lastRefreshSucceeded(true)
+                // Au premier install, on active le canal beta par defaut.
+                // Sur reinstall apres deconnexion, on respecte la valeur precedente.
+                .betaChannelEnabled(existing.map(License::isBetaChannelEnabled).orElse(true))
+                .createdAt(existing.map(License::getCreatedAt).orElse(now))
+                .build();
+
+        License saved = repository.save(toSave);
+        log.info("Patreon license installed for user={} tier={} expires={}",
+                saved.getPatreonUserId(), saved.getTierId(), saved.getExpiresAt());
+        return snapshotOf(saved, now);
+    }
+
+    /**
+     * Etat courant de la licence pour exposition UI / decision technique.
+     */
+    public LicenseSnapshot getCurrentSnapshot() {
+        Optional<License> opt = repository.findCurrent();
+        if (opt.isEmpty()) return LicenseSnapshot.none();
+        return snapshotOf(opt.get(), Instant.now());
+    }
+
+    /**
+     * Supprime la licence (deconnexion volontaire de Patreon par l'utilisateur).
+     */
+    public void disconnect() {
+        repository.deleteCurrent();
+        log.info("Patreon license removed (user disconnect)");
+    }
+
+    /**
+     * Active ou desactive le canal beta. Necessite une licence valide ou en grace.
+     */
+    public LicenseSnapshot setBetaChannelEnabled(boolean enabled) {
+        License current = repository.findCurrent()
+                .orElseThrow(() -> new IllegalStateException("No license installed"));
+        current.setBetaChannelEnabled(enabled);
+        License saved = repository.save(current);
+        return snapshotOf(saved, Instant.now());
+    }
+
+    /**
+     * Tente un refresh si la licence est proche de l'expiration. Idempotent.
+     * Appele par le daemon planifie + manuellement via l'UI ("Reessayer").
+     *
+     * @return true si un refresh a ete tente (avec ou sans succes)
+     */
+    public boolean refreshIfNeeded() {
+        Optional<License> opt = repository.findCurrent();
+        if (opt.isEmpty()) return false;
+        License current = opt.get();
+        Instant now = Instant.now();
+        long secondsUntilExpiry = Duration.between(now, current.getExpiresAt()).getSeconds();
+        if (secondsUntilExpiry > refreshBeforeExpirySeconds) {
+            return false;
+        }
+        return doRefresh(current, now);
+    }
+
+    /**
+     * Force un refresh immediat (bouton UI "Reessayer maintenant").
+     */
+    public boolean forceRefresh() {
+        return repository.findCurrent()
+                .map(license -> doRefresh(license, Instant.now()))
+                .orElse(false);
+    }
+
+    private boolean doRefresh(License current, Instant now) {
+        log.info("Refreshing Patreon license (current expires {})", current.getExpiresAt());
+        try {
+            String newJwt = relay.refreshToken(current.getRawJwt());
+            LicenseClaims claims = jwtVerifier.verify(newJwt);
+
+            current.setRawJwt(newJwt);
+            current.setIssuedAt(claims.issuedAt());
+            current.setExpiresAt(claims.expiresAt());
+            current.setTierId(claims.tierId());
+            current.setLastRefreshAttemptAt(now);
+            current.setLastRefreshSucceeded(true);
+            repository.save(current);
+            log.info("License refreshed successfully (new expiry {})", claims.expiresAt());
+            return true;
+        } catch (LicenseRelay.RelayException e) {
+            current.setLastRefreshAttemptAt(now);
+            current.setLastRefreshSucceeded(false);
+            repository.save(current);
+            if (e.getKind() == LicenseRelay.RelayErrorKind.REJECTED) {
+                log.warn("Relay rejected refresh ({}): tier may have been cancelled", e.getMessage());
+            } else {
+                log.warn("Relay refresh transient failure ({}): {}", e.getKind(), e.getMessage());
+            }
+            return true;
+        } catch (JwtVerifier.JwtVerificationException e) {
+            current.setLastRefreshAttemptAt(now);
+            current.setLastRefreshSucceeded(false);
+            repository.save(current);
+            log.error("Relay returned a JWT that fails verification: {}", e.getMessage());
+            return true;
+        }
+    }
+
+    /**
+     * Recupere les credentials registry pour pull du canal beta.
+     * @return empty si pas de licence valide ou relais en echec
+     */
+    public Optional<RegistryCredentials> fetchRegistryCredentials() {
+        LicenseSnapshot snap = getCurrentSnapshot();
+        if (snap.status() != LicenseStatus.VALID && snap.status() != LicenseStatus.GRACE) {
+            return Optional.empty();
+        }
+        License current = repository.findCurrent().orElse(null);
+        if (current == null) return Optional.empty();
+        try {
+            return Optional.of(relay.fetchRegistryCredentials(current.getRawJwt()));
+        } catch (LicenseRelay.RelayException e) {
+            log.warn("Cannot fetch registry credentials ({}): {}", e.getKind(), e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    private LicenseSnapshot snapshotOf(License l, Instant now) {
+        LicenseStatus status = computeStatus(l, now);
+        return new LicenseSnapshot(
+                status,
+                l.getPatreonUserId(),
+                l.getTierId(),
+                l.getInstanceId(),
+                l.getExpiresAt(),
+                l.getLastRefreshAttemptAt(),
+                l.isLastRefreshSucceeded(),
+                l.isBetaChannelEnabled()
+        );
+    }
+
+    private LicenseStatus computeStatus(License l, Instant now) {
+        if (l.getExpiresAt() == null) return LicenseStatus.NONE;
+        if (now.isBefore(l.getExpiresAt())) return LicenseStatus.VALID;
+        long secondsPastExpiry = Duration.between(l.getExpiresAt(), now).getSeconds();
+        if (secondsPastExpiry <= gracePeriodSeconds) return LicenseStatus.GRACE;
+        return LicenseStatus.EXPIRED;
+    }
+
+    public static class InstallException extends Exception {
+        public InstallException(String message) {
+            super(message);
+        }
+    }
+}

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

@@ -1,9 +1,13 @@
 package com.loremind.application.lorecontext;
 
 import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.domain.lorecontext.Page;
 import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
+import com.loremind.domain.lorecontext.ports.PageRepository;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -16,11 +20,20 @@ import java.util.Optional;
 public class LoreNodeService {
 
     private final LoreNodeRepository loreNodeRepository;
+    private final PageRepository pageRepository;
 
-    public LoreNodeService(LoreNodeRepository loreNodeRepository) {
+    public LoreNodeService(LoreNodeRepository loreNodeRepository, PageRepository pageRepository) {
         this.loreNodeRepository = loreNodeRepository;
+        this.pageRepository = pageRepository;
     }
 
+    /**
+     * Compte des entités qui seront supprimées en cascade si le dossier est effacé :
+     * le dossier lui-même n'est pas compté, seuls les descendants (sous-dossiers
+     * récursifs + pages de l'ensemble du sous-arbre).
+     */
+    public record DeletionImpact(int folders, int pages) {}
+
     /**
      * Crée un LoreNode (dossier) à partir d'un "objet changes" porteur des valeurs
      * souhaitées (pattern Parameter Object) : évite les signatures qui gonflent
@@ -68,7 +81,64 @@ public class LoreNodeService {
         return loreNodeRepository.save(existing);
     }
 
+    /**
+     * Calcule l'impact d'une suppression en cascade : nombre de sous-dossiers
+     * (récursif, sans compter la racine) et de pages dans l'ensemble du sous-arbre.
+     */
+    public DeletionImpact getDeletionImpact(String id) {
+        List<LoreNode> descendants = collectDescendants(id);
+        int pageTotal = pageRepository.findByNodeId(id).size();
+        for (LoreNode descendant : descendants) {
+            pageTotal += pageRepository.findByNodeId(descendant.getId()).size();
+        }
+        return new DeletionImpact(descendants.size(), pageTotal);
+    }
+
+    /**
+     * Supprime le dossier et tout son sous-arbre (sous-dossiers récursifs + pages).
+     * Suppression en profondeur d'abord (feuilles → racine) pour limiter les
+     * références orphelines en cours de transaction. Les FKs applicatives n'ayant
+     * pas de CASCADE en DB, on orchestre la descente ici.
+     */
+    @Transactional
     public void deleteLoreNode(String id) {
+        List<LoreNode> descendants = collectDescendants(id);
+        // Descendants retournés en ordre BFS (haut → bas) : on inverse pour
+        // supprimer les feuilles en premier, puis on finit par la racine.
+        for (int i = descendants.size() - 1; i >= 0; i--) {
+            String descendantId = descendants.get(i).getId();
+            deletePagesOfNode(descendantId);
+            loreNodeRepository.deleteById(descendantId);
+        }
+        deletePagesOfNode(id);
         loreNodeRepository.deleteById(id);
     }
+
+    private void deletePagesOfNode(String nodeId) {
+        for (Page page : pageRepository.findByNodeId(nodeId)) {
+            pageRepository.deleteById(page.getId());
+        }
+    }
+
+    /**
+     * Retourne tous les descendants (hors racine) d'un dossier, en ordre BFS.
+     * Parcours itératif pour éviter tout risque de débordement de pile sur
+     * une arborescence profonde malicieuse.
+     */
+    private List<LoreNode> collectDescendants(String rootId) {
+        List<LoreNode> result = new ArrayList<>();
+        List<String> frontier = new ArrayList<>();
+        frontier.add(rootId);
+        while (!frontier.isEmpty()) {
+            List<String> nextFrontier = new ArrayList<>();
+            for (String parentId : frontier) {
+                for (LoreNode child : loreNodeRepository.findByParentId(parentId)) {
+                    result.add(child);
+                    nextFrontier.add(child.getId());
+                }
+            }
+            frontier = nextFrontier;
+        }
+        return result;
+    }
 }

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

@@ -1,10 +1,17 @@
 package com.loremind.application.lorecontext;
 
+import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.lorecontext.Lore;
+import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.domain.lorecontext.Page;
+import com.loremind.domain.lorecontext.Template;
 import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
 import com.loremind.domain.lorecontext.ports.LoreRepository;
 import com.loremind.domain.lorecontext.ports.PageRepository;
+import com.loremind.domain.lorecontext.ports.TemplateRepository;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Optional;
@@ -26,15 +33,28 @@ public class LoreService {
     private final LoreRepository loreRepository;
     private final LoreNodeRepository loreNodeRepository;
     private final PageRepository pageRepository;
+    private final TemplateRepository templateRepository;
+    private final CampaignRepository campaignRepository;
 
     public LoreService(LoreRepository loreRepository,
                        LoreNodeRepository loreNodeRepository,
-                       PageRepository pageRepository) {
+                       PageRepository pageRepository,
+                       TemplateRepository templateRepository,
+                       CampaignRepository campaignRepository) {
         this.loreRepository = loreRepository;
         this.loreNodeRepository = loreNodeRepository;
         this.pageRepository = pageRepository;
+        this.templateRepository = templateRepository;
+        this.campaignRepository = campaignRepository;
     }
 
+    /**
+     * Compte des entités qui seront supprimées / détachées en cascade si le Lore
+     * est effacé. `detachedCampaigns` : campagnes qui perdront leur référence à
+     * ce Lore (leur loreId sera nullé) mais resteront présentes.
+     */
+    public record DeletionImpact(int folders, int pages, int templates, int detachedCampaigns) {}
+
     public Lore createLore(String name, String description) {
         Lore lore = Lore.builder()
                 .name(name)
@@ -83,7 +103,54 @@ public class LoreService {
         return loreRepository.save(lore);
     }
 
+    /**
+     * Calcule l'impact d'une suppression de Lore en cascade : dossiers + pages
+     * + templates supprimés, et campagnes qui seront détachées (loreId → null
+     * sans être supprimées, car une campagne peut vivre sans univers).
+     */
+    public DeletionImpact getDeletionImpact(String id) {
+        int folders = (int) loreNodeRepository.countByLoreId(id);
+        int pages = (int) pageRepository.countByLoreId(id);
+        int templates = templateRepository.findByLoreId(id).size();
+        int detached = countCampaignsReferencingLore(id);
+        return new DeletionImpact(folders, pages, templates, detached);
+    }
+
+    /**
+     * Supprime le Lore et toutes ses entités dépendantes (dossiers, pages, templates).
+     * Les campagnes qui référençaient ce Lore sont conservées — leur loreId est
+     * mis à null (une campagne peut légitimement exister sans univers associé).
+     * Opération transactionnelle : atomique.
+     */
+    @Transactional
     public void deleteLore(String id) {
+        // Pages d'abord : elles référencent nodeId ET loreId, on les supprime
+        // globalement via loreId pour éviter d'en rater une rattachée à un
+        // node orphelin (ne devrait pas arriver, mais ceinture+bretelles).
+        for (Page page : pageRepository.findByLoreId(id)) {
+            pageRepository.deleteById(page.getId());
+        }
+        for (LoreNode node : loreNodeRepository.findByLoreId(id)) {
+            loreNodeRepository.deleteById(node.getId());
+        }
+        for (Template template : templateRepository.findByLoreId(id)) {
+            templateRepository.deleteById(template.getId());
+        }
+        // Détache les campagnes : on garde la campagne, on nulle juste la référence.
+        for (Campaign campaign : campaignRepository.findAll()) {
+            if (id.equals(campaign.getLoreId())) {
+                campaign.setLoreId(null);
+                campaignRepository.save(campaign);
+            }
+        }
         loreRepository.deleteById(id);
     }
+
+    private int countCampaignsReferencingLore(String id) {
+        int count = 0;
+        for (Campaign campaign : campaignRepository.findAll()) {
+            if (id.equals(campaign.getLoreId())) count++;
+        }
+        return count;
+    }
 }

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

@@ -21,6 +21,9 @@ public class Arc {
     private String campaignId;       // Référence vers la Campaign parente
     private int order;               // Ordre de l'arc dans la campagne
 
+    /** Cle d'icone choisie par l'utilisateur (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // Champs narratifs enrichis (voir docs/maquettes/campagne/détail/)
     private String themes;           // Thèmes principaux explorés dans cet arc
     private String stakes;           // Enjeux globaux pour les personnages

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

@@ -21,6 +21,9 @@ public class Chapter {
     private String arcId;              // Référence vers l'Arc parent
     private int order;                 // Ordre du chapitre dans l'arc
 
+    /** Cle d'icone choisie par l'utilisateur (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // Champs narratifs enrichis (voir docs/maquettes/campagne/détail/)
     private String gmNotes;            // Notes privées du MJ (non exportées vers FoundryVTT)
     private String playerObjectives;   // Objectifs des joueurs dans ce chapitre

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

@@ -12,9 +12,10 @@ import java.time.LocalDateTime;
  * backstory, équipement). Évolution prévue vers un système templaté par
  * GameSystem (la fiche Nimble n'a pas les mêmes champs qu'une fiche D&D).
  * <p>
- * Scope strict PJ : les PNJ restent dans le Lore (pages templatées) ou
+ * Scope strict PJ : les PNJ sont gérés par l'entité {@link Npc} dédiée
- * dans les scènes elles-mêmes. Si le besoin de PNJ spécifiques à une
+ * (entité distincte plutôt qu'enum PJ/PNJ — invariants métier divergents).
- * campagne remonte, on étendra l'entité (ex: type enum PJ/PNJ).
+ * Évolution prévue : système de templating partagé PJ/PNJ piloté par
+ * GameSystem pour adapter les blocs aux différents systèmes de JDR.
  */
 @Data
 @Builder

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

@@ -0,0 +1,41 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * Fiche de personnage non-joueur (PNJ) d'une campagne.
+ * <p>
+ * MVP : entité dédiée, distincte de {@link Character} (PJ). Choix DDD assumé —
+ * un PNJ a vocation à porter à terme des invariants métier propres (faction,
+ * statut vivant/mort/disparu, visibilité côté joueurs, relations inter-PNJ)
+ * qui n'ont aucun sens sur un PJ. Mutualiser via un enum aurait pollué l'entité
+ * PJ avec des champs inutiles ({@code if (type == NPC)} partout = anti-pattern).
+ * <p>
+ * Contenu markdown libre comme les PJ. Évolution prévue : templating partagé
+ * PJ/PNJ piloté par GameSystem.
+ * <p>
+ * Scope campagne : les PNJ "univers" (worldboss, figures du Lore) restent
+ * gérés via le système Page/Template du LoreContext.
+ */
+@Data
+@Builder
+public class Npc {
+
+    private String id;
+    private String name;
+
+    /** Contenu libre markdown — description, motivation, stats, notes MJ. Nullable à la création. */
+    private String markdownContent;
+
+    /** Référence vers la Campaign parente (cross-aggregate via ID, jamais d'objet). */
+    private String campaignId;
+
+    /** Ordre d'affichage dans la liste des PNJ de la campagne. */
+    private int order;
+
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

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

@@ -21,6 +21,9 @@ public class Scene {
     private String chapterId;              // Référence vers le Chapter parent
     private int order;                     // Ordre de la scène dans le chapitre
 
+    /** Cle d'icone choisie par l'utilisateur (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // === Contexte et ambiance ===
     private String location;               // Lieu de la scène (ex: Taverne du Dragon d'Or)
     private String timing;                 // Moment (ex: Soir, à la tombée de la nuit)

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

@@ -1,31 +1,25 @@
 package com.loremind.domain.campaigncontext;
 
-import lombok.Builder;
-import lombok.Value;
-import lombok.extern.jackson.Jacksonized;
-
 /**
  * Value Object représentant une "sortie" narrative depuis une Scene.
  * Décrit un choix offert aux joueurs et la scène de destination associée.
  * <p>
- * Immuable (@Value) : pour "modifier" une branche on la remplace.
+ * Record Java : immuable par construction, sans aucune dépendance technique
- * @Jacksonized : permet à Jackson (sérialisation JSON via le converter JPA)
+ * (pas de Lombok, pas de Jackson). Jackson 2.12+ sait sérialiser/désérialiser
- * de reconstruire l'objet en passant par le builder malgré l'absence de setters.
+ * les records nativement via le constructeur canonique — c'est ce dont
+ * dépend le SceneBranchListJsonConverter pour le stockage JSONB.
  * <p>
  * Règle métier : targetSceneId DOIT pointer vers une Scene du MÊME Chapter
  * (validation portée par SceneService).
+ *
+ * @param label          Libellé du choix (ex: "Si les joueurs attaquent le garde").
+ * @param targetSceneId  Id de la Scene de destination, intra-chapitre uniquement.
+ * @param condition      Notes MJ privées sur la condition de déclenchement (optionnel).
  */
-@Value
+public record SceneBranch(String label, String targetSceneId, String condition) {
-@Builder
-@Jacksonized
-public class SceneBranch {
 
-    /** Libellé du choix (ex: "Si les joueurs attaquent le garde"). */
+    /** Raccourci pour construire une branche sans condition (cas le plus courant). */
-    String label;
+    public static SceneBranch of(String label, String targetSceneId) {
-
+        return new SceneBranch(label, targetSceneId, null);
-    /** Id de la Scene de destination, intra-chapitre uniquement. */
+    }
-    String targetSceneId;
-
-    /** Notes MJ privées sur la condition de déclenchement (optionnel). */
-    String condition;
 }

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

@@ -0,0 +1,22 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Npc;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des fiches de PNJ (campagne).
+ */
+public interface NpcRepository {
+
+    Npc save(Npc npc);
+
+    Optional<Npc> findById(String id);
+
+    List<Npc> findByCampaignId(String campaignId);
+
+    void deleteById(String id);
+
+    boolean existsById(String id);
+}

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

@@ -1,9 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Singular;
-import lombok.Value;
-
 import java.util.List;
 
 /**
@@ -22,16 +18,18 @@ import java.util.List;
  * <p>
  * La liste `arcs` préserve l'ordre narratif (tri sur `order` ascendant
  * fait par le use case côté application layer).
+ * <p>
+ * Record Java : pur domaine, aucune dépendance technique.
+ *
+ * @param characters Personnages joueurs (PJ) de la campagne. Vide si aucun.
+ * @param npcs       Personnages non-joueurs (PNJ) de la campagne. Vide si aucun.
  */
-@Value
+public record CampaignStructuralContext(
-@Builder
+        String campaignName,
-public class CampaignStructuralContext {
+        String campaignDescription,
-
+        List<ArcSummary> arcs,
-    String campaignName;
+        List<CharacterSummary> characters,
-    String campaignDescription;
+        List<NpcSummary> npcs) {
-    @Singular List<ArcSummary> arcs;
-    /** Personnages joueurs (PJ) de la campagne. Vide si aucun. */
-    @Singular List<CharacterSummary> characters;
 
     /**
      * Résumé d'un PJ : nom + snippet court du markdown.
@@ -40,53 +38,52 @@ public class CampaignStructuralContext {
      * La fiche complète n'est injectée que si le PJ est l'entité focus
      * (via NarrativeEntityContext, entity_type="character").
      */
-    @Value
+    public record CharacterSummary(String name, String snippet) {
-    @Builder
-    public static class CharacterSummary {
-        String name;
-        String snippet;
     }
 
-    /** Résumé d'un arc : nom + description courte + ses chapitres. */
+    /**
-    @Value
+     * Résumé d'un PNJ : symétrique à {@link CharacterSummary}.
-    @Builder
+     * Snippet court extrait du markdown — la fiche complète est réservée
-    public static class ArcSummary {
+     * à un usage focus (à venir, entity_type="npc").
-        String name;
+     */
-        String description;
+    public record NpcSummary(String name, String snippet) {
-        /** Nombre d'illustrations attachees a cet arc (pour hint dans le prompt IA). */
+    }
-        int illustrationCount;
+
-        @Singular List<ChapterSummary> chapters;
+    /**
+     * Résumé d'un arc : nom + description courte + ses chapitres.
+     *
+     * @param illustrationCount Nombre d'illustrations attachees a cet arc (pour hint dans le prompt IA).
+     */
+    public record ArcSummary(
+            String name,
+            String description,
+            int illustrationCount,
+            List<ChapterSummary> chapters) {
     }
 
     /** Résumé d'un chapitre : nom + description courte + ses scènes. */
-    @Value
+    public record ChapterSummary(
-    @Builder
+            String name,
-    public static class ChapterSummary {
+            String description,
-        String name;
+            int illustrationCount,
-        String description;
+            List<SceneSummary> scenes) {
-        int illustrationCount;
-        @Singular List<SceneSummary> scenes;
     }
 
     /** Résumé d'une scène : nom + description courte + branches narratives. */
-    @Value
+    public record SceneSummary(
-    @Builder
+            String name,
-    public static class SceneSummary {
+            String description,
-        String name;
+            int illustrationCount,
-        String description;
+            List<BranchHint> branches) {
-        int illustrationCount;
-        @Singular List<BranchHint> branches;
     }
 
-    /** Indice d'une branche narrative vers une autre scène du même chapitre. */
+    /**
-    @Value
+     * Indice d'une branche narrative vers une autre scène du même chapitre.
-    @Builder
+     *
-    public static class BranchHint {
+     * @param label           Libellé du choix joueur (ex: "Si les joueurs attaquent le garde").
-        /** Libellé du choix joueur (ex: "Si les joueurs attaquent le garde"). */
+     * @param targetSceneName Nom de la scène cible (résolu depuis targetSceneId côté builder).
-        String label;
+     * @param condition       Condition MJ privée (optionnel).
-        /** Nom de la scène cible (résolu depuis targetSceneId côté builder). */
+     */
-        String targetSceneName;
+    public record BranchHint(String label, String targetSceneName, String condition) {
-        /** Condition MJ privée (optionnel). */
-        String condition;
     }
 }

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

@@ -1,8 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Value;
-
 import java.util.List;
 
 /**
@@ -21,28 +18,74 @@ import java.util.List;
  * Un chat Lore ne reçoit JAMAIS de campaignContext : un Lore ne voit pas
  * ses campagnes (asymétrie métier : la campagne est l'emprunteur du Lore,
  * pas l'inverse).
- */
+ * <p>
-@Value
+ * Record Java : pur domaine. Builder manuel fourni en raison des 6 champs
-@Builder
+ * dont 5 sont nullables — l'API fluide reste plus lisible aux call sites
-public class ChatRequest {
+ * qu'un constructeur à 6 paramètres souvent à null.
-
+ *
-    List<ChatMessage> messages;
+ * @param loreContext       Optionnel : carte structurelle du Lore. Null si campagne non liée à un Lore.
-
+ * @param pageContext       Optionnel : contexte d'une page précise en cours d'édition (chat Lore uniquement).
-    /** Optionnel : carte structurelle du Lore. Null si campagne non liée à un Lore. */
+ * @param campaignContext   Optionnel : carte narrative d'une Campagne (chat Campagne uniquement).
-    LoreStructuralContext loreContext;
+ * @param narrativeEntity   Optionnel : entité narrative en cours d'édition (arc/chapter/scene).
-
+ * @param gameSystemContext Optionnel : règles du système de JDR de la campagne (filtrées par intent).
-    /** Optionnel : contexte d'une page précise en cours d'édition (chat Lore uniquement). */
-    PageContext pageContext;
-
-    /** Optionnel : carte narrative d'une Campagne (chat Campagne uniquement). */
-    CampaignStructuralContext campaignContext;
-
-    /** Optionnel : entité narrative en cours d'édition (arc/chapter/scene). */
-    NarrativeEntityContext narrativeEntity;
-
-    /**
-     * Optionnel : règles du système de JDR de la campagne (filtrées par intent).
  *                          Null si la campagne n'a pas de GameSystem associé. Campagne uniquement au MVP.
  */
-    GameSystemContext gameSystemContext;
+public record ChatRequest(
+        List<ChatMessage> messages,
+        LoreStructuralContext loreContext,
+        PageContext pageContext,
+        CampaignStructuralContext campaignContext,
+        NarrativeEntityContext narrativeEntity,
+        GameSystemContext gameSystemContext) {
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /** Builder fluide : permet d'omettre les contextes non pertinents. */
+    public static final class Builder {
+        private List<ChatMessage> messages;
+        private LoreStructuralContext loreContext;
+        private PageContext pageContext;
+        private CampaignStructuralContext campaignContext;
+        private NarrativeEntityContext narrativeEntity;
+        private GameSystemContext gameSystemContext;
+
+        private Builder() {}
+
+        public Builder messages(List<ChatMessage> messages) {
+            this.messages = messages;
+            return this;
+        }
+
+        public Builder loreContext(LoreStructuralContext loreContext) {
+            this.loreContext = loreContext;
+            return this;
+        }
+
+        public Builder pageContext(PageContext pageContext) {
+            this.pageContext = pageContext;
+            return this;
+        }
+
+        public Builder campaignContext(CampaignStructuralContext campaignContext) {
+            this.campaignContext = campaignContext;
+            return this;
+        }
+
+        public Builder narrativeEntity(NarrativeEntityContext narrativeEntity) {
+            this.narrativeEntity = narrativeEntity;
+            return this;
+        }
+
+        public Builder gameSystemContext(GameSystemContext gameSystemContext) {
+            this.gameSystemContext = gameSystemContext;
+            return this;
+        }
+
+        public ChatRequest build() {
+            return new ChatRequest(messages, loreContext, pageContext,
+                    campaignContext, narrativeEntity, gameSystemContext);
+        }
+    }
 }

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

@@ -1,8 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Value;
-
 import java.util.Map;
 
 /**
@@ -11,20 +8,14 @@ import java.util.Map;
  * Contient uniquement les sections pertinentes pour l'intent de génération
  * en cours (sélection effectuée par GameSystemContextBuilder). Les sections
  * sont indexées par leur titre H2 original (ex : "Combat", "Classes").
- */
+ *
-@Value
+ * @param systemName        Nom du système de JDR (ex : "Nimble", "D&D 5.1 SRD").
-@Builder
+ * @param systemDescription Description courte du système (nullable).
-public class GameSystemContext {
+ * @param sections          Sections de règles pertinentes, indexées par titre H2.
-
-    /** Nom du système de JDR (ex : "Nimble", "D&D 5.1 SRD"). */
-    String systemName;
-
-    /** Description courte du système (nullable). */
-    String systemDescription;
-
-    /**
-     * Sections de règles pertinentes, indexées par titre H2.
  *                          Vide si le GameSystem n'a aucune règle ou si aucune section ne matche l'intent.
  */
-    Map<String, String> sections;
+public record GameSystemContext(
+        String systemName,
+        String systemDescription,
+        Map<String, String> sections) {
 }

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

@@ -1,8 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Value;
-
 import java.util.List;
 
 /**
@@ -10,19 +7,16 @@ import java.util.List;
  * pour remplir une Page à partir d'un Template.
  * <p>
  * Équivalent Java du PageGenerationContext Python (brain/app/domain/models.py).
- * Entité pure du domaine : aucune dépendance technique.
+ * Record Java : pur domaine, aucune dépendance technique.
- * <p>
+ *
- * Immuable via @Value (Lombok) : pas de setters, tous les champs final.
+ * @param templateFields Champs à générer (clés attendues dans la réponse).
- * C'est un DTO de domaine entrant dans le port AiProvider.
+ * @param folderName     Nom du LoreNode parent (ex: "PNJ", "Lieux").
  */
-@Value
+public record GenerationContext(
-@Builder
+        String loreName,
-public class GenerationContext {
+        String loreDescription,
-
+        String folderName,
-    String loreName;
+        String templateName,
-    String loreDescription;
+        List<String> templateFields,
-    String folderName;            // Nom du LoreNode parent (ex: "PNJ", "Lieux")
+        String pageTitle) {
-    String templateName;
-    List<String> templateFields;  // Champs à générer (clés attendues dans la réponse)
-    String pageTitle;
 }

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

@@ -1,9 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Singular;
-import lombok.Value;
-
 import java.util.List;
 import java.util.Map;
 
@@ -16,15 +12,14 @@ import java.util.Map;
  * <p>
  * La map `folders` est indexée par nom de dossier et mappe vers la liste
  * des pages qu'il contient (liste vide autorisée pour les dossiers vides).
+ * <p>
+ * Record Java : pur domaine, aucune dépendance technique.
  */
-@Value
+public record LoreStructuralContext(
-@Builder
+        String loreName,
-public class LoreStructuralContext {
+        String loreDescription,
-
+        Map<String, List<PageSummary>> folders,
-    String loreName;
+        List<String> tags) {
-    String loreDescription;
-    Map<String, List<PageSummary>> folders;
-    @Singular List<String> tags;
 
     /**
      * Résumé projeté d'une page pour l'IA.
@@ -40,13 +35,11 @@ public class LoreStructuralContext {
      * uniquement ce qui est partageable en narration — les secrets MJ
      * restent confinés à leur page d'édition).
      */
-    @Value
+    public record PageSummary(
-    @Builder
+            String title,
-    public static class PageSummary {
+            String templateName,
-        String title;
+            Map<String, String> values,
-        String templateName;
+            List<String> tags,
-        Map<String, String> values;
+            List<String> relatedPageTitles) {
-        List<String> tags;
-        List<String> relatedPageTitles;
     }
 }

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

@@ -1,8 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Value;
-
 import java.util.Map;
 
 /**
@@ -17,13 +14,11 @@ import java.util.Map;
  * `fields` associe le nom d'un champ (ex: "themes", "playerNarration")
  * à sa valeur actuelle (chaîne vide si non renseigné). Utiliser une
  * LinkedHashMap à la construction pour un prompt lisible (ordre préservé).
+ *
+ * @param entityType "arc", "chapter" ou "scene" — utilisé pour libeller le bloc du prompt.
  */
-@Value
+public record NarrativeEntityContext(
-@Builder
+        String entityType,
-public class NarrativeEntityContext {
+        String title,
-
+        Map<String, String> fields) {
-    /** "arc", "chapter" ou "scene" — utilisé pour libeller le bloc du prompt. */
-    String entityType;
-    String title;
-    Map<String, String> fields;
 }

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

@@ -1,8 +1,5 @@
 package com.loremind.domain.generationcontext;
 
-import lombok.Builder;
-import lombok.Value;
-
 import java.util.List;
 import java.util.Map;
 
@@ -14,14 +11,11 @@ import java.util.Map;
  * à l'IA de focaliser ses suggestions sur les bons champs sans déborder
  * sur d'autres pages/templates.
  * <p>
- * Object de valeur immuable, pur domaine — aucune dépendance technique.
+ * Record Java : immuable, pur domaine, aucune dépendance technique.
  */
-@Value
+public record PageContext(
-@Builder
+        String title,
-public class PageContext {
+        String templateName,
-
+        List<String> templateFields,
-    String title;
+        Map<String, String> values) {
-    String templateName;
-    List<String> templateFields;
-    Map<String, String> values;
 }

core/src/main/java/com/loremind/domain/licensing/License.java

@@ -0,0 +1,48 @@
+package com.loremind.domain.licensing;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.Instant;
+
+/**
+ * Licence Patreon installee dans cette instance LoreMind.
+ * <p>
+ * Singleton (une seule licence par instance, identifiee logiquement par
+ * {@code id = "current"}). Contient le JWT brut emis par le relais OAuth
+ * + les claims extraits a la verification, plus l'etat operationnel
+ * (derniere tentative de refresh, succes/echec).
+ * <p>
+ * <b>Note securite :</b> {@link #rawJwt} est stocke tel quel ; sa signature
+ * Ed25519 est verifiee a chaque lecture. Pas besoin de chiffrement au repos
+ * supplementaire — un attaquant qui a acces a la base a deja l'instance,
+ * et le JWT ne donne aucun pouvoir au-dela du canal beta de cette instance.
+ */
+@Data
+@Builder
+public class License {
+
+    private String id;
+
+    private String rawJwt;
+
+    private String patreonUserId;
+
+    private String tierId;
+
+    private String instanceId;
+
+    private Instant issuedAt;
+
+    private Instant expiresAt;
+
+    private Instant lastRefreshAttemptAt;
+
+    private boolean lastRefreshSucceeded;
+
+    private boolean betaChannelEnabled;
+
+    private Instant createdAt;
+
+    private Instant updatedAt;
+}

core/src/main/java/com/loremind/domain/licensing/LicenseClaims.java

@@ -0,0 +1,15 @@
+package com.loremind.domain.licensing;
+
+import java.time.Instant;
+
+/**
+ * Claims extraits d'un JWT licence apres verification de signature.
+ * Immuable.
+ */
+public record LicenseClaims(
+        String subject,
+        String tierId,
+        String instanceId,
+        Instant issuedAt,
+        Instant expiresAt
+) {}

core/src/main/java/com/loremind/domain/licensing/LicenseSnapshot.java

@@ -0,0 +1,23 @@
+package com.loremind.domain.licensing;
+
+import java.time.Instant;
+
+/**
+ * Vue immuable de la licence pour exposition vers les couches superieures.
+ * Decouple le domaine du DTO web et permet de calculer le {@link LicenseStatus}
+ * a un instant donne sans muter l'entite.
+ */
+public record LicenseSnapshot(
+        LicenseStatus status,
+        String patreonUserId,
+        String tierId,
+        String instanceId,
+        Instant expiresAt,
+        Instant lastRefreshAttemptAt,
+        boolean lastRefreshSucceeded,
+        boolean betaChannelEnabled
+) {
+    public static LicenseSnapshot none() {
+        return new LicenseSnapshot(LicenseStatus.NONE, null, null, null, null, null, false, false);
+    }
+}

core/src/main/java/com/loremind/domain/licensing/LicenseStatus.java

@@ -0,0 +1,23 @@
+package com.loremind.domain.licensing;
+
+/**
+ * Etat operationnel de la licence vis-a-vis de l'acces beta.
+ * <p>
+ * Calcule a partir de la presence de licence + son JWT exp + grace period.
+ * <ul>
+ *   <li>{@link #NONE} : aucune licence installee</li>
+ *   <li>{@link #VALID} : JWT non expire, acces beta autorise</li>
+ *   <li>{@link #GRACE} : JWT expire mais dans la periode de tolerance ;
+ *       acces beta toujours autorise, l'UI doit avertir</li>
+ *   <li>{@link #EXPIRED} : au-dela de la grace period, acces beta refuse</li>
+ *   <li>{@link #UNVERIFIABLE} : JWT impossible a verifier (cle publique manquante,
+ *       signature invalide, claims malformes) — traite comme NONE pour la securite</li>
+ * </ul>
+ */
+public enum LicenseStatus {
+    NONE,
+    VALID,
+    GRACE,
+    EXPIRED,
+    UNVERIFIABLE
+}

core/src/main/java/com/loremind/domain/licensing/RegistryCredentials.java

@@ -0,0 +1,18 @@
+package com.loremind.domain.licensing;
+
+import java.time.Instant;
+
+/**
+ * Credentials de pull pour un registry Docker, distribues par le relais
+ * apres verification d'un JWT licence valide.
+ * <p>
+ * {@code expiresAt} peut etre {@code null} si le credential est statique
+ * (cas du PAT GHCR partage en MVP) ; sinon, l'instance doit re-demander
+ * de nouveaux credentials avant cette date.
+ */
+public record RegistryCredentials(
+        String registry,
+        String username,
+        String password,
+        Instant expiresAt
+) {}

core/src/main/java/com/loremind/domain/licensing/ports/DockerConfigWriter.java

@@ -0,0 +1,34 @@
+package com.loremind.domain.licensing.ports;
+
+import com.loremind.domain.licensing.RegistryCredentials;
+
+import java.io.IOException;
+
+/**
+ * Port de sortie : ecriture du docker config.json partage avec Watchtower.
+ * <p>
+ * Le fichier sert a Watchtower pour s'authentifier au registry prive (GHCR)
+ * lors du pull des images du canal beta. Volume Docker {@code docker-config}
+ * monte sur Core (en ecriture) et sur Watchtower (en lecture, via la variable
+ * {@code DOCKER_CONFIG}).
+ */
+public interface DockerConfigWriter {
+
+    /**
+     * Ecrit ou met a jour les credentials pour le registry indique.
+     * Cree le fichier s'il n'existe pas, conserve les autres registries deja
+     * presents (en theorie : aucun, mais defensif).
+     */
+    void writeCredentials(RegistryCredentials credentials) throws IOException;
+
+    /**
+     * Supprime le fichier de credentials. Appele quand la licence est invalidee
+     * ou que le toggle beta passe a OFF.
+     */
+    void clear() throws IOException;
+
+    /**
+     * @return true si le fichier de creds existe actuellement.
+     */
+    boolean isPresent();
+}

core/src/main/java/com/loremind/domain/licensing/ports/JwtVerifier.java

@@ -0,0 +1,34 @@
+package com.loremind.domain.licensing.ports;
+
+import com.loremind.domain.licensing.LicenseClaims;
+
+/**
+ * Port de sortie : verification de signature et extraction des claims
+ * d'un JWT emis par le relais.
+ * <p>
+ * Implemente cote infrastructure avec la cle publique Ed25519 embarquee
+ * (SPKI PEM via configuration {@code licensing.jwt.public-key}).
+ */
+public interface JwtVerifier {
+
+    /**
+     * Verifie la signature, l'issuer, l'audience et l'expiration du JWT.
+     * @throws JwtVerificationException si la signature est invalide ou les claims malformes
+     */
+    LicenseClaims verify(String rawJwt) throws JwtVerificationException;
+
+    /**
+     * @return true si la cle publique est configuree et utilisable.
+     *         Permet a l'application de masquer la feature licensing si pas configuree.
+     */
+    boolean isConfigured();
+
+    class JwtVerificationException extends Exception {
+        public JwtVerificationException(String message) {
+            super(message);
+        }
+        public JwtVerificationException(String message, Throwable cause) {
+            super(message, cause);
+        }
+    }
+}

core/src/main/java/com/loremind/domain/licensing/ports/LicenseRelay.java

@@ -0,0 +1,59 @@
+package com.loremind.domain.licensing.ports;
+
+import com.loremind.domain.licensing.RegistryCredentials;
+
+/**
+ * Port de sortie vers le service relais OAuth Patreon.
+ * Encapsule les appels HTTP : refresh JWT et fetch registry credentials.
+ */
+public interface LicenseRelay {
+
+    /**
+     * Demande au relais l'URL OAuth a ouvrir pour connecter le compte Patreon.
+     */
+    String buildConnectUrl(String instanceId);
+
+    /**
+     * Demande au relais de renouveler un JWT existant. Le relais re-verifie
+     * le tier Patreon de l'utilisateur ; renvoie un nouveau JWT si toujours
+     * actif, ou leve {@link RelayException} sinon.
+     */
+    String refreshToken(String currentJwt) throws RelayException;
+
+    /**
+     * Demande au relais les credentials de pull du registry beta.
+     */
+    RegistryCredentials fetchRegistryCredentials(String currentJwt) throws RelayException;
+
+    /**
+     * Erreurs distinctes emises par le relais. Permet au service application
+     * de differencier "tier expire" (action utilisateur) de "relais down"
+     * (action transitoire, garde la grace period).
+     */
+    class RelayException extends Exception {
+        private final RelayErrorKind kind;
+
+        public RelayException(RelayErrorKind kind, String message) {
+            super(message);
+            this.kind = kind;
+        }
+
+        public RelayException(RelayErrorKind kind, String message, Throwable cause) {
+            super(message, cause);
+            this.kind = kind;
+        }
+
+        public RelayErrorKind getKind() {
+            return kind;
+        }
+    }
+
+    enum RelayErrorKind {
+        /** Le relais est joignable mais refuse : tier non actif, JWT trop ancien, etc. */
+        REJECTED,
+        /** Le relais a renvoye un JWT mais il est invalide / non parsable. */
+        BAD_RESPONSE,
+        /** Le relais est injoignable / 5xx / timeout. */
+        TRANSIENT
+    }
+}

core/src/main/java/com/loremind/domain/licensing/ports/LicenseRepository.java

@@ -0,0 +1,19 @@
+package com.loremind.domain.licensing.ports;
+
+import com.loremind.domain.licensing.License;
+
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance de la licence installee.
+ * <p>
+ * Une seule licence par instance ({@code id = "current"} par convention).
+ */
+public interface LicenseRepository {
+
+    Optional<License> findCurrent();
+
+    License save(License license);
+
+    void deleteCurrent();
+}

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

@@ -53,12 +53,12 @@ public class BrainAiClient implements AiProvider {
 
     private BrainGeneratePageRequest toBrainRequest(GenerationContext context) {
         return new BrainGeneratePageRequest(
-                context.getLoreName(),
+                context.loreName(),
-                context.getLoreDescription(),
+                context.loreDescription(),
-                context.getFolderName(),
+                context.folderName(),
-                context.getTemplateName(),
+                context.templateName(),
-                context.getTemplateFields(),
+                context.templateFields(),
-                context.getPageTitle()
+                context.pageTitle()
         );
     }
 

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

@@ -5,6 +5,7 @@ import com.loremind.domain.generationcontext.CampaignStructuralContext.ArcSummar
 import com.loremind.domain.generationcontext.CampaignStructuralContext.BranchHint;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.ChapterSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.CharacterSummary;
+import com.loremind.domain.generationcontext.CampaignStructuralContext.NpcSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.SceneSummary;
 import com.loremind.domain.generationcontext.ChatMessage;
 import com.loremind.domain.generationcontext.ChatRequest;
@@ -38,35 +39,35 @@ public class BrainChatPayloadBuilder {
 
     public Map<String, Object> build(ChatRequest request) {
         Map<String, Object> root = new LinkedHashMap<>();
-        root.put("messages", request.getMessages().stream()
+        root.put("messages", request.messages().stream()
                 .map(this::messageToMap)
                 .collect(Collectors.toList()));
 
-        if (request.getLoreContext() != null) {
+        if (request.loreContext() != null) {
-            root.put("lore_context", loreContextToMap(request.getLoreContext()));
+            root.put("lore_context", loreContextToMap(request.loreContext()));
         }
-        if (request.getPageContext() != null) {
+        if (request.pageContext() != null) {
-            root.put("page_context", pageContextToMap(request.getPageContext()));
+            root.put("page_context", pageContextToMap(request.pageContext()));
         }
-        if (request.getCampaignContext() != null) {
+        if (request.campaignContext() != null) {
-            root.put("campaign_context", campaignContextToMap(request.getCampaignContext()));
+            root.put("campaign_context", campaignContextToMap(request.campaignContext()));
         }
-        if (request.getNarrativeEntity() != null) {
+        if (request.narrativeEntity() != null) {
-            root.put("narrative_entity", narrativeEntityToMap(request.getNarrativeEntity()));
+            root.put("narrative_entity", narrativeEntityToMap(request.narrativeEntity()));
         }
-        if (request.getGameSystemContext() != null) {
+        if (request.gameSystemContext() != null) {
-            root.put("game_system_context", gameSystemContextToMap(request.getGameSystemContext()));
+            root.put("game_system_context", gameSystemContextToMap(request.gameSystemContext()));
         }
         return root;
     }
 
     private Map<String, Object> gameSystemContextToMap(GameSystemContext gs) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("system_name", gs.getSystemName());
+        map.put("system_name", gs.systemName());
-        if (gs.getSystemDescription() != null && !gs.getSystemDescription().isBlank()) {
+        if (gs.systemDescription() != null && !gs.systemDescription().isBlank()) {
-            map.put("system_description", gs.getSystemDescription());
+            map.put("system_description", gs.systemDescription());
         }
-        map.put("sections", gs.getSections() != null ? gs.getSections() : Map.of());
+        map.put("sections", gs.sections() != null ? gs.sections() : Map.of());
         return map;
     }
 
@@ -79,67 +80,82 @@ public class BrainChatPayloadBuilder {
 
     private Map<String, Object> loreContextToMap(LoreStructuralContext ctx) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("lore_name", ctx.getLoreName());
+        map.put("lore_name", ctx.loreName());
-        map.put("lore_description", ctx.getLoreDescription());
+        map.put("lore_description", ctx.loreDescription());
 
         Map<String, Object> foldersMap = new LinkedHashMap<>();
-        for (Map.Entry<String, List<PageSummary>> e : ctx.getFolders().entrySet()) {
+        for (Map.Entry<String, List<PageSummary>> e : ctx.folders().entrySet()) {
             foldersMap.put(e.getKey(), e.getValue().stream()
                     .map(this::pageSummaryToMap)
                     .collect(Collectors.toList()));
         }
         map.put("folders", foldersMap);
-        map.put("tags", ctx.getTags());
+        map.put("tags", ctx.tags());
         return map;
     }
 
     private Map<String, Object> pageSummaryToMap(PageSummary ps) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("title", ps.getTitle());
+        map.put("title", ps.title());
-        map.put("template_name", ps.getTemplateName());
+        map.put("template_name", ps.templateName());
         // values/tags/related_page_titles : omis si vides pour alléger le payload.
-        if (ps.getValues() != null && !ps.getValues().isEmpty()) {
+        if (ps.values() != null && !ps.values().isEmpty()) {
-            map.put("values", ps.getValues());
+            map.put("values", ps.values());
         }
-        if (ps.getTags() != null && !ps.getTags().isEmpty()) {
+        if (ps.tags() != null && !ps.tags().isEmpty()) {
-            map.put("tags", ps.getTags());
+            map.put("tags", ps.tags());
         }
-        if (ps.getRelatedPageTitles() != null && !ps.getRelatedPageTitles().isEmpty()) {
+        if (ps.relatedPageTitles() != null && !ps.relatedPageTitles().isEmpty()) {
-            map.put("related_page_titles", ps.getRelatedPageTitles());
+            map.put("related_page_titles", ps.relatedPageTitles());
         }
         return map;
     }
 
     private Map<String, Object> pageContextToMap(PageContext pc) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("title", pc.getTitle());
+        map.put("title", pc.title());
-        map.put("template_name", pc.getTemplateName());
+        map.put("template_name", pc.templateName());
-        map.put("template_fields", pc.getTemplateFields());
+        map.put("template_fields", pc.templateFields());
-        map.put("values", pc.getValues());
+        map.put("values", pc.values());
         return map;
     }
 
     private Map<String, Object> campaignContextToMap(CampaignStructuralContext ctx) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("campaign_name", ctx.getCampaignName());
+        map.put("campaign_name", ctx.campaignName());
-        map.put("campaign_description", ctx.getCampaignDescription());
+        map.put("campaign_description", ctx.campaignDescription());
-        map.put("arcs", ctx.getArcs().stream()
+        map.put("arcs", ctx.arcs().stream()
                 .map(this::arcSummaryToMap)
                 .collect(Collectors.toList()));
         // Liste des PJ : omise si aucun pour alléger le prompt des campagnes sans fiches.
-        if (ctx.getCharacters() != null && !ctx.getCharacters().isEmpty()) {
+        if (ctx.characters() != null && !ctx.characters().isEmpty()) {
-            map.put("characters", ctx.getCharacters().stream()
+            map.put("characters", ctx.characters().stream()
                     .map(this::characterSummaryToMap)
                     .collect(Collectors.toList()));
         }
+        // Liste des PNJ : symétrique aux PJ, omise si vide pour alléger le payload.
+        if (ctx.npcs() != null && !ctx.npcs().isEmpty()) {
+            map.put("npcs", ctx.npcs().stream()
+                    .map(this::npcSummaryToMap)
+                    .collect(Collectors.toList()));
+        }
         return map;
     }
 
     private Map<String, Object> characterSummaryToMap(CharacterSummary c) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("name", c.getName());
+        map.put("name", c.name());
-        if (c.getSnippet() != null && !c.getSnippet().isBlank()) {
+        if (c.snippet() != null && !c.snippet().isBlank()) {
-            map.put("snippet", c.getSnippet());
+            map.put("snippet", c.snippet());
+        }
+        return map;
+    }
+
+    private Map<String, Object> npcSummaryToMap(NpcSummary n) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("name", n.name());
+        if (n.snippet() != null && !n.snippet().isBlank()) {
+            map.put("snippet", n.snippet());
         }
         return map;
     }
@@ -167,10 +183,10 @@ public class BrainChatPayloadBuilder {
     private Map<String, Object> arcSummaryToMap(ArcSummary a) {
         return structuralSummaryToMap(
                 a,
-                ArcSummary::getName,
+                ArcSummary::name,
-                ArcSummary::getDescription,
+                ArcSummary::description,
-                ArcSummary::getIllustrationCount,
+                ArcSummary::illustrationCount,
-                (map, arc) -> map.put("chapters", arc.getChapters().stream()
+                (map, arc) -> map.put("chapters", arc.chapters().stream()
                         .map(this::chapterSummaryToMap)
                         .collect(Collectors.toList())));
     }
@@ -178,10 +194,10 @@ public class BrainChatPayloadBuilder {
     private Map<String, Object> chapterSummaryToMap(ChapterSummary c) {
         return structuralSummaryToMap(
                 c,
-                ChapterSummary::getName,
+                ChapterSummary::name,
-                ChapterSummary::getDescription,
+                ChapterSummary::description,
-                ChapterSummary::getIllustrationCount,
+                ChapterSummary::illustrationCount,
-                (map, chapter) -> map.put("scenes", chapter.getScenes().stream()
+                (map, chapter) -> map.put("scenes", chapter.scenes().stream()
                         .map(this::sceneSummaryToMap)
                         .collect(Collectors.toList())));
     }
@@ -189,13 +205,13 @@ public class BrainChatPayloadBuilder {
     private Map<String, Object> sceneSummaryToMap(SceneSummary s) {
         return structuralSummaryToMap(
                 s,
-                SceneSummary::getName,
+                SceneSummary::name,
-                SceneSummary::getDescription,
+                SceneSummary::description,
-                SceneSummary::getIllustrationCount,
+                SceneSummary::illustrationCount,
                 (map, scene) -> {
                     // Branches narratives : omises si absentes (scènes linéaires classiques).
-                    if (s.getBranches() != null && !s.getBranches().isEmpty()) {
+                    if (s.branches() != null && !s.branches().isEmpty()) {
-                        map.put("branches", s.getBranches().stream()
+                        map.put("branches", s.branches().stream()
                                 .map(this::branchHintToMap)
                                 .collect(Collectors.toList()));
                     }
@@ -204,19 +220,19 @@ public class BrainChatPayloadBuilder {
 
     private Map<String, Object> branchHintToMap(BranchHint b) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("label", b.getLabel());
+        map.put("label", b.label());
-        map.put("target_scene_name", b.getTargetSceneName());
+        map.put("target_scene_name", b.targetSceneName());
-        if (b.getCondition() != null && !b.getCondition().isBlank()) {
+        if (b.condition() != null && !b.condition().isBlank()) {
-            map.put("condition", b.getCondition());
+            map.put("condition", b.condition());
         }
         return map;
     }
 
     private Map<String, Object> narrativeEntityToMap(NarrativeEntityContext ne) {
         Map<String, Object> map = new LinkedHashMap<>();
-        map.put("entity_type", ne.getEntityType());
+        map.put("entity_type", ne.entityType());
-        map.put("title", ne.getTitle());
+        map.put("title", ne.title());
-        map.put("fields", ne.getFields());
+        map.put("fields", ne.fields());
         return map;
     }
 }

core/src/main/java/com/loremind/infrastructure/licensing/FileDockerConfigWriter.java

@@ -0,0 +1,111 @@
+package com.loremind.infrastructure.licensing;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.loremind.domain.licensing.RegistryCredentials;
+import com.loremind.domain.licensing.ports.DockerConfigWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.PosixFilePermissions;
+import java.util.Base64;
+
+/**
+ * Implementation : ecriture du fichier {@code config.json} au format Docker
+ * standard, dans un volume partage avec Watchtower.
+ * <p>
+ * Format produit :
+ * <pre>{@code
+ * {
+ *   "auths": {
+ *     "ghcr.io": {
+ *       "auth": "<base64(username:password)>"
+ *     }
+ *   }
+ * }
+ * }</pre>
+ */
+@Component
+public class FileDockerConfigWriter implements DockerConfigWriter {
+
+    private static final Logger log = LoggerFactory.getLogger(FileDockerConfigWriter.class);
+
+    private final Path configPath;
+    private final ObjectMapper mapper = new ObjectMapper();
+
+    public FileDockerConfigWriter(
+            @Value("${licensing.docker-config-path:/shared/docker/config.json}") String pathStr) {
+        this.configPath = Path.of(pathStr);
+    }
+
+    @Override
+    public void writeCredentials(RegistryCredentials credentials) throws IOException {
+        ensureParentDirectory();
+
+        ObjectNode root;
+        if (Files.exists(configPath)) {
+            try {
+                JsonNode existing = mapper.readTree(configPath.toFile());
+                root = existing.isObject() ? (ObjectNode) existing : mapper.createObjectNode();
+            } catch (IOException e) {
+                log.warn("Existing docker config unreadable, overwriting: {}", e.getMessage());
+                root = mapper.createObjectNode();
+            }
+        } else {
+            root = mapper.createObjectNode();
+        }
+
+        ObjectNode auths = root.has("auths") && root.get("auths").isObject()
+                ? (ObjectNode) root.get("auths")
+                : root.putObject("auths");
+
+        String b64 = Base64.getEncoder().encodeToString(
+                (credentials.username() + ":" + credentials.password()).getBytes(StandardCharsets.UTF_8));
+
+        ObjectNode entry = mapper.createObjectNode();
+        entry.put("auth", b64);
+        auths.set(credentials.registry(), entry);
+
+        Files.writeString(configPath, mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root),
+                StandardCharsets.UTF_8);
+        applyRestrictivePermissions();
+        log.info("Docker config written at {} for registry {}", configPath, credentials.registry());
+    }
+
+    @Override
+    public void clear() throws IOException {
+        if (Files.exists(configPath)) {
+            Files.delete(configPath);
+            log.info("Docker config cleared at {}", configPath);
+        }
+    }
+
+    @Override
+    public boolean isPresent() {
+        return Files.exists(configPath);
+    }
+
+    private void ensureParentDirectory() throws IOException {
+        Path parent = configPath.getParent();
+        if (parent != null && !Files.exists(parent)) {
+            Files.createDirectories(parent);
+        }
+    }
+
+    /** 0600 sur POSIX. Sur Windows (dev), no-op silencieux. */
+    private void applyRestrictivePermissions() {
+        try {
+            Files.setPosixFilePermissions(configPath, PosixFilePermissions.fromString("rw-------"));
+        } catch (UnsupportedOperationException | IOException e) {
+            // Windows / FS qui ne supporte pas POSIX => ignore (le conteneur tourne sous Linux en prod)
+        }
+    }
+
+}

core/src/main/java/com/loremind/infrastructure/licensing/HttpLicenseRelay.java

@@ -0,0 +1,146 @@
+package com.loremind.infrastructure.licensing;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.loremind.domain.licensing.RegistryCredentials;
+import com.loremind.domain.licensing.ports.LicenseRelay;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.HttpServerErrorException;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestTemplate;
+
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+
+/**
+ * Client HTTP du relais OAuth Patreon (deploye sur Cloudflare Workers).
+ * Voir {@code relay/} pour le code du relais.
+ */
+@Component
+public class HttpLicenseRelay implements LicenseRelay {
+
+    private static final Logger log = LoggerFactory.getLogger(HttpLicenseRelay.class);
+
+    private final RestTemplate http;
+    private final String baseUrl;
+
+    public HttpLicenseRelay(
+            RestTemplateBuilder builder,
+            @Value("${licensing.relay.base-url:}") String baseUrl) {
+        this.http = builder
+                .setConnectTimeout(Duration.ofSeconds(5))
+                .setReadTimeout(Duration.ofSeconds(15))
+                .build();
+        this.baseUrl = stripTrailingSlash(baseUrl);
+    }
+
+    @Override
+    public String buildConnectUrl(String instanceId) {
+        if (baseUrl.isBlank()) {
+            throw new IllegalStateException("Licensing relay base URL not configured");
+        }
+        String encoded = URLEncoder.encode(instanceId, StandardCharsets.UTF_8);
+        return baseUrl + "/oauth/start?instance_id=" + encoded;
+    }
+
+    @Override
+    public String refreshToken(String currentJwt) throws RelayException {
+        if (baseUrl.isBlank()) {
+            throw new RelayException(RelayErrorKind.TRANSIENT, "relay not configured");
+        }
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        Map<String, String> body = Map.of("jwt", currentJwt);
+
+        ResponseEntity<JsonNode> resp;
+        try {
+            resp = http.exchange(
+                    baseUrl + "/token/refresh",
+                    HttpMethod.POST,
+                    new HttpEntity<>(body, headers),
+                    JsonNode.class);
+        } catch (HttpClientErrorException e) {
+            throw new RelayException(RelayErrorKind.REJECTED,
+                    "relay rejected refresh: " + e.getStatusCode() + " " + e.getStatusText());
+        } catch (HttpServerErrorException e) {
+            throw new RelayException(RelayErrorKind.TRANSIENT,
+                    "relay 5xx: " + e.getStatusCode());
+        } catch (RestClientException e) {
+            throw new RelayException(RelayErrorKind.TRANSIENT, "relay unreachable: " + e.getMessage(), e);
+        }
+
+        JsonNode payload = resp.getBody();
+        if (payload == null || !payload.hasNonNull("jwt")) {
+            throw new RelayException(RelayErrorKind.BAD_RESPONSE, "missing jwt in refresh response");
+        }
+        return payload.get("jwt").asText();
+    }
+
+    @Override
+    public RegistryCredentials fetchRegistryCredentials(String currentJwt) throws RelayException {
+        if (baseUrl.isBlank()) {
+            throw new RelayException(RelayErrorKind.TRANSIENT, "relay not configured");
+        }
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        Map<String, String> body = Map.of("jwt", currentJwt);
+
+        ResponseEntity<JsonNode> resp;
+        try {
+            resp = http.exchange(
+                    baseUrl + "/registry/credentials",
+                    HttpMethod.POST,
+                    new HttpEntity<>(body, headers),
+                    JsonNode.class);
+        } catch (HttpClientErrorException e) {
+            throw new RelayException(RelayErrorKind.REJECTED,
+                    "relay rejected creds: " + e.getStatusCode() + " " + e.getStatusText());
+        } catch (HttpServerErrorException e) {
+            throw new RelayException(RelayErrorKind.TRANSIENT,
+                    "relay 5xx: " + e.getStatusCode());
+        } catch (RestClientException e) {
+            throw new RelayException(RelayErrorKind.TRANSIENT, "relay unreachable: " + e.getMessage(), e);
+        }
+
+        JsonNode payload = resp.getBody();
+        if (payload == null
+                || !payload.hasNonNull("registry")
+                || !payload.hasNonNull("username")
+                || !payload.hasNonNull("password")) {
+            throw new RelayException(RelayErrorKind.BAD_RESPONSE, "incomplete credentials response");
+        }
+        Instant expiresAt = null;
+        if (payload.hasNonNull("expires_at")) {
+            try {
+                expiresAt = Instant.parse(payload.get("expires_at").asText());
+            } catch (Exception e) {
+                log.warn("Cannot parse expires_at from relay creds response: {}", e.getMessage());
+            }
+        }
+        return new RegistryCredentials(
+                payload.get("registry").asText(),
+                payload.get("username").asText(),
+                payload.get("password").asText(),
+                expiresAt
+        );
+    }
+
+    private static String stripTrailingSlash(String s) {
+        if (s == null) return "";
+        String v = s.trim();
+        if (v.endsWith("/")) v = v.substring(0, v.length() - 1);
+        return v;
+    }
+}

core/src/main/java/com/loremind/infrastructure/licensing/LicenseRefreshDaemon.java

@@ -0,0 +1,93 @@
+package com.loremind.infrastructure.licensing;
+
+import com.loremind.application.licensing.LicenseService;
+import com.loremind.domain.licensing.LicenseSnapshot;
+import com.loremind.domain.licensing.LicenseStatus;
+import com.loremind.domain.licensing.RegistryCredentials;
+import com.loremind.domain.licensing.ports.DockerConfigWriter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.util.Optional;
+
+/**
+ * Daemon planifie qui :
+ * <ul>
+ *   <li>renouvelle le JWT licence via le relais avant expiration (J-2)</li>
+ *   <li>met a jour les credentials registry GHCR pour Watchtower
+ *       (volume partage docker-config) tant que le canal beta est ON</li>
+ *   <li>nettoie les credentials si la licence est invalidee ou le toggle OFF</li>
+ * </ul>
+ * Idempotent : peut tourner toutes les 6h sans risque, fait du no-op
+ * la plupart du temps.
+ */
+@Component
+public class LicenseRefreshDaemon {
+
+    private static final Logger log = LoggerFactory.getLogger(LicenseRefreshDaemon.class);
+
+    /** 6 heures entre chaque cycle. Suffisant pour rattraper un J-2 sans surcharger. */
+    private static final long FIXED_DELAY_MS = 6L * 60L * 60L * 1000L;
+    /** Premier run apres 30s pour laisser le contexte Spring se stabiliser. */
+    private static final long INITIAL_DELAY_MS = 30_000L;
+
+    private final LicenseService licenseService;
+    private final DockerConfigWriter dockerConfigWriter;
+
+    public LicenseRefreshDaemon(LicenseService licenseService,
+                                DockerConfigWriter dockerConfigWriter) {
+        this.licenseService = licenseService;
+        this.dockerConfigWriter = dockerConfigWriter;
+    }
+
+    @Scheduled(initialDelay = INITIAL_DELAY_MS, fixedDelay = FIXED_DELAY_MS)
+    public void tick() {
+        if (!licenseService.isLicensingEnabled()) {
+            return;
+        }
+        try {
+            licenseService.refreshIfNeeded();
+            syncDockerConfig();
+        } catch (Exception e) {
+            log.error("LicenseRefreshDaemon tick failed: {}", e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Aligne le fichier docker config avec l'etat de la licence et le toggle :
+     * <ul>
+     *   <li>VALID/GRACE + beta ON  -> ecrit/refresh les creds</li>
+     *   <li>tout autre cas         -> efface le fichier</li>
+     * </ul>
+     */
+    private void syncDockerConfig() {
+        LicenseSnapshot snap = licenseService.getCurrentSnapshot();
+        boolean shouldHaveCreds = snap.betaChannelEnabled()
+                && (snap.status() == LicenseStatus.VALID || snap.status() == LicenseStatus.GRACE);
+
+        if (!shouldHaveCreds) {
+            try {
+                if (dockerConfigWriter.isPresent()) {
+                    dockerConfigWriter.clear();
+                }
+            } catch (IOException e) {
+                log.warn("Cannot clear docker config: {}", e.getMessage());
+            }
+            return;
+        }
+
+        Optional<RegistryCredentials> creds = licenseService.fetchRegistryCredentials();
+        if (creds.isEmpty()) {
+            log.warn("Beta enabled but cannot fetch registry credentials (relay down or rejected)");
+            return;
+        }
+        try {
+            dockerConfigWriter.writeCredentials(creds.get());
+        } catch (IOException e) {
+            log.error("Cannot write docker config: {}", e.getMessage());
+        }
+    }
+}

core/src/main/java/com/loremind/infrastructure/licensing/NimbusJwtVerifier.java

@@ -0,0 +1,188 @@
+package com.loremind.infrastructure.licensing;
+
+import com.loremind.domain.licensing.LicenseClaims;
+import com.loremind.domain.licensing.ports.JwtVerifier;
+import com.nimbusds.jose.JWSAlgorithm;
+import com.nimbusds.jose.JWSVerifier;
+import com.nimbusds.jose.crypto.Ed25519Verifier;
+import com.nimbusds.jose.jwk.OctetKeyPair;
+import com.nimbusds.jwt.JWTClaimsSet;
+import com.nimbusds.jwt.SignedJWT;
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import org.springframework.core.io.ClassPathResource;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.text.ParseException;
+import java.util.Base64;
+import java.util.Date;
+
+/**
+ * Verifie les JWT EdDSA/Ed25519 emis par le relais Patreon.
+ * <p>
+ * La cle publique est fournie en PEM SPKI via la propriete
+ * {@code licensing.jwt.public-key} (env {@code LICENSING_JWT_PUBLIC_KEY}).
+ * Si la cle est absente ou invalide, {@link #isConfigured()} retourne false
+ * et {@link #verify} echoue systematiquement — la feature licensing est
+ * desactivee silencieusement.
+ */
+@Component
+public class NimbusJwtVerifier implements JwtVerifier {
+
+    private static final Logger log = LoggerFactory.getLogger(NimbusJwtVerifier.class);
+
+    private final String expectedIssuer;
+    private final String expectedAudience;
+    private final OctetKeyPair publicKey;
+
+    public NimbusJwtVerifier(
+            @Value("${licensing.jwt.public-key:}") String publicKeyPemFromEnv,
+            @Value("${licensing.jwt.expected-issuer:loremind-auth}") String expectedIssuer,
+            @Value("${licensing.jwt.expected-audience:loremind-instance}") String expectedAudience) {
+        this.expectedIssuer = expectedIssuer;
+        this.expectedAudience = expectedAudience;
+        // Strategie : env var en priorite (rotation possible sans rebuild),
+        // sinon ressource classpath embarquee dans le binaire.
+        String pem = (publicKeyPemFromEnv != null && !publicKeyPemFromEnv.isBlank())
+                ? publicKeyPemFromEnv
+                : loadEmbeddedKey();
+        this.publicKey = parsePemSpki(pem);
+        if (publicKey == null) {
+            log.info("Licensing JWT verifier disabled (no public key found)");
+        } else {
+            String source = (publicKeyPemFromEnv != null && !publicKeyPemFromEnv.isBlank()) ? "env" : "embedded";
+            log.info("Licensing JWT verifier enabled (issuer={}, audience={}, key source={})",
+                    expectedIssuer, expectedAudience, source);
+        }
+    }
+
+    /**
+     * Charge la cle publique embarquee dans le binaire (resource classpath).
+     * Le fichier est un PEM SPKI standard, fourni a la build pour chaque
+     * release. Si absent, la feature licensing est desactivee.
+     */
+    private static String loadEmbeddedKey() {
+        ClassPathResource resource = new ClassPathResource("licensing/jwt-public-key.pem");
+        if (!resource.exists()) {
+            return null;
+        }
+        try (InputStream in = resource.getInputStream()) {
+            return new String(in.readAllBytes(), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            log.warn("Cannot read embedded JWT public key: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    @Override
+    public boolean isConfigured() {
+        return publicKey != null;
+    }
+
+    @Override
+    public LicenseClaims verify(String rawJwt) throws JwtVerificationException {
+        if (publicKey == null) {
+            throw new JwtVerificationException("JWT verifier not configured");
+        }
+        if (rawJwt == null || rawJwt.isBlank()) {
+            throw new JwtVerificationException("JWT is empty");
+        }
+
+        SignedJWT signed;
+        try {
+            signed = SignedJWT.parse(rawJwt);
+        } catch (ParseException e) {
+            throw new JwtVerificationException("JWT parse error: " + e.getMessage(), e);
+        }
+
+        JWSAlgorithm alg = signed.getHeader().getAlgorithm();
+        if (!JWSAlgorithm.EdDSA.equals(alg)) {
+            throw new JwtVerificationException("Unexpected JWT algorithm: " + alg);
+        }
+
+        try {
+            JWSVerifier verifier = new Ed25519Verifier(publicKey);
+            if (!signed.verify(verifier)) {
+                throw new JwtVerificationException("JWT signature invalid");
+            }
+        } catch (Exception e) {
+            throw new JwtVerificationException("JWT signature verification failed: " + e.getMessage(), e);
+        }
+
+        JWTClaimsSet claims;
+        try {
+            claims = signed.getJWTClaimsSet();
+        } catch (ParseException e) {
+            throw new JwtVerificationException("JWT claims parse error", e);
+        }
+
+        if (!expectedIssuer.equals(claims.getIssuer())) {
+            throw new JwtVerificationException("JWT issuer mismatch: " + claims.getIssuer());
+        }
+        if (claims.getAudience() == null || !claims.getAudience().contains(expectedAudience)) {
+            throw new JwtVerificationException("JWT audience mismatch");
+        }
+
+        Date exp = claims.getExpirationTime();
+        Date iat = claims.getIssueTime();
+        String sub = claims.getSubject();
+        if (exp == null || iat == null || sub == null) {
+            throw new JwtVerificationException("JWT missing required claims");
+        }
+
+        // Note : on ne refuse pas un JWT expire ici. C'est au LicenseService
+        // de decider ce qu'il fait d'un JWT expire (grace period, refresh, etc.).
+        // La verification de signature reste valide tant que la cle existe.
+
+        String tierId;
+        String instanceId;
+        try {
+            tierId = claims.getStringClaim("tier_id");
+            instanceId = claims.getStringClaim("instance_id");
+        } catch (ParseException e) {
+            throw new JwtVerificationException("JWT custom claim parse error", e);
+        }
+        if (tierId == null || tierId.isBlank() || instanceId == null || instanceId.isBlank()) {
+            throw new JwtVerificationException("JWT missing tier_id or instance_id");
+        }
+
+        return new LicenseClaims(
+                sub,
+                tierId,
+                instanceId,
+                iat.toInstant(),
+                exp.toInstant()
+        );
+    }
+
+    /**
+     * Parse une cle publique Ed25519 au format PEM SPKI vers un Nimbus
+     * {@link OctetKeyPair} (forme JWK utilisee pour la verification).
+     */
+    private static OctetKeyPair parsePemSpki(String pem) {
+        if (pem == null || pem.isBlank()) return null;
+        try {
+            String base64 = pem
+                    .replace("-----BEGIN PUBLIC KEY-----", "")
+                    .replace("-----END PUBLIC KEY-----", "")
+                    .replaceAll("\\s+", "");
+            byte[] der = Base64.getDecoder().decode(base64);
+            SubjectPublicKeyInfo spki = SubjectPublicKeyInfo.getInstance(ASN1Sequence.fromByteArray(der));
+            byte[] keyBytes = spki.getPublicKeyData().getOctets();
+            String x = Base64.getUrlEncoder().withoutPadding().encodeToString(keyBytes);
+            return new OctetKeyPair.Builder(com.nimbusds.jose.jwk.Curve.Ed25519, com.nimbusds.jose.util.Base64URL.from(x))
+                    .build();
+        } catch (IOException | IllegalArgumentException e) {
+            log.warn("Cannot parse licensing JWT public key: {}", e.getMessage());
+            return null;
+        }
+    }
+
+}

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

@@ -37,6 +37,9 @@ public class ArcJpaEntity {
     @Column(name = "\"order\"", nullable = false)
     private int order;
 
+    @Column
+    private String icon;
+
     // Champs narratifs enrichis — ajoutés automatiquement par Hibernate DDL (ddl-auto=update)
     @Column(columnDefinition = "TEXT")
     private String themes;

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

@@ -37,6 +37,9 @@ public class ChapterJpaEntity {
     @Column(name = "\"order\"", nullable = false)
     private int order;
 
+    @Column
+    private String icon;
+
     // Champs narratifs enrichis — ajoutés automatiquement par Hibernate DDL (ddl-auto=update)
     @Column(name = "gm_notes", columnDefinition = "TEXT")
     private String gmNotes;

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

@@ -0,0 +1,72 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.Instant;
+
+/**
+ * Entite JPA pour la licence Patreon installee.
+ * <p>
+ * Singleton : une seule ligne par instance (id = "current"). Ce design permet
+ * de ne jamais avoir de licence "fantome" en base et de simplifier les queries.
+ */
+@Entity
+@Table(name = "licenses")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class LicenseJpaEntity {
+
+    @Id
+    private String id;
+
+    @Column(name = "raw_jwt", columnDefinition = "TEXT", nullable = false)
+    private String rawJwt;
+
+    @Column(name = "patreon_user_id", nullable = false)
+    private String patreonUserId;
+
+    @Column(name = "tier_id", nullable = false)
+    private String tierId;
+
+    @Column(name = "instance_id", nullable = false)
+    private String instanceId;
+
+    @Column(name = "issued_at", nullable = false)
+    private Instant issuedAt;
+
+    @Column(name = "expires_at", nullable = false)
+    private Instant expiresAt;
+
+    @Column(name = "last_refresh_attempt_at")
+    private Instant lastRefreshAttemptAt;
+
+    @Column(name = "last_refresh_succeeded", nullable = false)
+    private boolean lastRefreshSucceeded;
+
+    @Column(name = "beta_channel_enabled", nullable = false)
+    private boolean betaChannelEnabled;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private Instant createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private Instant updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        Instant now = Instant.now();
+        if (createdAt == null) createdAt = now;
+        updatedAt = now;
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour les fiches de PNJ d'une campagne.
+ * Pas de FK physique vers campaigns (weak reference cross-agrégat intra-contexte).
+ */
+@Entity
+@Table(name = "npcs")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class NpcJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(name = "markdown_content", columnDefinition = "TEXT")
+    private String markdownContent;
+
+    @Column(name = "campaign_id", nullable = false)
+    private Long campaignId;
+
+    @Column(name = "\"order\"", nullable = false)
+    private int order;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

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

@@ -39,6 +39,9 @@ public class SceneJpaEntity {
     @Column(name = "\"order\"", nullable = false)
     private int order;
 
+    @Column
+    private String icon;
+
     // Champs narratifs enrichis — ajoutés automatiquement par Hibernate (ddl-auto=update)
 
     // Contexte et ambiance

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

@@ -0,0 +1,9 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.LicenseJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface LicenseJpaRepository extends JpaRepository<LicenseJpaEntity, String> {
+}

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

@@ -0,0 +1,13 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.NpcJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface NpcJpaRepository extends JpaRepository<NpcJpaEntity, Long> {
+
+    List<NpcJpaEntity> findByCampaignIdOrderByOrderAsc(Long campaignId);
+}

core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresArcRepository.java

@@ -71,6 +71,7 @@ public class PostgresArcRepository implements ArcRepository {
                 .description(jpaEntity.getDescription())
                 .campaignId(jpaEntity.getCampaignId().toString())
                 .order(jpaEntity.getOrder())
+                .icon(jpaEntity.getIcon())
                 .themes(jpaEntity.getThemes())
                 .stakes(jpaEntity.getStakes())
                 .gmNotes(jpaEntity.getGmNotes())
@@ -99,6 +100,7 @@ public class PostgresArcRepository implements ArcRepository {
                 .description(arc.getDescription())
                 .campaignId(Long.parseLong(arc.getCampaignId()))
                 .order(arc.getOrder())
+                .icon(arc.getIcon())
                 .themes(arc.getThemes())
                 .stakes(arc.getStakes())
                 .gmNotes(arc.getGmNotes())

core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresChapterRepository.java

@@ -71,6 +71,7 @@ public class PostgresChapterRepository implements ChapterRepository {
                 .description(jpaEntity.getDescription())
                 .arcId(jpaEntity.getArcId().toString())
                 .order(jpaEntity.getOrder())
+                .icon(jpaEntity.getIcon())
                 .gmNotes(jpaEntity.getGmNotes())
                 .playerObjectives(jpaEntity.getPlayerObjectives())
                 .narrativeStakes(jpaEntity.getNarrativeStakes())
@@ -96,6 +97,7 @@ public class PostgresChapterRepository implements ChapterRepository {
                 .description(chapter.getDescription())
                 .arcId(Long.parseLong(chapter.getArcId()))
                 .order(chapter.getOrder())
+                .icon(chapter.getIcon())
                 .gmNotes(chapter.getGmNotes())
                 .playerObjectives(chapter.getPlayerObjectives())
                 .narrativeStakes(chapter.getNarrativeStakes())

core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLicenseRepository.java

@@ -0,0 +1,76 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.licensing.License;
+import com.loremind.domain.licensing.ports.LicenseRepository;
+import com.loremind.infrastructure.persistence.entity.LicenseJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.LicenseJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.Instant;
+import java.util.Optional;
+
+@Repository
+public class PostgresLicenseRepository implements LicenseRepository {
+
+    static final String CURRENT_ID = "current";
+
+    private final LicenseJpaRepository jpa;
+
+    public PostgresLicenseRepository(LicenseJpaRepository jpa) {
+        this.jpa = jpa;
+    }
+
+    @Override
+    public Optional<License> findCurrent() {
+        return jpa.findById(CURRENT_ID).map(this::toDomain);
+    }
+
+    @Override
+    public License save(License license) {
+        LicenseJpaEntity entity = toEntity(license);
+        if (entity.getCreatedAt() == null) {
+            entity.setCreatedAt(Instant.now());
+        }
+        LicenseJpaEntity saved = jpa.save(entity);
+        return toDomain(saved);
+    }
+
+    @Override
+    public void deleteCurrent() {
+        jpa.deleteById(CURRENT_ID);
+    }
+
+    private License toDomain(LicenseJpaEntity e) {
+        return License.builder()
+                .id(e.getId())
+                .rawJwt(e.getRawJwt())
+                .patreonUserId(e.getPatreonUserId())
+                .tierId(e.getTierId())
+                .instanceId(e.getInstanceId())
+                .issuedAt(e.getIssuedAt())
+                .expiresAt(e.getExpiresAt())
+                .lastRefreshAttemptAt(e.getLastRefreshAttemptAt())
+                .lastRefreshSucceeded(e.isLastRefreshSucceeded())
+                .betaChannelEnabled(e.isBetaChannelEnabled())
+                .createdAt(e.getCreatedAt())
+                .updatedAt(e.getUpdatedAt())
+                .build();
+    }
+
+    private LicenseJpaEntity toEntity(License l) {
+        return LicenseJpaEntity.builder()
+                .id(CURRENT_ID)
+                .rawJwt(l.getRawJwt())
+                .patreonUserId(l.getPatreonUserId())
+                .tierId(l.getTierId())
+                .instanceId(l.getInstanceId())
+                .issuedAt(l.getIssuedAt())
+                .expiresAt(l.getExpiresAt())
+                .lastRefreshAttemptAt(l.getLastRefreshAttemptAt())
+                .lastRefreshSucceeded(l.isLastRefreshSucceeded())
+                .betaChannelEnabled(l.isBetaChannelEnabled())
+                .createdAt(l.getCreatedAt())
+                .updatedAt(l.getUpdatedAt())
+                .build();
+    }
+}

core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresNpcRepository.java

@@ -0,0 +1,75 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
+import com.loremind.infrastructure.persistence.entity.NpcJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.NpcJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Repository
+public class PostgresNpcRepository implements NpcRepository {
+
+    private final NpcJpaRepository jpaRepository;
+
+    public PostgresNpcRepository(NpcJpaRepository jpaRepository) {
+        this.jpaRepository = jpaRepository;
+    }
+
+    @Override
+    public Npc save(Npc npc) {
+        NpcJpaEntity entity = toJpaEntity(npc);
+        NpcJpaEntity saved = jpaRepository.save(entity);
+        return toDomainEntity(saved);
+    }
+
+    @Override
+    public Optional<Npc> findById(String id) {
+        return jpaRepository.findById(Long.parseLong(id)).map(this::toDomainEntity);
+    }
+
+    @Override
+    public List<Npc> findByCampaignId(String campaignId) {
+        return jpaRepository.findByCampaignIdOrderByOrderAsc(Long.parseLong(campaignId)).stream()
+                .map(this::toDomainEntity)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpaRepository.deleteById(Long.parseLong(id));
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpaRepository.existsById(Long.parseLong(id));
+    }
+
+    private Npc toDomainEntity(NpcJpaEntity e) {
+        return Npc.builder()
+                .id(e.getId().toString())
+                .name(e.getName())
+                .markdownContent(e.getMarkdownContent())
+                .campaignId(e.getCampaignId().toString())
+                .order(e.getOrder())
+                .createdAt(e.getCreatedAt())
+                .updatedAt(e.getUpdatedAt())
+                .build();
+    }
+
+    private NpcJpaEntity toJpaEntity(Npc n) {
+        Long id = n.getId() != null ? Long.parseLong(n.getId()) : null;
+        return NpcJpaEntity.builder()
+                .id(id)
+                .name(n.getName())
+                .markdownContent(n.getMarkdownContent())
+                .campaignId(Long.parseLong(n.getCampaignId()))
+                .order(n.getOrder())
+                .createdAt(n.getCreatedAt())
+                .updatedAt(n.getUpdatedAt())
+                .build();
+    }
+}

core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresSceneRepository.java

@@ -71,6 +71,7 @@ public class PostgresSceneRepository implements SceneRepository {
                 .description(jpaEntity.getDescription())
                 .chapterId(jpaEntity.getChapterId().toString())
                 .order(jpaEntity.getOrder())
+                .icon(jpaEntity.getIcon())
                 .location(jpaEntity.getLocation())
                 .timing(jpaEntity.getTiming())
                 .atmosphere(jpaEntity.getAtmosphere())
@@ -104,6 +105,7 @@ public class PostgresSceneRepository implements SceneRepository {
                 .description(scene.getDescription())
                 .chapterId(Long.parseLong(scene.getChapterId()))
                 .order(scene.getOrder())
+                .icon(scene.getIcon())
                 .location(scene.getLocation())
                 .timing(scene.getTiming())
                 .atmosphere(scene.getAtmosphere())

core/src/main/java/com/loremind/infrastructure/updates/UpdateCheckService.java

@@ -0,0 +1,459 @@
+package com.loremind.infrastructure.updates;
+
+import com.loremind.application.licensing.LicenseService;
+import com.loremind.domain.licensing.LicenseSnapshot;
+import com.loremind.domain.licensing.LicenseStatus;
+import com.loremind.domain.licensing.RegistryCredentials;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.info.BuildProperties;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.lang.Nullable;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.RestTemplate;
+
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Detection des mises a jour disponibles + declenchement via Watchtower.
+ * <p>
+ * <b>Strategie</b> : comparaison de versions semver, pas de digests.
+ * <ul>
+ *   <li>La version courante de l'app est lue depuis {@link BuildProperties}
+ *       (genere par spring-boot-maven-plugin dans META-INF/build-info.properties).</li>
+ *   <li>Pour chaque image suivie, on interroge le registry sur
+ *       {@code /v2/<image>/tags/list}, on extrait les tags semver, on prend le max.</li>
+ *   <li>Si max > version courante => UPDATE_AVAILABLE.</li>
+ *   <li>Si max == version courante => UP_TO_DATE.</li>
+ *   <li>Si registry injoignable ou aucun tag valide => UNKNOWN.</li>
+ * </ul>
+ *
+ * <b>Pourquoi pas les digests ?</b> Le bug historique etait : le baseline-digest
+ * pose au @PostConstruct supposait que le pull venait d'avoir lieu (vrai apres
+ * `docker compose pull && up -d`, faux apres un simple restart de daemon ou un
+ * OOM). La version semver lue depuis le binaire est <b>fiable par construction</b> :
+ * c'est ce que le code source declare faire tourner.
+ */
+@Service
+public class UpdateCheckService {
+
+    private static final Logger log = LoggerFactory.getLogger(UpdateCheckService.class);
+
+    private final RestTemplate http;
+    private final String registry;
+    private final List<String> images;
+    private final String watchtowerUrl;
+    private final String watchtowerToken;
+    private final List<String> betaImages;
+    private final LicenseService licenseService;
+    /** Version semver courante du binaire (ex: "0.8.0"). Source de verite. */
+    private final String currentVersion;
+
+    public UpdateCheckService(
+            RestTemplateBuilder builder,
+            @Value("${update-check.registry:}") String registry,
+            @Value("${update-check.images:}") String imagesCsv,
+            @Value("${update-check.watchtower-url:http://watchtower:8080}") String watchtowerUrl,
+            @Value("${update-check.watchtower-token:}") String watchtowerToken,
+            @Value("${licensing.beta.images:}") String betaImagesCsv,
+            LicenseService licenseService,
+            @Nullable BuildProperties buildProperties) {
+        this.http = builder
+                .setConnectTimeout(Duration.ofSeconds(5))
+                .setReadTimeout(Duration.ofSeconds(15))
+                .build();
+        this.registry = normalizeRegistry(registry);
+        this.images = parseImages(imagesCsv);
+        this.watchtowerUrl = watchtowerUrl;
+        this.watchtowerToken = watchtowerToken;
+        this.betaImages = parseImages(betaImagesCsv);
+        this.licenseService = licenseService;
+        this.currentVersion = buildProperties != null ? buildProperties.getVersion() : null;
+        log.info("Update check init - registry={} images={} currentVersion={}",
+                this.registry, this.images, this.currentVersion);
+    }
+
+    public boolean isEnabled() {
+        return watchtowerToken != null && !watchtowerToken.isBlank() && !images.isEmpty();
+    }
+
+    /**
+     * @return version courante exposee aux endpoints (ex: pour affichage UI).
+     *         {@code null} si build-info.properties absent (dev en IDE sans build Maven).
+     */
+    public String getCurrentVersion() {
+        return currentVersion;
+    }
+
+    public UpdateStatus check() {
+        if (!isEnabled()) {
+            return new UpdateStatus(false, false, false, null, List.of(), Instant.now());
+        }
+        if (currentVersion == null) {
+            log.warn("Update check : currentVersion absente (build-info manquant). Tous UNKNOWN.");
+            List<ImageStatus> statuses = new ArrayList<>();
+            for (String image : images) {
+                statuses.add(new ImageStatus(image, null, null, ImageStatusKind.UNKNOWN));
+            }
+            return new UpdateStatus(true, false, true, null, statuses, Instant.now());
+        }
+
+        List<ImageStatus> statuses = new ArrayList<>();
+        boolean anyUpdate = false;
+        boolean anyUnknown = false;
+        for (String image : images) {
+            String latest = null;
+            try {
+                latest = fetchLatestSemverTag(registry, image, null);
+            } catch (Exception e) {
+                log.warn("Tags fetch failed for {}: {}", image, e.getMessage());
+            }
+            ImageStatusKind kind;
+            if (latest == null) {
+                kind = ImageStatusKind.UNKNOWN;
+                anyUnknown = true;
+            } else {
+                int cmp = compareSemver(currentVersion, latest);
+                if (cmp >= 0) {
+                    kind = ImageStatusKind.UP_TO_DATE;
+                } else {
+                    kind = ImageStatusKind.UPDATE_AVAILABLE;
+                    anyUpdate = true;
+                }
+            }
+            statuses.add(new ImageStatus(image, currentVersion, latest, kind));
+        }
+        return new UpdateStatus(true, anyUpdate, anyUnknown, currentVersion, statuses, Instant.now());
+    }
+
+    /**
+     * Verifie l'etat du canal beta (images privees GHCR) avec auth basique.
+     */
+    public BetaStatus checkBeta() {
+        if (!licenseService.isLicensingEnabled()) {
+            return BetaStatus.disabled("licensing-not-configured");
+        }
+        LicenseSnapshot snap = licenseService.getCurrentSnapshot();
+        if (snap.status() != LicenseStatus.VALID && snap.status() != LicenseStatus.GRACE) {
+            return BetaStatus.disabled("license-" + snap.status().name().toLowerCase());
+        }
+        if (!snap.betaChannelEnabled()) {
+            return BetaStatus.disabled("beta-toggle-off");
+        }
+        if (betaImages.isEmpty()) {
+            return BetaStatus.disabled("no-beta-images-configured");
+        }
+
+        Optional<RegistryCredentials> creds = licenseService.fetchRegistryCredentials();
+        if (creds.isEmpty()) {
+            return new BetaStatus(true, false, true, List.of(), Instant.now(), "relay-unavailable");
+        }
+
+        String basicAuth = "Basic " + Base64.getEncoder().encodeToString(
+                (creds.get().username() + ":" + creds.get().password()).getBytes(StandardCharsets.UTF_8));
+        String betaRegistry = normalizeRegistry(creds.get().registry());
+
+        List<ImageStatus> statuses = new ArrayList<>();
+        boolean anyUpdate = false;
+        boolean anyUnknown = false;
+        for (String image : betaImages) {
+            String latest = null;
+            try {
+                latest = fetchLatestSemverTag(betaRegistry, image, basicAuth);
+            } catch (Exception e) {
+                log.warn("Beta tags fetch failed for {}: {}", image, e.getMessage());
+            }
+            ImageStatusKind kind;
+            if (latest == null) {
+                kind = ImageStatusKind.UNKNOWN;
+                anyUnknown = true;
+            } else if (currentVersion != null && compareSemver(currentVersion, latest) >= 0) {
+                kind = ImageStatusKind.UP_TO_DATE;
+            } else {
+                kind = ImageStatusKind.UPDATE_AVAILABLE;
+                anyUpdate = true;
+            }
+            statuses.add(new ImageStatus(image, currentVersion, latest, kind));
+        }
+        return new BetaStatus(true, anyUpdate, anyUnknown, statuses, Instant.now(), null);
+    }
+
+    public void apply() {
+        if (!isEnabled()) {
+            throw new IllegalStateException("Update apply not configured (WATCHTOWER_TOKEN missing)");
+        }
+        HttpHeaders headers = new HttpHeaders();
+        headers.setBearerAuth(watchtowerToken);
+        http.exchange(
+                watchtowerUrl + "/v1/update",
+                HttpMethod.POST,
+                new HttpEntity<>(headers),
+                Void.class);
+    }
+
+    // -----------------------------------------------------------------------
+    // Registry HTTP API v2 - tags listing + auth bearer
+    // -----------------------------------------------------------------------
+
+    /**
+     * Interroge le registry pour la liste des tags d'une image, parse les
+     * versions semver et retourne la plus elevee. {@code null} si echec
+     * ou aucun tag valide.
+     *
+     * @param registryUrl URL normalisee (ex: "https://ghcr.io")
+     * @param image       nom de l'image (ex: "igmlcreation/loremind-core")
+     * @param authHeader  optionnel - "Basic ..." pour les registries prives
+     */
+    private String fetchLatestSemverTag(String registryUrl, String image, @Nullable String authHeader) {
+        String url = registryUrl + "/v2/" + image + "/tags/list";
+        HttpHeaders headers = new HttpHeaders();
+        headers.setAccept(List.of(MediaType.APPLICATION_JSON));
+        if (authHeader != null) {
+            headers.set(HttpHeaders.AUTHORIZATION, authHeader);
+        }
+        TagsListResponse body;
+        try {
+            body = tagsCall(url, headers);
+        } catch (HttpClientErrorException.Unauthorized e) {
+            String www = e.getResponseHeaders() == null ? null
+                    : e.getResponseHeaders().getFirst(HttpHeaders.WWW_AUTHENTICATE);
+            String token = obtainBearerToken(www, authHeader);
+            if (token == null) {
+                log.warn("Cannot obtain bearer token for {} (registry response: {})", image, www);
+                return null;
+            }
+            HttpHeaders bearerHeaders = new HttpHeaders();
+            bearerHeaders.setAccept(List.of(MediaType.APPLICATION_JSON));
+            bearerHeaders.setBearerAuth(token);
+            body = tagsCall(url, bearerHeaders);
+        }
+        if (body == null || body.tags == null || body.tags.isEmpty()) return null;
+        return findMaxSemver(body.tags);
+    }
+
+    private TagsListResponse tagsCall(String url, HttpHeaders headers) {
+        ResponseEntity<TagsListResponse> resp = http.exchange(
+                url, HttpMethod.GET, new HttpEntity<>(headers), TagsListResponse.class);
+        return resp.getBody();
+    }
+
+    /**
+     * Parcourt la liste des tags, garde uniquement ceux qui parsent en semver
+     * (1 a 3 chiffres separes par des points, optionnel prefix "v"), retourne le max.
+     * Pre-release / build metadata sont strippes pour la comparaison.
+     */
+    @Nullable
+    static String findMaxSemver(List<String> tags) {
+        String maxTag = null;
+        int[] maxParts = null;
+        for (String t : tags) {
+            if (t == null || t.isBlank()) continue;
+            int[] parts = parseSemver(t);
+            if (parts == null) continue;
+            if (maxParts == null || compareParts(parts, maxParts) > 0) {
+                maxParts = parts;
+                maxTag = t;
+            }
+        }
+        return maxTag;
+    }
+
+    /** @return [major, minor, patch] ou null si non parsable. */
+    @Nullable
+    static int[] parseSemver(String tag) {
+        if (tag == null) return null;
+        String s = tag.trim();
+        if (s.isEmpty()) return null;
+        if (s.startsWith("v") || s.startsWith("V")) s = s.substring(1);
+        int dashIdx = s.indexOf('-');
+        if (dashIdx > 0) s = s.substring(0, dashIdx);
+        int plusIdx = s.indexOf('+');
+        if (plusIdx > 0) s = s.substring(0, plusIdx);
+        String[] parts = s.split("\\.");
+        if (parts.length < 1 || parts.length > 3) return null;
+        int[] result = new int[]{0, 0, 0};
+        for (int i = 0; i < parts.length; i++) {
+            try {
+                int v = Integer.parseInt(parts[i]);
+                if (v < 0) return null;
+                result[i] = v;
+            } catch (NumberFormatException e) {
+                return null;
+            }
+        }
+        return result;
+    }
+
+    /** Compare deux versions semver brutes (sans prefix). Negatif si a < b. */
+    static int compareSemver(String a, String b) {
+        int[] aParts = parseSemver(a);
+        int[] bParts = parseSemver(b);
+        if (aParts == null || bParts == null) return 0;
+        return compareParts(aParts, bParts);
+    }
+
+    private static int compareParts(int[] a, int[] b) {
+        for (int i = 0; i < 3; i++) {
+            int diff = Integer.compare(a[i], b[i]);
+            if (diff != 0) return diff;
+        }
+        return 0;
+    }
+
+    /**
+     * Suit le challenge {@code WWW-Authenticate: Bearer realm="..."} pour obtenir
+     * un token. Si {@code basicAuth} est fourni, l'utilise pour l'echange (cas
+     * registry prive). Sinon anonyme (cas registry public).
+     */
+    @SuppressWarnings("rawtypes")
+    private String obtainBearerToken(@Nullable String wwwAuth, @Nullable String basicAuth) {
+        if (wwwAuth == null) return null;
+        String prefix = "Bearer ";
+        if (!wwwAuth.regionMatches(true, 0, prefix, 0, prefix.length())) return null;
+        Map<String, String> params = parseAuthParams(wwwAuth.substring(prefix.length()));
+        String realm = params.get("realm");
+        if (realm == null) return null;
+        StringBuilder url = new StringBuilder(realm);
+        boolean hasQuery = realm.contains("?");
+        for (String key : new String[]{"service", "scope"}) {
+            String v = params.get(key);
+            if (v != null) {
+                String encoded = URLEncoder.encode(v, StandardCharsets.UTF_8)
+                        .replace("%3A", ":")
+                        .replace("%2F", "/");
+                url.append(hasQuery ? '&' : '?').append(key).append('=').append(encoded);
+                hasQuery = true;
+            }
+        }
+        try {
+            HttpHeaders headers = new HttpHeaders();
+            if (basicAuth != null) {
+                headers.set(HttpHeaders.AUTHORIZATION, basicAuth);
+            }
+            ResponseEntity<Map> resp = http.exchange(url.toString(), HttpMethod.GET,
+                    new HttpEntity<>(headers), Map.class);
+            Map<?, ?> body = resp.getBody();
+            if (body == null) return null;
+            Object t = body.get("token");
+            if (t == null) t = body.get("access_token");
+            return t == null ? null : t.toString();
+        } catch (Exception e) {
+            log.warn("Bearer token request failed: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    /** Parser minimaliste pour {@code key="value", key2="value2"}. */
+    private static Map<String, String> parseAuthParams(String s) {
+        Map<String, String> out = new HashMap<>();
+        int i = 0;
+        int n = s.length();
+        while (i < n) {
+            while (i < n && (s.charAt(i) == ',' || s.charAt(i) == ' ')) i++;
+            int eq = s.indexOf('=', i);
+            if (eq < 0) break;
+            String key = s.substring(i, eq).trim();
+            int valStart = eq + 1;
+            String val;
+            if (valStart < n && s.charAt(valStart) == '"') {
+                int valEnd = s.indexOf('"', valStart + 1);
+                if (valEnd < 0) break;
+                val = s.substring(valStart + 1, valEnd);
+                i = valEnd + 1;
+            } else {
+                int valEnd = s.indexOf(',', valStart);
+                if (valEnd < 0) valEnd = n;
+                val = s.substring(valStart, valEnd).trim();
+                i = valEnd;
+            }
+            out.put(key, val);
+        }
+        return out;
+    }
+
+    private static String normalizeRegistry(String value) {
+        if (value == null || value.isBlank()) return "";
+        String v = value.trim();
+        if (!v.startsWith("http://") && !v.startsWith("https://")) {
+            v = "https://" + v;
+        }
+        if (v.endsWith("/")) v = v.substring(0, v.length() - 1);
+        return v;
+    }
+
+    private static List<String> parseImages(String csv) {
+        if (csv == null || csv.isBlank()) return List.of();
+        List<String> out = new ArrayList<>();
+        for (String part : csv.split(",")) {
+            String p = part.trim();
+            if (!p.isEmpty()) out.add(p);
+        }
+        return out;
+    }
+
+    // -----------------------------------------------------------------------
+    // Records / DTO
+    // -----------------------------------------------------------------------
+
+    public enum ImageStatusKind { UP_TO_DATE, UPDATE_AVAILABLE, UNKNOWN }
+
+    public record UpdateStatus(
+            boolean enabled,
+            boolean updateAvailable,
+            boolean anyUnknown,
+            String currentVersion,
+            List<ImageStatus> images,
+            Instant checkedAt) {}
+
+    /**
+     * Statut par image. {@code localVersion} = version embarquee dans le binaire ;
+     * {@code remoteVersion} = plus haute version semver trouvee dans le registry.
+     * {@code updateAvailable} est derive de {@code status} (back-compat front).
+     */
+    public record ImageStatus(
+            String image,
+            String localVersion,
+            String remoteVersion,
+            ImageStatusKind status,
+            boolean updateAvailable) {
+
+        public ImageStatus(String image, String localVersion, String remoteVersion, ImageStatusKind status) {
+            this(image, localVersion, remoteVersion, status, status == ImageStatusKind.UPDATE_AVAILABLE);
+        }
+    }
+
+    public record BetaStatus(
+            boolean enabled,
+            boolean updateAvailable,
+            boolean anyUnknown,
+            List<ImageStatus> images,
+            Instant checkedAt,
+            String disabledReason) {
+
+        public static BetaStatus disabled(String reason) {
+            return new BetaStatus(false, false, false, List.of(), Instant.now(), reason);
+        }
+    }
+
+    /** DTO pour deserialisation Jackson de /v2/.../tags/list. */
+    static class TagsListResponse {
+        public String name;
+        public List<String> tags;
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/config/SecurityConfig.java

@@ -66,6 +66,8 @@ public class SecurityConfig {
                 // Preflight CORS toujours libre (le browser n'envoie pas Authorization sur OPTIONS)
                 .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                 .requestMatchers("/api/settings/**").hasRole("ADMIN")
+                .requestMatchers("/api/admin/**").hasRole("ADMIN")
+                .requestMatchers("/api/license/**").hasRole("ADMIN")
                 .anyRequest().permitAll()
             )
             .httpBasic(basic -> {});

core/src/main/java/com/loremind/infrastructure/web/controller/ArcController.java

@@ -28,7 +28,7 @@ public class ArcController {
     @PostMapping
     public ResponseEntity<ArcDTO> createArc(@RequestBody ArcDTO arcDTO) {
         Arc arc = arcMapper.toDomain(arcDTO);
-        Arc createdArc = arcService.createArc(arc.getName(), arc.getDescription(), arc.getCampaignId(), arc.getOrder());
+        Arc createdArc = arcService.createArc(arc.getName(), arc.getDescription(), arc.getCampaignId(), arc.getOrder(), arc.getIcon());
         return ResponseEntity.ok(arcMapper.toDTO(createdArc));
     }
 
@@ -40,17 +40,11 @@ public class ArcController {
     }
 
     @GetMapping
-    public ResponseEntity<List<ArcDTO>> getAllArcs() {
+    public ResponseEntity<List<ArcDTO>> getAllArcs(
-        List<Arc> arcs = arcService.getAllArcs();
+            @RequestParam(value = "campaignId", required = false) String campaignId) {
-        List<ArcDTO> arcDTOs = arcs.stream()
+        List<Arc> arcs = (campaignId != null && !campaignId.isBlank())
-                .map(arcMapper::toDTO)
+                ? arcService.getArcsByCampaignId(campaignId)
-                .collect(Collectors.toList());
+                : arcService.getAllArcs();
-        return ResponseEntity.ok(arcDTOs);
-    }
-
-    @GetMapping("/campaign/{campaignId}")
-    public ResponseEntity<List<ArcDTO>> getArcsByCampaignId(@PathVariable String campaignId) {
-        List<Arc> arcs = arcService.getArcsByCampaignId(campaignId);
         List<ArcDTO> arcDTOs = arcs.stream()
                 .map(arcMapper::toDTO)
                 .collect(Collectors.toList());
@@ -68,4 +62,12 @@ public class ArcController {
         arcService.deleteArc(id);
         return ResponseEntity.noContent().build();
     }
+
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<ArcService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
+        if (!arcService.arcExists(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(arcService.getDeletionImpact(id));
+    }
 }

core/src/main/java/com/loremind/infrastructure/web/controller/CampaignController.java

@@ -74,4 +74,16 @@ public class CampaignController {
         campaignService.deleteCampaign(id);
         return ResponseEntity.noContent().build();
     }
+
+    /**
+     * Récapitulatif des entités qui seront supprimées en cascade : utilisé par
+     * l'UI pour afficher "X arcs, Y chapitres, Z scènes..." dans la confirmation.
+     */
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<CampaignService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
+        if (!campaignService.campaignExists(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(campaignService.getDeletionImpact(id));
+    }
 }

core/src/main/java/com/loremind/infrastructure/web/controller/ChapterController.java

@@ -28,7 +28,7 @@ public class ChapterController {
     @PostMapping
     public ResponseEntity<ChapterDTO> createChapter(@RequestBody ChapterDTO chapterDTO) {
         Chapter chapter = chapterMapper.toDomain(chapterDTO);
-        Chapter createdChapter = chapterService.createChapter(chapter.getName(), chapter.getDescription(), chapter.getArcId(), chapter.getOrder());
+        Chapter createdChapter = chapterService.createChapter(chapter.getName(), chapter.getDescription(), chapter.getArcId(), chapter.getOrder(), chapter.getIcon());
         return ResponseEntity.ok(chapterMapper.toDTO(createdChapter));
     }
 
@@ -40,17 +40,11 @@ public class ChapterController {
     }
 
     @GetMapping
-    public ResponseEntity<List<ChapterDTO>> getAllChapters() {
+    public ResponseEntity<List<ChapterDTO>> getAllChapters(
-        List<Chapter> chapters = chapterService.getAllChapters();
+            @RequestParam(value = "arcId", required = false) String arcId) {
-        List<ChapterDTO> chapterDTOs = chapters.stream()
+        List<Chapter> chapters = (arcId != null && !arcId.isBlank())
-                .map(chapterMapper::toDTO)
+                ? chapterService.getChaptersByArcId(arcId)
-                .collect(Collectors.toList());
+                : chapterService.getAllChapters();
-        return ResponseEntity.ok(chapterDTOs);
-    }
-
-    @GetMapping("/arc/{arcId}")
-    public ResponseEntity<List<ChapterDTO>> getChaptersByArcId(@PathVariable String arcId) {
-        List<Chapter> chapters = chapterService.getChaptersByArcId(arcId);
         List<ChapterDTO> chapterDTOs = chapters.stream()
                 .map(chapterMapper::toDTO)
                 .collect(Collectors.toList());
@@ -68,4 +62,12 @@ public class ChapterController {
         chapterService.deleteChapter(id);
         return ResponseEntity.noContent().build();
     }
+
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<ChapterService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
+        if (!chapterService.chapterExists(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(chapterService.getDeletionImpact(id));
+    }
 }

core/src/main/java/com/loremind/infrastructure/web/controller/ConfigController.java

@@ -0,0 +1,36 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.infrastructure.updates.UpdateCheckService;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+ * Expose la configuration publique consommee par le frontend au demarrage.
+ * Activer le mode demo via la variable d'env DEMO_MODE=true : le front
+ * masque alors Settings / Export VTT, et les endpoints sensibles sont
+ * verrouilles cote serveur (cf. SettingsController).
+ */
+@RestController
+@RequestMapping("/api/config")
+public class ConfigController {
+
+    private final boolean demoMode;
+    private final UpdateCheckService updates;
+
+    public ConfigController(@Value("${app.demo-mode:false}") boolean demoMode,
+                            UpdateCheckService updates) {
+        this.demoMode = demoMode;
+        this.updates = updates;
+    }
+
+    @GetMapping
+    public Map<String, Object> getPublicConfig() {
+        return Map.of(
+                "demoMode", demoMode,
+                "updateCheckEnabled", updates.isEnabled());
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/controller/LicenseController.java

@@ -0,0 +1,87 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.licensing.LicenseService;
+import com.loremind.application.licensing.LicenseService.InstallException;
+import com.loremind.domain.licensing.LicenseSnapshot;
+import com.loremind.infrastructure.web.dto.licensing.LicenseStatusDTO;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+/**
+ * Endpoints de gestion de la licence Patreon.
+ *
+ * <ul>
+ *   <li>{@code GET /api/license} : etat courant (status, tier, expiration...)</li>
+ *   <li>{@code GET /api/license/connect-url} : URL OAuth a ouvrir dans le navigateur</li>
+ *   <li>{@code POST /api/license/install} : colle un JWT recu du relais</li>
+ *   <li>{@code DELETE /api/license} : deconnecte Patreon (efface la licence)</li>
+ *   <li>{@code POST /api/license/refresh} : force un refresh manuel</li>
+ *   <li>{@code PUT /api/license/beta-channel} : active/desactive le canal beta</li>
+ * </ul>
+ */
+@RestController
+@RequestMapping("/api/license")
+public class LicenseController {
+
+    private final LicenseService licenseService;
+
+    public LicenseController(LicenseService licenseService) {
+        this.licenseService = licenseService;
+    }
+
+    @GetMapping
+    public LicenseStatusDTO getStatus() {
+        boolean enabled = licenseService.isLicensingEnabled();
+        LicenseSnapshot snap = licenseService.getCurrentSnapshot();
+        return LicenseStatusDTO.from(enabled, snap);
+    }
+
+    @GetMapping("/connect-url")
+    public Map<String, String> getConnectUrl() {
+        return Map.of("url", licenseService.buildConnectUrl());
+    }
+
+    @PostMapping("/install")
+    public ResponseEntity<?> install(@RequestBody InstallRequest request) {
+        if (request == null || request.jwt() == null || request.jwt().isBlank()) {
+            return ResponseEntity.badRequest().body(Map.of("error", "missing jwt"));
+        }
+        try {
+            LicenseSnapshot snap = licenseService.installToken(request.jwt());
+            return ResponseEntity.ok(LicenseStatusDTO.from(true, snap));
+        } catch (InstallException e) {
+            return ResponseEntity.badRequest().body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    @DeleteMapping
+    public ResponseEntity<Void> disconnect() {
+        licenseService.disconnect();
+        return ResponseEntity.noContent().build();
+    }
+
+    @PostMapping("/refresh")
+    public ResponseEntity<LicenseStatusDTO> refresh() {
+        licenseService.forceRefresh();
+        boolean enabled = licenseService.isLicensingEnabled();
+        return ResponseEntity.ok(LicenseStatusDTO.from(enabled, licenseService.getCurrentSnapshot()));
+    }
+
+    @PutMapping("/beta-channel")
+    public ResponseEntity<?> setBetaChannel(@RequestBody BetaChannelRequest request) {
+        if (request == null) {
+            return ResponseEntity.badRequest().body(Map.of("error", "missing body"));
+        }
+        try {
+            LicenseSnapshot snap = licenseService.setBetaChannelEnabled(request.enabled());
+            return ResponseEntity.ok(LicenseStatusDTO.from(true, snap));
+        } catch (IllegalStateException e) {
+            return ResponseEntity.status(409).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    public record InstallRequest(String jwt) {}
+    public record BetaChannelRequest(boolean enabled) {}
+}

core/src/main/java/com/loremind/infrastructure/web/controller/LoreController.java

@@ -69,4 +69,17 @@ public class LoreController {
         loreService.deleteLore(id);
         return ResponseEntity.noContent().build();
     }
+
+    /**
+     * Récapitulatif des entités qui seront supprimées / détachées en cascade.
+     * Utilisé par l'UI pour afficher "X dossiers, Y pages, Z templates,
+     * N campagne(s) détachée(s)" dans la confirmation.
+     */
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<LoreService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
+        if (loreService.getLoreById(id).isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(loreService.getDeletionImpact(id));
+    }
 }

core/src/main/java/com/loremind/infrastructure/web/controller/LoreNodeController.java

@@ -97,4 +97,16 @@ public class LoreNodeController {
         loreNodeService.deleteLoreNode(id);
         return ResponseEntity.noContent().build();
     }
+
+    /**
+     * Récapitulatif des entités qui seront supprimées en cascade : utilisé par
+     * l'UI pour afficher "X sous-dossiers, Y pages..." dans la confirmation.
+     */
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<LoreNodeService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
+        if (loreNodeService.getLoreNodeById(id).isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(loreNodeService.getDeletionImpact(id));
+    }
 }

core/src/main/java/com/loremind/infrastructure/web/controller/NpcController.java

@@ -0,0 +1,62 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.NpcService;
+import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.infrastructure.web.dto.campaigncontext.NpcDTO;
+import com.loremind.infrastructure.web.mapper.NpcMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api/npcs")
+public class NpcController {
+
+    private final NpcService npcService;
+    private final NpcMapper npcMapper;
+
+    public NpcController(NpcService npcService, NpcMapper npcMapper) {
+        this.npcService = npcService;
+        this.npcMapper = npcMapper;
+    }
+
+    @PostMapping
+    public ResponseEntity<NpcDTO> createNpc(@RequestBody NpcDTO dto) {
+        Npc created = npcService.createNpc(
+                new NpcService.NpcData(dto.getName(), dto.getMarkdownContent(), dto.getCampaignId(), null)
+        );
+        return ResponseEntity.ok(npcMapper.toDTO(created));
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<NpcDTO> getNpcById(@PathVariable String id) {
+        return npcService.getNpcById(id)
+                .map(n -> ResponseEntity.ok(npcMapper.toDTO(n)))
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @GetMapping("/campaign/{campaignId}")
+    public ResponseEntity<List<NpcDTO>> getNpcsByCampaign(@PathVariable String campaignId) {
+        List<NpcDTO> dtos = npcService.getNpcsByCampaignId(campaignId).stream()
+                .map(npcMapper::toDTO)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(dtos);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<NpcDTO> updateNpc(@PathVariable String id, @RequestBody NpcDTO dto) {
+        Npc updated = npcService.updateNpc(
+                id,
+                new NpcService.NpcData(dto.getName(), dto.getMarkdownContent(), dto.getCampaignId(), dto.getOrder())
+        );
+        return ResponseEntity.ok(npcMapper.toDTO(updated));
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteNpc(@PathVariable String id) {
+        npcService.deleteNpc(id);
+        return ResponseEntity.noContent().build();
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/controller/SceneController.java

@@ -28,7 +28,7 @@ public class SceneController {
     @PostMapping
     public ResponseEntity<SceneDTO> createScene(@RequestBody SceneDTO sceneDTO) {
         Scene scene = sceneMapper.toDomain(sceneDTO);
-        Scene createdScene = sceneService.createScene(scene.getName(), scene.getDescription(), scene.getChapterId(), scene.getOrder());
+        Scene createdScene = sceneService.createScene(scene.getName(), scene.getDescription(), scene.getChapterId(), scene.getOrder(), scene.getIcon());
         return ResponseEntity.ok(sceneMapper.toDTO(createdScene));
     }
 
@@ -40,17 +40,11 @@ public class SceneController {
     }
 
     @GetMapping
-    public ResponseEntity<List<SceneDTO>> getAllScenes() {
+    public ResponseEntity<List<SceneDTO>> getAllScenes(
-        List<Scene> scenes = sceneService.getAllScenes();
+            @RequestParam(value = "chapterId", required = false) String chapterId) {
-        List<SceneDTO> sceneDTOs = scenes.stream()
+        List<Scene> scenes = (chapterId != null && !chapterId.isBlank())
-                .map(sceneMapper::toDTO)
+                ? sceneService.getScenesByChapterId(chapterId)
-                .collect(Collectors.toList());
+                : sceneService.getAllScenes();
-        return ResponseEntity.ok(sceneDTOs);
-    }
-
-    @GetMapping("/chapter/{chapterId}")
-    public ResponseEntity<List<SceneDTO>> getScenesByChapterId(@PathVariable String chapterId) {
-        List<Scene> scenes = sceneService.getScenesByChapterId(chapterId);
         List<SceneDTO> sceneDTOs = scenes.stream()
                 .map(sceneMapper::toDTO)
                 .collect(Collectors.toList());

core/src/main/java/com/loremind/infrastructure/web/controller/SettingsController.java

@@ -4,16 +4,28 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.client.RestTemplate;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
 import java.util.Map;
 
 /**
@@ -32,20 +44,28 @@ public class SettingsController {
 
     private final RestTemplate restTemplate;
     private final String brainBaseUrl;
+    private final String brainInternalSecret;
+    private final boolean demoMode;
 
     public SettingsController(RestTemplate restTemplate,
-                              @Value("${brain.base-url}") String brainBaseUrl) {
+                              @Value("${brain.base-url}") String brainBaseUrl,
+                              @Value("${brain.internal-secret}") String brainInternalSecret,
+                              @Value("${app.demo-mode:false}") boolean demoMode) {
         this.restTemplate = restTemplate;
         this.brainBaseUrl = brainBaseUrl;
+        this.brainInternalSecret = brainInternalSecret;
+        this.demoMode = demoMode;
     }
 
     @GetMapping
     public ResponseEntity<Map<String, Object>> getSettings() {
+        guardDemoMode();
         return forward(HttpMethod.GET, "/settings", null);
     }
 
     @PutMapping
     public ResponseEntity<Map<String, Object>> updateSettings(@RequestBody Map<String, Object> patch) {
+        guardDemoMode();
         return forward(HttpMethod.PUT, "/settings", patch);
     }
 
@@ -59,11 +79,98 @@ public class SettingsController {
         return forward(HttpMethod.POST, "/models/ollama/info", body);
     }
 
+    /**
+     * Telecharge un modele Ollama et streame la progression au client.
+     * <p>
+     * On bypass RestTemplate (qui bufferise toute la reponse) au profit du
+     * client HTTP standard de Java en mode streaming. Le Brain renvoie du
+     * NDJSON ligne par ligne ; on relaie chaque chunk tel quel pour que le
+     * frontend voie la progression en temps reel.
+     */
+    @PostMapping(value = "/models/ollama/pull", produces = "application/x-ndjson")
+    public ResponseEntity<StreamingResponseBody> pullOllamaModel(@RequestBody Map<String, Object> body) {
+        guardDemoMode();
+        StreamingResponseBody stream = output -> {
+            // Force HTTP/1.1 : le HttpClient JDK essaie HTTP/2 par defaut,
+            // mais uvicorn (Brain) ne supporte que HTTP/1.1 et rejette la
+            // tentative d'upgrade ("Unsupported upgrade request") -> la
+            // requete n'arrive jamais a notre endpoint Python.
+            HttpClient http = HttpClient.newBuilder()
+                    .version(HttpClient.Version.HTTP_1_1)
+                    .connectTimeout(Duration.ofSeconds(10))
+                    .build();
+            // Le RestTemplate auto-injecte X-Internal-Secret via un interceptor,
+            // mais on bypass RestTemplate pour le streaming -> on doit ajouter
+            // l'entete a la main, sinon le Brain repond 401.
+            HttpRequest.Builder reqBuilder = HttpRequest.newBuilder()
+                    .uri(URI.create(brainBaseUrl + "/models/ollama/pull"))
+                    .timeout(Duration.ofMinutes(60))
+                    .header("Content-Type", "application/json")
+                    .POST(HttpRequest.BodyPublishers.ofString(toJson(body)));
+            if (brainInternalSecret != null && !brainInternalSecret.isBlank()) {
+                reqBuilder.header("X-Internal-Secret", brainInternalSecret);
+            }
+            HttpRequest req = reqBuilder.build();
+            try {
+                HttpResponse<InputStream> resp = http.send(req, HttpResponse.BodyHandlers.ofInputStream());
+                try (InputStream in = resp.body()) {
+                    byte[] buf = new byte[4096];
+                    int n;
+                    while ((n = in.read(buf)) != -1) {
+                        output.write(buf, 0, n);
+                        output.flush();
+                    }
+                }
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+                throw new IOException("Pull interrompu", ie);
+            }
+        };
+        return ResponseEntity.ok().contentType(MediaType.parseMediaType("application/x-ndjson")).body(stream);
+    }
+
+    @DeleteMapping("/models/ollama/{name}")
+    public ResponseEntity<Map<String, Object>> deleteOllamaModel(@PathVariable("name") String name) {
+        guardDemoMode();
+        return forward(HttpMethod.DELETE, "/models/ollama/" + name, null);
+    }
+
     @GetMapping("/models/onemin")
     public ResponseEntity<Map<String, Object>> listOneMinModels() {
         return forward(HttpMethod.GET, "/models/onemin", null);
     }
 
+    /**
+     * Serialiseur JSON minimal pour eviter d'instancier ObjectMapper a chaque
+     * appel. Suffisant pour notre cas d'usage : Map<String,Object> avec des
+     * String/Number/Boolean en valeur.
+     */
+    private static String toJson(Map<String, Object> m) {
+        StringBuilder sb = new StringBuilder("{");
+        boolean first = true;
+        for (Map.Entry<String, Object> e : m.entrySet()) {
+            if (!first) sb.append(",");
+            sb.append("\"").append(escape(e.getKey())).append("\":");
+            Object v = e.getValue();
+            if (v == null) sb.append("null");
+            else if (v instanceof Number || v instanceof Boolean) sb.append(v);
+            else sb.append("\"").append(escape(v.toString())).append("\"");
+            first = false;
+        }
+        return sb.append("}").toString();
+    }
+
+    private static String escape(String s) {
+        return s.replace("\\", "\\\\").replace("\"", "\\\"")
+                .replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t");
+    }
+
+    private void guardDemoMode() {
+        if (demoMode) {
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Settings disabled in demo mode");
+        }
+    }
+
     @SuppressWarnings({"rawtypes", "unchecked"})
     private ResponseEntity<Map<String, Object>> forward(HttpMethod method, String path, Object body) {
         HttpHeaders headers = new HttpHeaders();

core/src/main/java/com/loremind/infrastructure/web/controller/UpdatesController.java

@@ -0,0 +1,83 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.infrastructure.updates.UpdateCheckService;
+import com.loremind.infrastructure.updates.UpdateCheckService.BetaStatus;
+import com.loremind.infrastructure.updates.UpdateCheckService.UpdateStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.Map;
+
+/**
+ * Endpoints admin pour la verification et le declenchement des mises a jour
+ * des conteneurs LoreMind (core/brain/web).
+ *
+ * Protege par HTTP Basic via SecurityConfig (path /api/admin/**).
+ * Si la feature n'est pas configuree (WATCHTOWER_TOKEN vide), check renvoie
+ * {enabled:false} et apply repond 503.
+ */
+@RestController
+@RequestMapping("/api/admin/updates")
+public class UpdatesController {
+
+    private static final Logger log = LoggerFactory.getLogger(UpdatesController.class);
+
+    private final UpdateCheckService updates;
+    private final boolean demoMode;
+
+    public UpdatesController(UpdateCheckService updates,
+                             @Value("${app.demo-mode:false}") boolean demoMode) {
+        this.updates = updates;
+        this.demoMode = demoMode;
+    }
+
+    @GetMapping("/check")
+    public UpdateStatus check() {
+        guardDemoMode();
+        return updates.check();
+    }
+
+    @GetMapping("/check-beta")
+    public BetaStatus checkBeta() {
+        guardDemoMode();
+        return updates.checkBeta();
+    }
+
+    @PostMapping("/apply")
+    public ResponseEntity<Map<String, Object>> apply() {
+        guardDemoMode();
+        if (!updates.isEnabled()) {
+            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
+                    .body(Map.of("error", "Update apply not configured"));
+        }
+        try {
+            updates.apply();
+            return ResponseEntity.accepted()
+                    .body(Map.of("status", "triggered",
+                                 "message", "Watchtower va telecharger et redemarrer les conteneurs."));
+        } catch (Exception e) {
+            log.error("Apply update failed", e);
+            return ResponseEntity.status(HttpStatus.BAD_GATEWAY)
+                    .body(Map.of("error", "Watchtower unreachable: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * En mode demo, les instances ne doivent pas se mettre a jour ni meme
+     * exposer leur statut (pas de surface d'attaque, et pas de redemarrage
+     * intempestif d'une demo en cours). Cohérent avec SettingsController.
+     */
+    private void guardDemoMode() {
+        if (demoMode) {
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Updates disabled in demo mode");
+        }
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/controller/VersionController.java

@@ -0,0 +1,35 @@
+package com.loremind.infrastructure.web.controller;
+
+import org.springframework.boot.info.BuildProperties;
+import org.springframework.lang.Nullable;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+ * Endpoint public exposant la version courante du binaire.
+ * <p>
+ * Consomme par le frontend pour detecter qu'une mise a jour a ete deployee
+ * pendant qu'un onglet utilisateur etait deja ouvert : si la version polled
+ * differe de celle observee au boot, l'UI affiche un bandeau "rechargez".
+ * <p>
+ * Volontairement public (pas d'auth) : la version est deja exposee dans le
+ * JAR / l'image Docker, aucun risque de leak.
+ */
+@RestController
+@RequestMapping("/api/version")
+public class VersionController {
+
+    private final String version;
+
+    public VersionController(@Nullable BuildProperties buildProperties) {
+        this.version = buildProperties != null ? buildProperties.getVersion() : "dev";
+    }
+
+    @GetMapping
+    public Map<String, String> getVersion() {
+        return Map.of("version", version);
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ArcDTO.java

@@ -17,6 +17,9 @@ public class ArcDTO {
     private String campaignId;
     private int order;
 
+    /** Cle d'icone (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // Champs narratifs enrichis
     private String themes;
     private String stakes;

core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ChapterDTO.java

@@ -17,6 +17,9 @@ public class ChapterDTO {
     private String arcId;
     private int order;
 
+    /** Cle d'icone (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // Champs narratifs enrichis
     private String gmNotes;
     private String playerObjectives;

core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/NpcDTO.java

@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+
+/**
+ * DTO pour les fiches de PNJ d'une campagne.
+ */
+@Data
+public class NpcDTO {
+
+    private String id;
+    private String name;
+    private String markdownContent;
+    private String campaignId;
+    private int order;
+}

core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/SceneDTO.java

@@ -17,6 +17,9 @@ public class SceneDTO {
     private String chapterId;
     private int order;
 
+    /** Cle d'icone (cf. CAMPAIGN_ICON_OPTIONS cote front). */
+    private String icon;
+
     // Champs narratifs enrichis
     private String location;
     private String timing;

core/src/main/java/com/loremind/infrastructure/web/dto/licensing/LicenseStatusDTO.java

@@ -0,0 +1,35 @@
+package com.loremind.infrastructure.web.dto.licensing;
+
+import com.loremind.domain.licensing.LicenseSnapshot;
+
+import java.time.Instant;
+
+/**
+ * Vue serialisee de l'etat de la licence pour le frontend.
+ * Le {@code rawJwt} n'est volontairement JAMAIS expose.
+ */
+public record LicenseStatusDTO(
+        boolean enabled,
+        String status,
+        String patreonUserId,
+        String tierId,
+        String instanceId,
+        Instant expiresAt,
+        Instant lastRefreshAttemptAt,
+        Boolean lastRefreshSucceeded,
+        boolean betaChannelEnabled
+) {
+    public static LicenseStatusDTO from(boolean enabled, LicenseSnapshot snap) {
+        return new LicenseStatusDTO(
+                enabled,
+                snap.status().name(),
+                snap.patreonUserId(),
+                snap.tierId(),
+                snap.instanceId(),
+                snap.expiresAt(),
+                snap.lastRefreshAttemptAt(),
+                snap.lastRefreshAttemptAt() != null ? snap.lastRefreshSucceeded() : null,
+                snap.betaChannelEnabled()
+        );
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/mapper/ArcMapper.java

@@ -24,6 +24,7 @@ public class ArcMapper {
         dto.setDescription(arc.getDescription());
         dto.setCampaignId(arc.getCampaignId());
         dto.setOrder(arc.getOrder());
+        dto.setIcon(arc.getIcon());
         dto.setThemes(arc.getThemes());
         dto.setStakes(arc.getStakes());
         dto.setGmNotes(arc.getGmNotes());
@@ -46,6 +47,7 @@ public class ArcMapper {
                 .description(dto.getDescription())
                 .campaignId(dto.getCampaignId())
                 .order(dto.getOrder())
+                .icon(dto.getIcon())
                 .themes(dto.getThemes())
                 .stakes(dto.getStakes())
                 .gmNotes(dto.getGmNotes())

core/src/main/java/com/loremind/infrastructure/web/mapper/ChapterMapper.java

@@ -24,6 +24,7 @@ public class ChapterMapper {
         dto.setDescription(chapter.getDescription());
         dto.setArcId(chapter.getArcId());
         dto.setOrder(chapter.getOrder());
+        dto.setIcon(chapter.getIcon());
         dto.setGmNotes(chapter.getGmNotes());
         dto.setPlayerObjectives(chapter.getPlayerObjectives());
         dto.setNarrativeStakes(chapter.getNarrativeStakes());
@@ -44,6 +45,7 @@ public class ChapterMapper {
                 .description(dto.getDescription())
                 .arcId(dto.getArcId())
                 .order(dto.getOrder())
+                .icon(dto.getIcon())
                 .gmNotes(dto.getGmNotes())
                 .playerObjectives(dto.getPlayerObjectives())
                 .narrativeStakes(dto.getNarrativeStakes())

core/src/main/java/com/loremind/infrastructure/web/mapper/NpcMapper.java

@@ -0,0 +1,31 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.infrastructure.web.dto.campaigncontext.NpcDTO;
+import org.springframework.stereotype.Component;
+
+@Component
+public class NpcMapper {
+
+    public NpcDTO toDTO(Npc n) {
+        if (n == null) return null;
+        NpcDTO dto = new NpcDTO();
+        dto.setId(n.getId());
+        dto.setName(n.getName());
+        dto.setMarkdownContent(n.getMarkdownContent());
+        dto.setCampaignId(n.getCampaignId());
+        dto.setOrder(n.getOrder());
+        return dto;
+    }
+
+    public Npc toDomain(NpcDTO dto) {
+        if (dto == null) return null;
+        return Npc.builder()
+                .id(dto.getId())
+                .name(dto.getName())
+                .markdownContent(dto.getMarkdownContent())
+                .campaignId(dto.getCampaignId())
+                .order(dto.getOrder())
+                .build();
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/mapper/SceneMapper.java

@@ -27,6 +27,7 @@ public class SceneMapper {
         dto.setDescription(scene.getDescription());
         dto.setChapterId(scene.getChapterId());
         dto.setOrder(scene.getOrder());
+        dto.setIcon(scene.getIcon());
         dto.setLocation(scene.getLocation());
         dto.setTiming(scene.getTiming());
         dto.setAtmosphere(scene.getAtmosphere());
@@ -59,6 +60,7 @@ public class SceneMapper {
                 .description(dto.getDescription())
                 .chapterId(dto.getChapterId())
                 .order(dto.getOrder())
+                .icon(dto.getIcon())
                 .location(dto.getLocation())
                 .timing(dto.getTiming())
                 .atmosphere(dto.getAtmosphere())
@@ -85,18 +87,14 @@ public class SceneMapper {
     private List<SceneBranchDTO> toBranchDTOs(List<SceneBranch> branches) {
         if (branches == null) return new ArrayList<>();
         return branches.stream()
-                .map(b -> new SceneBranchDTO(b.getLabel(), b.getTargetSceneId(), b.getCondition()))
+                .map(b -> new SceneBranchDTO(b.label(), b.targetSceneId(), b.condition()))
                 .collect(Collectors.toList());
     }
 
     private List<SceneBranch> toBranchDomain(List<SceneBranchDTO> dtos) {
         if (dtos == null) return new ArrayList<>();
         return dtos.stream()
-                .map(d -> SceneBranch.builder()
+                .map(d -> new SceneBranch(d.getLabel(), d.getTargetSceneId(), d.getCondition()))
-                        .label(d.getLabel())
-                        .targetSceneId(d.getTargetSceneId())
-                        .condition(d.getCondition())
-                        .build())
                 .collect(Collectors.toList());
     }
 }

core/src/main/resources/application.properties

@@ -5,6 +5,12 @@ server.port=8080
 # de WebFlux (utilisé uniquement pour WebClient côté adapter SSE vers le Brain).
 spring.main.web-application-type=servlet
 
+# Pas de timeout sur les requetes async (StreamingResponseBody, SSE).
+# Le defaut Tomcat coupe a 30s, ce qui interrompt le streaming d'un pull
+# de modele Ollama (peut durer des dizaines de minutes pour un GGUF de 10+ Go).
+# -1 = pas de timeout, on s'appuie sur la fermeture cote client ou cote upstream.
+spring.mvc.async.request-timeout=-1
+
 # Configuration de la base de donnees PostgreSQL
 # Valeurs surchargeables via variables d'env (cf. docker-compose.yml).
 # En dev local, creez un fichier .env a la racine de core/ OU definissez les
@@ -21,13 +27,13 @@ spring.jpa.show-sql=true
 spring.jpa.properties.hibernate.format_sql=true
 
 # Configuration CORS pour autoriser le Frontend Angular
-spring.web.cors.allowed-origins=http://localhost:4200
+spring.web.cors.allowed-origins=${CORS_ALLOWED_ORIGINS:http://localhost:4200}
 spring.web.cors.allowed-methods=GET,POST,PUT,DELETE,OPTIONS
 spring.web.cors.allowed-headers=*
 spring.web.cors.allow-credentials=true
 
 # Configuration du Brain (service IA Python)
-brain.base-url=http://localhost:8000
+brain.base-url=${BRAIN_BASE_URL:http://localhost:8000}
 brain.timeout-seconds=120
 
 # Secret partage Core <-> Brain (auth inter-service via entete X-Internal-Secret).
@@ -50,3 +56,48 @@ minio.bucket=${MINIO_BUCKET:loremind-images}
 # Limites d'upload d'images (MB)
 spring.servlet.multipart.max-file-size=10MB
 spring.servlet.multipart.max-request-size=10MB
+
+# Mode demo : masque Settings/Export cote front et bloque les PUT /api/settings
+# cote serveur. Activer via DEMO_MODE=true sur les deploiements publics.
+app.demo-mode=${DEMO_MODE:false}
+
+# Detection des mises a jour des conteneurs Docker (registry HTTP API + Watchtower).
+# Feature desactivee si UPDATE_CHECK_WATCHTOWER_TOKEN est vide.
+update-check.registry=${UPDATE_CHECK_REGISTRY:}
+update-check.images=${UPDATE_CHECK_IMAGES:}
+update-check.watchtower-url=${WATCHTOWER_URL:http://watchtower:8080}
+update-check.watchtower-token=${WATCHTOWER_TOKEN:}
+
+# ============================================================================
+# Licensing (canal beta gate par Patreon)
+# ============================================================================
+# URL du relais OAuth Patreon (Cloudflare Workers). En prod : valeur par defaut.
+licensing.relay.base-url=${LICENSING_RELAY_BASE_URL:https://loremind-auth.igmlcreation.fr}
+
+# Cle publique Ed25519 (PEM SPKI) qui verifie les JWT emis par le relais.
+# En prod : chargee automatiquement depuis classpath:licensing/jwt-public-key.pem
+# (embarquee dans le binaire). Cette propriete sert UNIQUEMENT a la rotation
+# de cle ou aux tests : si LICENSING_JWT_PUBLIC_KEY est defini, il prevaut
+# sur le fichier embarque.
+licensing.jwt.public-key=${LICENSING_JWT_PUBLIC_KEY:}
+licensing.jwt.expected-issuer=loremind-auth
+licensing.jwt.expected-audience=loremind-instance
+
+# Periode de tolerance apres expiration du JWT pendant laquelle l'instance
+# garde l'acces beta meme si le relais est indisponible pour le refresh.
+licensing.grace-period-days=14
+# Avant J-N de l'expiration, le daemon tente un refresh.
+licensing.refresh-before-expiry-days=2
+
+# Identifiant stable de l'instance (UUID genere a la premiere connexion Patreon
+# et conserve en base). Utilise dans le state OAuth + dans le JWT.
+licensing.instance-id-file=${LICENSING_INSTANCE_ID_FILE:}
+
+# Image beta : si la licence est valide ET le toggle canal beta active,
+# UpdateCheckService check ces images en plus du canal stable.
+licensing.beta.images=${LICENSING_BETA_IMAGES:igmlcreation/loremind-beta-core,igmlcreation/loremind-beta-brain,igmlcreation/loremind-beta-web}
+
+# Chemin de sortie pour le docker config.json partage avec Watchtower.
+# Volume Docker `docker-config` monte sur ce chemin dans Core, et sur
+# `/shared/docker` dans Watchtower (DOCKER_CONFIG=/shared/docker).
+licensing.docker-config-path=${LICENSING_DOCKER_CONFIG_PATH:/shared/docker/config.json}

core/src/main/resources/licensing/README.md

@@ -0,0 +1,29 @@
+# Cle publique JWT du relais OAuth Patreon
+
+Le fichier `jwt-public-key.pem` contient la **cle publique Ed25519** qui sert
+a verifier la signature des JWT licence emis par le relais
+(`loremind-auth.igmlcreation.fr`).
+
+## Pourquoi ici ?
+
+- C'est une **cle publique** : par nature non-secrete, elle peut etre committee
+  dans le repo public et embarquee dans le binaire distribue.
+- Cela evite a chaque utilisateur final de devoir renseigner manuellement la
+  cle dans son `.env` au moment de l'installation.
+- L'env `LICENSING_JWT_PUBLIC_KEY` peut surcharger cette valeur (utile pour
+  la rotation de cle sans rebuild ou pour les tests).
+
+## Si le fichier est absent
+
+La feature licensing est **desactivee silencieusement** : `LicenseService.isLicensingEnabled()`
+renvoie `false`, et l'UI masque toute la section Patreon.
+
+## Rotation de cle
+
+1. Generer une nouvelle paire dans le relais : `npm run keys:generate`
+2. Pousser la nouvelle cle privee : `wrangler secret put JWT_PRIVATE_KEY`
+3. Remplacer `jwt-public-key.pem` ici avec la nouvelle cle publique
+4. Rebuild + redeployer LoreMind (les anciens JWT seront refuses au prochain
+   refresh, l'utilisateur sera invite a reconnecter Patreon)
+5. Optionnel : pendant la transition, supporter les deux cles en parallele
+   (pas implemente en MVP, peut etre ajoute si besoin operationnel)

core/src/main/resources/licensing/jwt-public-key.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEArbfaqBq54HJR1pKqliTShKrNIab32gpBwSTDw90I4wg=
+-----END PUBLIC KEY-----

core/src/test/java/com/loremind/application/campaigncontext/ArcServiceTest.java

@@ -1,7 +1,11 @@
 package com.loremind.application.campaigncontext;
 
 import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -14,6 +18,7 @@ import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.*;
 
 /**
@@ -26,6 +31,10 @@ public class ArcServiceTest {
 
     @Mock
     private ArcRepository arcRepository;
+    @Mock
+    private ChapterRepository chapterRepository;
+    @Mock
+    private SceneRepository sceneRepository;
 
     @InjectMocks
     private ArcService arcService;
@@ -159,15 +168,48 @@ public class ArcServiceTest {
     }
 
     @Test
-    void testDeleteArc() {
+    void testDeleteArc_EmptyArc() {
-        // Arrange
+        // Aucun chapitre : Mockito renvoie List.of() par défaut.
-        doNothing().when(arcRepository).deleteById("arc-1");
-
-        // Act
         arcService.deleteArc("arc-1");
 
-        // Assert
+        verify(arcRepository).deleteById("arc-1");
-        verify(arcRepository, times(1)).deleteById("arc-1");
+        verify(chapterRepository, never()).deleteById(anyString());
+        verify(sceneRepository, never()).deleteById(anyString());
+    }
+
+    @Test
+    void testDeleteArc_CascadesChaptersAndScenes() {
+        Chapter chapter = Chapter.builder().id("chap-1").arcId("arc-1").name("C").build();
+        Scene s1 = Scene.builder().id("s-1").chapterId("chap-1").name("S1").build();
+        Scene s2 = Scene.builder().id("s-2").chapterId("chap-1").name("S2").build();
+
+        when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(chapter));
+        when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(s1, s2));
+
+        arcService.deleteArc("arc-1");
+
+        verify(sceneRepository).deleteById("s-1");
+        verify(sceneRepository).deleteById("s-2");
+        verify(chapterRepository).deleteById("chap-1");
+        verify(arcRepository).deleteById("arc-1");
+    }
+
+    @Test
+    void testGetDeletionImpact() {
+        Chapter c1 = Chapter.builder().id("chap-1").arcId("arc-1").name("C1").build();
+        Chapter c2 = Chapter.builder().id("chap-2").arcId("arc-1").name("C2").build();
+        Scene s1 = Scene.builder().id("s-1").chapterId("chap-1").name("S1").build();
+        Scene s2 = Scene.builder().id("s-2").chapterId("chap-2").name("S2").build();
+        Scene s3 = Scene.builder().id("s-3").chapterId("chap-2").name("S3").build();
+
+        when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(c1, c2));
+        when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(s1));
+        when(sceneRepository.findByChapterId("chap-2")).thenReturn(List.of(s2, s3));
+
+        ArcService.DeletionImpact impact = arcService.getDeletionImpact("arc-1");
+
+        assertEquals(2, impact.chapters());
+        assertEquals(3, impact.scenes());
     }
 
     @Test

core/src/test/java/com/loremind/application/campaigncontext/CampaignServiceTest.java

@@ -1,7 +1,15 @@
 package com.loremind.application.campaigncontext;
 
+import com.loremind.domain.campaigncontext.Arc;
 import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.Character;
+import com.loremind.domain.campaigncontext.Scene;
+import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -27,6 +35,14 @@ public class CampaignServiceTest {
 
     @Mock
     private CampaignRepository campaignRepository;
+    @Mock
+    private ArcRepository arcRepository;
+    @Mock
+    private ChapterRepository chapterRepository;
+    @Mock
+    private SceneRepository sceneRepository;
+    @Mock
+    private CharacterRepository characterRepository;
 
     @InjectMocks
     private CampaignService campaignService;
@@ -53,7 +69,10 @@ public class CampaignServiceTest {
                 "lore-123",
                 null
         );
-        when(campaignRepository.save(any(Campaign.class))).thenReturn(testCampaign);
+        // Le repo renvoie la Campaign telle que passée — on teste la normalisation
+        // du loreId dans le service, pas le comportement du repo.
+        when(campaignRepository.save(any(Campaign.class)))
+                .thenAnswer(invocation -> invocation.getArgument(0));
 
         // Act
         Campaign result = campaignService.createCampaign(data);
@@ -73,7 +92,8 @@ public class CampaignServiceTest {
                 null,
                 null
         );
-        when(campaignRepository.save(any(Campaign.class))).thenReturn(testCampaign);
+        when(campaignRepository.save(any(Campaign.class)))
+                .thenAnswer(invocation -> invocation.getArgument(0));
 
         // Act
         Campaign result = campaignService.createCampaign(data);
@@ -93,7 +113,8 @@ public class CampaignServiceTest {
                 "   ",
                 null
         );
-        when(campaignRepository.save(any(Campaign.class))).thenReturn(testCampaign);
+        when(campaignRepository.save(any(Campaign.class)))
+                .thenAnswer(invocation -> invocation.getArgument(0));
 
         // Act
         Campaign result = campaignService.createCampaign(data);
@@ -191,15 +212,75 @@ public class CampaignServiceTest {
     }
 
     @Test
-    void testDeleteCampaign() {
+    void testDeleteCampaign_EmptyCampaign() {
-        // Arrange
+        // Arrange : aucune dépendance ; Mockito renvoie List.of() par défaut.
-        doNothing().when(campaignRepository).deleteById("campaign-1");
-
         // Act
         campaignService.deleteCampaign("campaign-1");
 
         // Assert
         verify(campaignRepository, times(1)).deleteById("campaign-1");
+        verify(arcRepository, never()).deleteById(anyString());
+        verify(chapterRepository, never()).deleteById(anyString());
+        verify(sceneRepository, never()).deleteById(anyString());
+        verify(characterRepository, never()).deleteById(anyString());
+    }
+
+    @Test
+    void testDeleteCampaign_CascadesArcsChaptersScenes() {
+        // Arrange : campagne avec 1 arc → 1 chapitre → 2 scènes.
+        Arc arc = Arc.builder().id("arc-1").campaignId("campaign-1").name("Arc 1").build();
+        Chapter chapter = Chapter.builder().id("chap-1").arcId("arc-1").name("Chap 1").build();
+        Scene scene1 = Scene.builder().id("scene-1").chapterId("chap-1").name("Scene 1").build();
+        Scene scene2 = Scene.builder().id("scene-2").chapterId("chap-1").name("Scene 2").build();
+
+        when(arcRepository.findByCampaignId("campaign-1")).thenReturn(List.of(arc));
+        when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(chapter));
+        when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(scene1, scene2));
+
+        // Act
+        campaignService.deleteCampaign("campaign-1");
+
+        // Assert : tout disparaît, dans l'ordre feuilles → racine.
+        verify(sceneRepository).deleteById("scene-1");
+        verify(sceneRepository).deleteById("scene-2");
+        verify(chapterRepository).deleteById("chap-1");
+        verify(arcRepository).deleteById("arc-1");
+        verify(campaignRepository).deleteById("campaign-1");
+    }
+
+    @Test
+    void testDeleteCampaign_CascadesCharacters() {
+        Character pc = Character.builder().id("char-1").campaignId("campaign-1").name("Alric").build();
+        when(characterRepository.findByCampaignId("campaign-1")).thenReturn(List.of(pc));
+
+        campaignService.deleteCampaign("campaign-1");
+
+        verify(characterRepository).deleteById("char-1");
+        verify(campaignRepository).deleteById("campaign-1");
+    }
+
+    @Test
+    void testGetDeletionImpact() {
+        Arc arc = Arc.builder().id("arc-1").campaignId("campaign-1").name("Arc 1").build();
+        Chapter c1 = Chapter.builder().id("chap-1").arcId("arc-1").name("C1").build();
+        Chapter c2 = Chapter.builder().id("chap-2").arcId("arc-1").name("C2").build();
+        Scene s1 = Scene.builder().id("s-1").chapterId("chap-1").name("S1").build();
+        Scene s2 = Scene.builder().id("s-2").chapterId("chap-2").name("S2").build();
+        Scene s3 = Scene.builder().id("s-3").chapterId("chap-2").name("S3").build();
+        Character pc = Character.builder().id("char-1").campaignId("campaign-1").name("Alric").build();
+
+        when(arcRepository.findByCampaignId("campaign-1")).thenReturn(List.of(arc));
+        when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(c1, c2));
+        when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(s1));
+        when(sceneRepository.findByChapterId("chap-2")).thenReturn(List.of(s2, s3));
+        when(characterRepository.findByCampaignId("campaign-1")).thenReturn(List.of(pc));
+
+        CampaignService.DeletionImpact impact = campaignService.getDeletionImpact("campaign-1");
+
+        assertEquals(1, impact.arcs());
+        assertEquals(2, impact.chapters());
+        assertEquals(3, impact.scenes());
+        assertEquals(1, impact.characters());
     }
 
     @Test

core/src/test/java/com/loremind/application/campaigncontext/ChapterServiceTest.java

@@ -1,7 +1,9 @@
 package com.loremind.application.campaigncontext;
 
 import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -14,6 +16,7 @@ import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.*;
 
 /**
@@ -26,6 +29,8 @@ public class ChapterServiceTest {
 
     @Mock
     private ChapterRepository chapterRepository;
+    @Mock
+    private SceneRepository sceneRepository;
 
     @InjectMocks
     private ChapterService chapterService;
@@ -157,15 +162,36 @@ public class ChapterServiceTest {
     }
 
     @Test
-    void testDeleteChapter() {
+    void testDeleteChapter_EmptyChapter() {
-        // Arrange
+        // Aucune scène : Mockito renvoie List.of() par défaut.
-        doNothing().when(chapterRepository).deleteById("chapter-1");
-
-        // Act
         chapterService.deleteChapter("chapter-1");
 
-        // Assert
+        verify(chapterRepository).deleteById("chapter-1");
-        verify(chapterRepository, times(1)).deleteById("chapter-1");
+        verify(sceneRepository, never()).deleteById(anyString());
+    }
+
+    @Test
+    void testDeleteChapter_CascadesScenes() {
+        Scene s1 = Scene.builder().id("s-1").chapterId("chapter-1").name("S1").build();
+        Scene s2 = Scene.builder().id("s-2").chapterId("chapter-1").name("S2").build();
+        when(sceneRepository.findByChapterId("chapter-1")).thenReturn(List.of(s1, s2));
+
+        chapterService.deleteChapter("chapter-1");
+
+        verify(sceneRepository).deleteById("s-1");
+        verify(sceneRepository).deleteById("s-2");
+        verify(chapterRepository).deleteById("chapter-1");
+    }
+
+    @Test
+    void testGetDeletionImpact() {
+        Scene s1 = Scene.builder().id("s-1").chapterId("chapter-1").name("S1").build();
+        Scene s2 = Scene.builder().id("s-2").chapterId("chapter-1").name("S2").build();
+        when(sceneRepository.findByChapterId("chapter-1")).thenReturn(List.of(s1, s2));
+
+        ChapterService.DeletionImpact impact = chapterService.getDeletionImpact("chapter-1");
+
+        assertEquals(2, impact.scenes());
     }
 
     @Test

core/src/test/java/com/loremind/application/campaigncontext/NpcServiceTest.java

@@ -0,0 +1,159 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Npc;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+/**
+ * Test unitaire pour NpcService.
+ * Couvre la création (avec auto-calcul de l'order), la lecture, la mise à jour
+ * (incl. cas non trouvé), la suppression, et le calcul d'order.
+ */
+@ExtendWith(MockitoExtension.class)
+public class NpcServiceTest {
+
+    @Mock
+    private NpcRepository npcRepository;
+
+    @InjectMocks
+    private NpcService npcService;
+
+    private Npc testNpc;
+
+    @BeforeEach
+    void setUp() {
+        testNpc = Npc.builder()
+                .id("npc-1")
+                .name("Borin le forgeron")
+                .markdownContent("# Borin\nForgeron nain")
+                .campaignId("camp-1")
+                .order(1)
+                .build();
+    }
+
+    @Test
+    void testCreateNpc_WithExplicitOrder() {
+        when(npcRepository.save(any(Npc.class))).thenReturn(testNpc);
+
+        Npc result = npcService.createNpc(
+                new NpcService.NpcData("Borin le forgeron", "# Borin", "camp-1", 5));
+
+        assertNotNull(result);
+        ArgumentCaptor<Npc> captor = ArgumentCaptor.forClass(Npc.class);
+        verify(npcRepository).save(captor.capture());
+        assertEquals(5, captor.getValue().getOrder());
+    }
+
+    @Test
+    void testCreateNpc_AutoComputesNextOrder_WhenNullProvided() {
+        // Existant : 2 PNJ avec orders 0 et 3 → next = 4
+        Npc a = Npc.builder().id("a").campaignId("camp-1").order(0).build();
+        Npc b = Npc.builder().id("b").campaignId("camp-1").order(3).build();
+        when(npcRepository.findByCampaignId("camp-1")).thenReturn(List.of(a, b));
+        when(npcRepository.save(any(Npc.class))).thenReturn(testNpc);
+
+        npcService.createNpc(new NpcService.NpcData("Nouveau", null, "camp-1", null));
+
+        ArgumentCaptor<Npc> captor = ArgumentCaptor.forClass(Npc.class);
+        verify(npcRepository).save(captor.capture());
+        assertEquals(4, captor.getValue().getOrder());
+    }
+
+    @Test
+    void testCreateNpc_FirstNpcGetsOrderZero() {
+        when(npcRepository.findByCampaignId("camp-1")).thenReturn(List.of());
+        when(npcRepository.save(any(Npc.class))).thenReturn(testNpc);
+
+        npcService.createNpc(new NpcService.NpcData("Premier", null, "camp-1", null));
+
+        ArgumentCaptor<Npc> captor = ArgumentCaptor.forClass(Npc.class);
+        verify(npcRepository).save(captor.capture());
+        assertEquals(0, captor.getValue().getOrder());
+    }
+
+    @Test
+    void testGetNpcById_Found() {
+        when(npcRepository.findById("npc-1")).thenReturn(Optional.of(testNpc));
+
+        Optional<Npc> result = npcService.getNpcById("npc-1");
+
+        assertTrue(result.isPresent());
+        assertEquals("Borin le forgeron", result.get().getName());
+    }
+
+    @Test
+    void testGetNpcById_NotFound() {
+        when(npcRepository.findById("missing")).thenReturn(Optional.empty());
+
+        Optional<Npc> result = npcService.getNpcById("missing");
+
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void testGetNpcsByCampaignId_DelegatesToRepository() {
+        Npc a = Npc.builder().id("a").campaignId("camp-1").order(1).build();
+        Npc b = Npc.builder().id("b").campaignId("camp-1").order(2).build();
+        when(npcRepository.findByCampaignId("camp-1")).thenReturn(List.of(a, b));
+
+        List<Npc> result = npcService.getNpcsByCampaignId("camp-1");
+
+        assertEquals(2, result.size());
+        verify(npcRepository).findByCampaignId("camp-1");
+    }
+
+    @Test
+    void testUpdateNpc_Success() {
+        when(npcRepository.findById("npc-1")).thenReturn(Optional.of(testNpc));
+        when(npcRepository.save(any(Npc.class))).thenAnswer(inv -> inv.getArgument(0));
+
+        Npc result = npcService.updateNpc("npc-1",
+                new NpcService.NpcData("Borin renommé", "# v2", "camp-1", 7));
+
+        assertEquals("Borin renommé", result.getName());
+        assertEquals("# v2", result.getMarkdownContent());
+        assertEquals(7, result.getOrder());
+    }
+
+    @Test
+    void testUpdateNpc_OrderNullPreservesExistingOrder() {
+        when(npcRepository.findById("npc-1")).thenReturn(Optional.of(testNpc));
+        when(npcRepository.save(any(Npc.class))).thenAnswer(inv -> inv.getArgument(0));
+
+        Npc result = npcService.updateNpc("npc-1",
+                new NpcService.NpcData("Borin", "# txt", "camp-1", null));
+
+        // testNpc avait order=1 → préservé
+        assertEquals(1, result.getOrder());
+    }
+
+    @Test
+    void testUpdateNpc_NotFoundThrows() {
+        when(npcRepository.findById("missing")).thenReturn(Optional.empty());
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                () -> npcService.updateNpc("missing",
+                        new NpcService.NpcData("x", null, "camp-1", null)));
+        assertTrue(ex.getMessage().contains("missing"));
+        verify(npcRepository, never()).save(any());
+    }
+
+    @Test
+    void testDeleteNpc_DelegatesToRepository() {
+        npcService.deleteNpc("npc-1");
+        verify(npcRepository).deleteById("npc-1");
+    }
+}

core/src/test/java/com/loremind/application/campaigncontext/SceneServiceTest.java

@@ -178,10 +178,7 @@ public class SceneServiceTest {
     @Test
     void testUpdateScene_WithValidBranches() {
         // Arrange
-        SceneBranch branch = SceneBranch.builder()
+        SceneBranch branch = SceneBranch.of("Go to scene 2", "scene-2");
-                .targetSceneId("scene-2")
-                .label("Go to scene 2")
-                .build();
         Scene updatedScene = Scene.builder()
                 .name("Updated Scene")
                 .branches(List.of(branch))
@@ -203,10 +200,7 @@ public class SceneServiceTest {
     @Test
     void testUpdateScene_WithBranchToSelf() {
         // Arrange
-        SceneBranch branch = SceneBranch.builder()
+        SceneBranch branch = SceneBranch.of("Self-reference", "scene-1");
-                .targetSceneId("scene-1")
-                .label("Self-reference")
-                .build();
         Scene updatedScene = Scene.builder()
                 .name("Updated Scene")
                 .branches(List.of(branch))
@@ -228,10 +222,7 @@ public class SceneServiceTest {
     @Test
     void testUpdateScene_WithBranchToDifferentChapter() {
         // Arrange
-        SceneBranch branch = SceneBranch.builder()
+        SceneBranch branch = SceneBranch.of("Go to other chapter", "scene-other-chapter");
-                .targetSceneId("scene-other-chapter")
-                .label("Go to other chapter")
-                .build();
         Scene updatedScene = Scene.builder()
                 .name("Updated Scene")
                 .branches(List.of(branch))
@@ -253,10 +244,7 @@ public class SceneServiceTest {
     @Test
     void testUpdateScene_WithBranchNullTarget() {
         // Arrange
-        SceneBranch branch = SceneBranch.builder()
+        SceneBranch branch = SceneBranch.of("Null target", null);
-                .targetSceneId(null)
-                .label("Null target")
-                .build();
         Scene updatedScene = Scene.builder()
                 .name("Updated Scene")
                 .branches(List.of(branch))
@@ -277,10 +265,7 @@ public class SceneServiceTest {
     @Test
     void testUpdateScene_WithBranchBlankTarget() {
         // Arrange
-        SceneBranch branch = SceneBranch.builder()
+        SceneBranch branch = SceneBranch.of("Blank target", "   ");
-                .targetSceneId("   ")
-                .label("Blank target")
-                .build();
         Scene updatedScene = Scene.builder()
                 .name("Updated Scene")
                 .branches(List.of(branch))

core/src/test/java/com/loremind/application/generationcontext/CampaignStructuralContextBuilderTest.java

@@ -3,11 +3,15 @@ package com.loremind.application.generationcontext;
 import com.loremind.domain.campaigncontext.Arc;
 import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.Character;
+import com.loremind.domain.campaigncontext.Npc;
 import com.loremind.domain.campaigncontext.Scene;
 import com.loremind.domain.campaigncontext.SceneBranch;
 import com.loremind.domain.campaigncontext.ports.ArcRepository;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.domain.campaigncontext.ports.CharacterRepository;
+import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import com.loremind.domain.generationcontext.CampaignStructuralContext;
 import org.junit.jupiter.api.BeforeEach;
@@ -40,6 +44,10 @@ public class CampaignStructuralContextBuilderTest {
     private ChapterRepository chapterRepository;
     @Mock
     private SceneRepository sceneRepository;
+    @Mock
+    private CharacterRepository characterRepository;
+    @Mock
+    private NpcRepository npcRepository;
 
     @InjectMocks
     private CampaignStructuralContextBuilder builder;
@@ -71,9 +79,9 @@ public class CampaignStructuralContextBuilderTest {
 
         CampaignStructuralContext ctx = builder.build("camp-1");
 
-        assertEquals("Les Terres Brisées", ctx.getCampaignName());
+        assertEquals("Les Terres Brisées", ctx.campaignName());
-        assertEquals("Campagne dark fantasy", ctx.getCampaignDescription());
+        assertEquals("Campagne dark fantasy", ctx.campaignDescription());
-        assertTrue(ctx.getArcs().isEmpty());
+        assertTrue(ctx.arcs().isEmpty());
     }
 
     @Test
@@ -97,19 +105,19 @@ public class CampaignStructuralContextBuilderTest {
 
         CampaignStructuralContext ctx = builder.build("camp-1");
 
-        assertEquals(2, ctx.getArcs().size());
+        assertEquals(2, ctx.arcs().size());
-        assertEquals("Arc A", ctx.getArcs().get(0).getName());
+        assertEquals("Arc A", ctx.arcs().get(0).name());
-        assertEquals("Arc B", ctx.getArcs().get(1).getName());
+        assertEquals("Arc B", ctx.arcs().get(1).name());
 
         // Chapitres tries : ch2 (order 1) avant ch1 (order 2)
-        assertEquals(2, ctx.getArcs().get(0).getChapters().size());
+        assertEquals(2, ctx.arcs().get(0).chapters().size());
-        assertEquals("Ch B", ctx.getArcs().get(0).getChapters().get(0).getName());
+        assertEquals("Ch B", ctx.arcs().get(0).chapters().get(0).name());
-        assertEquals("Ch A", ctx.getArcs().get(0).getChapters().get(1).getName());
+        assertEquals("Ch A", ctx.arcs().get(0).chapters().get(1).name());
 
         // Scenes dans ch-1 : s2 (order 1) avant s1 (order 2)
-        var chADto = ctx.getArcs().get(0).getChapters().get(1);
+        var chADto = ctx.arcs().get(0).chapters().get(1);
-        assertEquals("Scene B", chADto.getScenes().get(0).getName());
+        assertEquals("Scene B", chADto.scenes().get(0).name());
-        assertEquals("Scene A", chADto.getScenes().get(1).getName());
+        assertEquals("Scene A", chADto.scenes().get(1).name());
     }
 
     @Test
@@ -117,15 +125,8 @@ public class CampaignStructuralContextBuilderTest {
         Arc arc = Arc.builder().id("arc-1").name("Arc").description("").order(1).build();
         Chapter ch = Chapter.builder().id("ch-1").arcId("arc-1").name("Ch").description("").order(1).build();
 
-        SceneBranch validBranch = SceneBranch.builder()
+        SceneBranch validBranch = new SceneBranch("Si les joueurs fuient", "s-2", "en cas de combat perdu");
-                .label("Si les joueurs fuient")
+        SceneBranch danglingBranch = SceneBranch.of("Vers l'inconnu", "s-inconnu");
-                .targetSceneId("s-2")
-                .condition("en cas de combat perdu")
-                .build();
-        SceneBranch danglingBranch = SceneBranch.builder()
-                .label("Vers l'inconnu")
-                .targetSceneId("s-inconnu")
-                .build();
 
         Scene s1 = Scene.builder().id("s-1").chapterId("ch-1").name("Entrée").description("")
                 .order(1)
@@ -140,12 +141,72 @@ public class CampaignStructuralContextBuilderTest {
 
         CampaignStructuralContext ctx = builder.build("camp-1");
 
-        var scene1Summary = ctx.getArcs().get(0).getChapters().get(0).getScenes().get(0);
+        var scene1Summary = ctx.arcs().get(0).chapters().get(0).scenes().get(0);
-        assertEquals(2, scene1Summary.getBranches().size());
+        assertEquals(2, scene1Summary.branches().size());
-        assertEquals("Fuite", scene1Summary.getBranches().get(0).getTargetSceneName());
+        assertEquals("Fuite", scene1Summary.branches().get(0).targetSceneName());
-        assertEquals("en cas de combat perdu", scene1Summary.getBranches().get(0).getCondition());
+        assertEquals("en cas de combat perdu", scene1Summary.branches().get(0).condition());
         // ID inconnu → libellé de fallback
-        assertEquals("(scène inconnue)", scene1Summary.getBranches().get(1).getTargetSceneName());
+        assertEquals("(scène inconnue)", scene1Summary.branches().get(1).targetSceneName());
+    }
+
+    @Test
+    void testBuild_ProjectsCharactersAndNpcsWithSnippets() {
+        Character pj1 = Character.builder().id("c-1").campaignId("camp-1").order(1)
+                .name("Aragorn")
+                .markdownContent("# Aragorn\n\nRôdeur du Nord, héritier d'Isildur.")
+                .build();
+        Character pj2 = Character.builder().id("c-2").campaignId("camp-1").order(2)
+                .name("Legolas")
+                .markdownContent(null) // pas de snippet → string vide
+                .build();
+        Npc npc1 = Npc.builder().id("n-1").campaignId("camp-1").order(2)
+                .name("Borin le forgeron")
+                .markdownContent("# Borin\n\nNain barbu au regard perçant, ancien clan Feuillefer.")
+                .build();
+        Npc npc2 = Npc.builder().id("n-2").campaignId("camp-1").order(1)
+                .name("Dame Elara")
+                .markdownContent("")
+                .build();
+
+        when(campaignRepository.findById("camp-1")).thenReturn(Optional.of(campaign));
+        when(arcRepository.findByCampaignId("camp-1")).thenReturn(List.of());
+        when(characterRepository.findByCampaignId("camp-1")).thenReturn(List.of(pj2, pj1));
+        when(npcRepository.findByCampaignId("camp-1")).thenReturn(List.of(npc1, npc2));
+
+        CampaignStructuralContext ctx = builder.build("camp-1");
+
+        // PJ triés par order croissant
+        assertEquals(2, ctx.characters().size());
+        assertEquals("Aragorn", ctx.characters().get(0).name());
+        assertEquals("Rôdeur du Nord, héritier d'Isildur.", ctx.characters().get(0).snippet());
+        assertEquals("Legolas", ctx.characters().get(1).name());
+        assertEquals("", ctx.characters().get(1).snippet());
+
+        // PNJ triés par order croissant : Elara (1) avant Borin (2)
+        assertEquals(2, ctx.npcs().size());
+        assertEquals("Dame Elara", ctx.npcs().get(0).name());
+        assertEquals("", ctx.npcs().get(0).snippet());
+        assertEquals("Borin le forgeron", ctx.npcs().get(1).name());
+        assertEquals("Nain barbu au regard perçant, ancien clan Feuillefer.",
+                ctx.npcs().get(1).snippet());
+    }
+
+    @Test
+    void testBuild_TruncatesLongSnippet() {
+        // Snippet > 160 chars : doit être tronqué à 159 + "…"
+        String longLine = "x".repeat(200);
+        Npc longNpc = Npc.builder().id("n-1").campaignId("camp-1").order(1)
+                .name("Verbeux").markdownContent(longLine).build();
+
+        when(campaignRepository.findById("camp-1")).thenReturn(Optional.of(campaign));
+        when(arcRepository.findByCampaignId("camp-1")).thenReturn(List.of());
+        when(npcRepository.findByCampaignId("camp-1")).thenReturn(List.of(longNpc));
+
+        CampaignStructuralContext ctx = builder.build("camp-1");
+
+        String snippet = ctx.npcs().get(0).snippet();
+        assertEquals(160, snippet.length());
+        assertTrue(snippet.endsWith("…"));
     }
 
     @Test
@@ -167,9 +228,9 @@ public class CampaignStructuralContextBuilderTest {
 
         CampaignStructuralContext ctx = builder.build("camp-1");
 
-        assertEquals(2, ctx.getArcs().get(0).getIllustrationCount());
+        assertEquals(2, ctx.arcs().get(0).illustrationCount());
-        assertEquals(0, ctx.getArcs().get(0).getChapters().get(0).getIllustrationCount());
+        assertEquals(0, ctx.arcs().get(0).chapters().get(0).illustrationCount());
-        assertEquals(1, ctx.getArcs().get(0).getChapters().get(0).getScenes().get(0).getIllustrationCount());
+        assertEquals(1, ctx.arcs().get(0).chapters().get(0).scenes().get(0).illustrationCount());
-        assertTrue(ctx.getArcs().get(0).getChapters().get(0).getScenes().get(0).getBranches().isEmpty());
+        assertTrue(ctx.arcs().get(0).chapters().get(0).scenes().get(0).branches().isEmpty());
     }
 }

core/src/test/java/com/loremind/application/generationcontext/GeneratePageValuesUseCaseTest.java

@@ -89,13 +89,13 @@ public class GeneratePageValuesUseCaseTest {
         verify(aiProvider).generatePage(captor.capture());
         GenerationContext ctx = captor.getValue();
 
-        assertEquals("Aetheria", ctx.getLoreName());
+        assertEquals("Aetheria", ctx.loreName());
-        assertEquals("monde aérien", ctx.getLoreDescription());
+        assertEquals("monde aérien", ctx.loreDescription());
-        assertEquals("PNJ", ctx.getFolderName());
+        assertEquals("PNJ", ctx.folderName());
-        assertEquals("Personnage", ctx.getTemplateName());
+        assertEquals("Personnage", ctx.templateName());
-        assertEquals("Alice", ctx.getPageTitle());
+        assertEquals("Alice", ctx.pageTitle());
         // Seuls les champs TEXT doivent etre envoyes (pas "Portrait" IMAGE).
-        assertEquals(List.of("Histoire", "Apparence"), ctx.getTemplateFields());
+        assertEquals(List.of("Histoire", "Apparence"), ctx.templateFields());
     }
 
     @Test