Mise à jour du pom coté pore pour intégrer une dépendance vers crypto.tink ; sinon la vérification de la licence patreon ne marche pas.

Correction de plusieurs anomalies : problème de switch entre 2 templates (par exemple si on était sur un template 1 et qu'on voulait passer directement au 2, ce dernier ne chargeait pas) ;
correction du soucis d'apparition de la sidebar à gauche qui disparaissait sans explication ; problème de redirection : lorsqu'on terminait de créer un PJ / PNJ ; on arrivait sur l'accueil de la campagne au lieu de voir le résultat de la création.
Problème de redirection également lors du clique sur un PNJ / PJ sur le coté : on arrivait sur l'édition au lieu de la présentation. Correction de la première lettre stylisée : tout est au même style comme ça plus de probleme de lecture.

Nouveautées : stylisation des modales (notamment suppression, warning.....) avec en prime l'ajout d'un warning lors du changement de système pour avertir que les fiches persos ne sont pas conservées.
Ajout d'une option pour créer un game system directement à la création d'une campagne afin de faciliter la mise en place de cette dernière.
Ajout d'un bouton pour créer un nouveau template directement lorsqu'on créer une page : ça permet de créer un template et de revenir sur la page qu'on était en train de créer sans perdre le titre.

Passage en bêta 0.8.4

.gitea/workflows/release.yml

@@ -85,57 +85,3 @@ jobs:
             ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/${{ matrix.component }}:${{ steps.meta.outputs.version }}
             ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-beta-${{ matrix.component }}:beta
             ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-beta-${{ matrix.component }}:${{ steps.meta.outputs.version }}
-
-  # Job separe pour le sidecar `switcher`.
-  # Pourquoi separe : le switcher est volontairement HORS de IMAGE_NAMESPACE
-  # (cf. docker-compose.yml). Il est toujours pulle depuis le repo public
-  # `loremind-switcher`, quel que soit le canal de l'instance. On le build
-  # donc uniquement sur les releases stables — pas la peine de re-publier
-  # une variante beta du switcher, c'est une infrastructure neutre.
-  build-switcher:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Detect channel
-        id: meta
-        run: |
-          VERSION="${GITHUB_REF_NAME#v}"
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
-          if [[ "${VERSION}" == *-beta* ]]; then
-            echo "channel=beta" >> $GITHUB_OUTPUT
-          else
-            echo "channel=stable" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Login to Gitea Registry
-        if: steps.meta.outputs.channel == 'stable'
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GITEA_REGISTRY }}
-          username: ${{ env.GITEA_REGISTRY_USER }}
-          password: ${{ secrets.DOCKER_PAT }}
-
-      - name: Login to GHCR
-        if: steps.meta.outputs.channel == 'stable'
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.GHCR_REGISTRY }}
-          username: ${{ env.GHCR_NAMESPACE }}
-          password: ${{ secrets.GHCR_TOKEN }}
-
-      - name: Build & push switcher (stable only)
-        if: steps.meta.outputs.channel == 'stable'
-        uses: docker/build-push-action@v5
-        with:
-          context: ./switcher
-          push: true
-          tags: |
-            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/switcher:latest
-            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/switcher:${{ steps.meta.outputs.version }}
-            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-switcher:latest
-            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-switcher:${{ steps.meta.outputs.version }}

.gitignore

@@ -108,4 +108,3 @@ docker-compose.override.yml
 # ============================================================================
 relay/
 scripts/bump-version.mjs
-brain/data/notebooks/5.json

brain/Dockerfile

@@ -1,15 +1,7 @@
 FROM python:3.12-slim
 WORKDIR /app
 
-# curl : healthcheck docker.
+RUN apt-get update && apt-get install -y --no-install-recommends curl \
-# tesseract-ocr (+ langues fra/eng) : repli OCR de l'import de PDF de regles
-#   pour les pages sans couche texte (scans). Inutile pour les PDF born-digital
-#   mais necessaire pour couvrir tous les cas.
-RUN apt-get update && apt-get install -y --no-install-recommends \
-        curl \
-        tesseract-ocr \
-        tesseract-ocr-fra \
-        tesseract-ocr-eng \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .

brain/app/application/adapt_campaign.py

@@ -1,125 +0,0 @@
-"""Use case : conseils d'adaptation d'un PDF à une campagne EXISTANTE.
-
-L'IA connaît la campagne de l'utilisateur (un « brief » : structure arcs/chapitres/
-scènes + PNJ + univers/lore), lit le contenu du PDF, et rédige des recommandations
-d'INTÉGRATION/ADAPTATION (où insérer, reskins de PNJ, transposition à l'univers,
-doublons à réconcilier…). Sortie en markdown, streamée token par token.
-
-Contrairement à l'IMPORT (qui produit une arborescence à créer), ici on produit
-du CONSEIL libre : rien n'est créé, l'utilisateur applique à la main.
-"""
-from __future__ import annotations
-
-import logging
-from typing import AsyncIterator
-
-from app.domain.models import ChatMessage
-from app.domain.ports import LLMChatProvider, PdfExtractionError, PdfTextExtractor
-
-logger = logging.getLogger(__name__)
-
-# Plus créatif que l'import (tâche de structuration) : ici on conseille/adapte.
-_TEMPERATURE = 0.7
-
-_SYSTEM_PREFIX = (
-    "Tu es un assistant pour Maître de Jeu de jeu de rôle. L'utilisateur a une "
-    "campagne EXISTANTE (décrite plus bas) et souhaite ADAPTER et INTÉGRER le "
-    "contenu d'un PDF (aventure, donjon, supplément) à CETTE campagne précise."
-)
-
-_SYSTEM_SUFFIX = (
-    "Produis des CONSEILS D'ADAPTATION concrets, actionnables et en FRANÇAIS, "
-    "en markdown structuré (titres ##, listes). Couvre notamment :\n"
-    "- **Où l'insérer** : à quel(s) arc(s)/chapitre(s) EXISTANT(s) rattacher ce "
-    "contenu, dans quel ordre, et — si l'arc est un hub — sous quelles conditions de déblocage.\n"
-    "- **Reskins / liens PNJ** : quels PNJ EXISTANTS de la campagne peuvent incarner "
-    "ou remplacer les personnages clés du PDF.\n"
-    "- **Adaptation à l'univers** : comment transposer lieux, factions, noms propres et "
-    "ton vers l'univers de l'utilisateur plutôt que le cadre d'origine du PDF.\n"
-    "- **Doublons / conflits** : ce qui recoupe l'existant et comment le réconcilier.\n"
-    "- **Ajustements de ton et de difficulté**.\n\n"
-    "Réfère-toi TOUJOURS aux éléments existants par leur NOM. Ne réécris PAS le PDF en "
-    "entier : donne des recommandations. Si une information manque, propose des options."
-)
-
-
-class AdaptCampaignUseCase:
-    """Génère (en streaming) des conseils d'adaptation d'un PDF à une campagne."""
-
-    def __init__(
-        self,
-        llm: LLMChatProvider,
-        extractor: PdfTextExtractor,
-        max_input_tokens: int = 10000,
-    ) -> None:
-        self._llm = llm
-        self._extractor = extractor
-        # L'adaptation envoie le PDF en UNE requête (pas de découpage). On plafonne
-        # donc l'entrée pour ne pas dépasser la taille de requête acceptée par le
-        # provider (sinon HTTP 400). Calé sur la taille des morceaux d'import.
-        self._max_input_tokens = max_input_tokens
-
-    async def stream(
-        self,
-        pdf_bytes: bytes,
-        brief: str,
-        messages: list[ChatMessage],
-    ) -> AsyncIterator[str]:
-        """Conversationnel : le PDF + la campagne sont le CONTEXTE (system prompt),
-        `messages` est l'échange (demande initiale, puis feedbacks de l'utilisateur)."""
-        doc = self._extractor.extract(pdf_bytes)
-        pdf_text = doc.full_text
-        if not pdf_text.strip():
-            raise PdfExtractionError("Aucun texte exploitable n'a été extrait du PDF.")
-
-        brief = brief or ""
-        pdf_text, truncated = self._fit_pdf_to_budget(pdf_text, brief)
-
-        logger.info(
-            "Adaptation campagne : %s page(s) (%s via OCR), brief %s car., PDF %s car.%s, %s message(s).",
-            doc.page_count, doc.ocr_page_count, len(brief), len(pdf_text),
-            " (tronqué)" if truncated else "", len(messages),
-        )
-
-        trunc_note = (
-            "\n[Note : PDF tronqué pour tenir dans une requête — base-toi sur ce début.]"
-            if truncated else ""
-        )
-        # Concaténation (pas .format) : brief/PDF peuvent contenir des { } littéraux.
-        system_prompt = (
-            f"{_SYSTEM_PREFIX}\n\n"
-            "--- CAMPAGNE EXISTANTE DE L'UTILISATEUR ---\n"
-            f"{brief.strip() or '(campagne encore vide)'}\n\n"
-            "--- CONTENU DU PDF À ADAPTER ---\n"
-            f"{pdf_text}{trunc_note}\n\n"
-            f"{_SYSTEM_SUFFIX}\n\n"
-            "Tu es en CONVERSATION : à chaque message de l'utilisateur, ajuste, corrige "
-            "ou propose des alternatives en gardant tout ce contexte à l'esprit."
-        )
-
-        # 1er tour : si aucun message, on lance la demande initiale par défaut.
-        convo = messages or [ChatMessage(
-            role="user",
-            content="Propose-moi comment intégrer et adapter ce PDF à ma campagne.",
-        )]
-
-        async for token in self._llm.stream_chat(
-            convo, system_prompt=system_prompt, temperature=_TEMPERATURE
-        ):
-            yield token
-
-    def _fit_pdf_to_budget(self, pdf_text: str, brief: str) -> tuple[str, bool]:
-        """Tronque le texte du PDF pour que (brief + PDF) tienne dans le budget tokens.
-
-        Évite un HTTP 400 « requête trop grosse » côté provider. Réserve une marge
-        pour le prompt système et le brief.
-        """
-        import tiktoken
-
-        enc = tiktoken.get_encoding("cl100k_base")
-        brief_tokens = len(enc.encode(brief))
-        budget = max(2000, self._max_input_tokens - brief_tokens - 1000)  # 1000 = marge système
-        pdf_tokens = enc.encode(pdf_text)
-        if len(pdf_tokens) <= budget:
-            return pdf_text, False
-        return enc.decode(pdf_tokens[:budget]), True

brain/app/application/chat.py

@@ -23,13 +23,10 @@ from app.domain.models import (
     CharacterSummary,
     NpcSummary,
     GameSystemContext,
-    JournalEntrySummary,
     LoreStructuralContext,
     NarrativeEntityContext,
     PageContext,
     PageSummary,
-    QuestSummary,
-    SessionContext,
 )
 from app.domain.ports import LLMChatProvider
 
@@ -70,7 +67,6 @@ class ChatUseCase:
         campaign_context: CampaignStructuralContext | None = None,
         narrative_entity: NarrativeEntityContext | None = None,
         game_system_context: GameSystemContext | None = None,
-        session_context: SessionContext | None = None,
     ) -> AsyncIterator[str]:
         """Streame les tokens de la réponse assistant pour le dernier message user.
 
@@ -80,7 +76,7 @@ class ChatUseCase:
         cette règle à la frontière HTTP.
         """
         system_prompt = self._build_system_prompt(
-            lore_context, page_context, campaign_context, narrative_entity, game_system_context, session_context
+            lore_context, page_context, campaign_context, narrative_entity, game_system_context
         )
         async for token in self._llm.stream_chat(
             messages,
@@ -96,13 +92,12 @@ class ChatUseCase:
         campaign_context: CampaignStructuralContext | None = None,
         narrative_entity: NarrativeEntityContext | None = None,
         game_system_context: GameSystemContext | None = None,
-        session_context: SessionContext | None = None,
     ) -> str:
         """Version publique — utilisée par le controller HTTP pour compter
         les tokens du system prompt avant de streamer (jauge de contexte).
         """
         return self._build_system_prompt(
-            lore_context, page_context, campaign_context, narrative_entity, game_system_context, session_context
+            lore_context, page_context, campaign_context, narrative_entity, game_system_context
         )
 
     # --- Construction du system prompt --------------------------------------
@@ -114,7 +109,6 @@ class ChatUseCase:
         campaign: CampaignStructuralContext | None,
         narrative: NarrativeEntityContext | None,
         game_system: GameSystemContext | None = None,
-        session: SessionContext | None = None,
     ) -> str:
         sections = [_BASE_SYSTEM]
         if lore is not None:
@@ -127,8 +121,6 @@ class ChatUseCase:
             sections.append(self._format_page(page))
         if narrative is not None:
             sections.append(self._format_narrative_entity(narrative))
-        if session is not None:
-            sections.append(self._format_session(session))
         return "\n\n".join(sections)
 
     # --- Blocs Lore ---------------------------------------------------------
@@ -296,8 +288,7 @@ class ChatUseCase:
         else:
             for scene in chapter.scenes:
                 sc_hint = ChatUseCase._illustration_hint(scene.illustration_count)
-                scene_kind = " (lieu explorable)" if scene.rooms else " (scène)"
+                block.append(f"        - {scene.name} (scène){sc_hint}")
-                block.append(f"        - {scene.name}{scene_kind}{sc_hint}")
                 if scene.description:
                     block.append(f"          Description : {scene.description}")
                 for br in scene.branches:
@@ -305,19 +296,6 @@ class ChatUseCase:
                     block.append(
                         f'          → "{br.label}" vers {br.target_scene_name}{cond}'
                     )
-                # Pièces du lieu explorable (mode donjon)
-                for room in scene.rooms:
-                    floor = f" [étage {room.floor}]" if room.floor is not None else ""
-                    block.append(f"          ◆ {room.name}{floor}")
-                    if room.description:
-                        block.append(f"            {room.description}")
-                    if room.enemies:
-                        block.append(f"            Ennemis : {room.enemies}")
-                    for rb in room.branches:
-                        cond = f" (si : {rb.condition})" if rb.condition else ""
-                        block.append(
-                            f'            ↳ "{rb.label}" vers {rb.target_room_name}{cond}'
-                        )
         return block
 
     @staticmethod
@@ -364,141 +342,6 @@ class ChatUseCase:
             f"{sections_block}"
         )
 
-    # --- Bloc Session de jeu (Play Context) ---------------------------------
-
-    _ENTRY_TYPE_LABELS = {
-        "NOTE": "Note du MJ",
-        "EVENT": "Évènement",
-        "DICE_ROLL": "Jet de dés",
-        "PLAYER_ACTION": "Action joueur",
-    }
-
-    @staticmethod
-    def _format_session(sc: SessionContext) -> str:
-        """Bloc journal de la session en cours + résumé des sessions précédentes.
-
-        Fournit à l'IA le contexte temporel : ce qui s'est passé jusqu'ici,
-        dans l'ordre chronologique. Permet de référencer un PNJ rencontré,
-        rappeler un évènement antérieur, ou rebondir sur une action joueur.
-
-        Pour les sessions PRÉCÉDENTES de la même campagne, on ne remonte que
-        les EVENTs (les moments marquants) pour préserver le contexte LLM.
-        """
-        status = "EN COURS" if sc.active else "TERMINÉE"
-        started = f" — démarrée {sc.started_at}" if sc.started_at else ""
-
-        previous_block = ChatUseCase._format_previous_events(sc.previous_events)
-        hub_block = ChatUseCase._format_hub_status(sc)
-
-        if not sc.entries:
-            current_block = "(Aucune entrée dans le journal pour l'instant — la session vient de commencer.)"
-        else:
-            lines: list[str] = []
-            for e in sc.entries:
-                label = ChatUseCase._ENTRY_TYPE_LABELS.get(e.type, e.type)
-                ts = f" [{e.occurred_at}]" if e.occurred_at else ""
-                content = e.content.replace("\n", "\n    ")
-                lines.append(f"- {label}{ts} : {content}")
-            current_block = "\n".join(lines)
-
-        return (
-            "--- SESSION DE JEU EN COURS ---\n"
-            f"Nom : {sc.session_name}\n"
-            f"Statut : {status}{started}\n"
-            f"{hub_block}"
-            f"{previous_block}"
-            "\nJournal chronologique de la session courante (du plus ancien au plus récent) :\n"
-            f"{current_block}\n\n"
-            "IMPORTANT : tu es l'assistant du MJ PENDANT la partie. Tes réponses doivent :\n"
-            "- Tenir compte des évènements déjà capturés (sessions précédentes + journal courant).\n"
-            "- Être concrètes et utiles en temps réel : descriptions sensorielles, "
-            "réactions de PNJ cohérentes avec leur fiche, suggestions de complications "
-            "qui s'enchaînent à ce qui vient de se passer.\n"
-            "- Éviter les longs développements : le MJ est en train d'animer une partie, "
-            "il a besoin d'idées immédiatement actionnables."
-        )
-
-    @staticmethod
-    def _format_hub_status(sc: SessionContext) -> str:
-        """Bloc Hub : quêtes ouvertes + flags actifs.
-
-        Vide si la campagne n'a aucun Arc HUB (toutes les listes vides côté Core).
-        Les quêtes LOCKED apparaissent par leur TITRE uniquement : l'IA sait
-        qu'elles existent (utile pour les teasers, les rumeurs en jeu) mais ne
-        peut pas spoiler leurs détails.
-        """
-        if (not sc.available_quests
-                and not sc.in_progress_quests
-                and not sc.locked_quest_titles
-                and not sc.active_flags):
-            return ""
-
-        lines = ["", "État du Hub (quêtes parallèles et faits narratifs) :"]
-
-        if sc.in_progress_quests:
-            lines.append("  Quêtes en cours :")
-            lines.extend(ChatUseCase._format_quest_lines(sc.in_progress_quests))
-
-        if sc.available_quests:
-            lines.append("  Quêtes disponibles (non démarrées, prêtes à être lancées) :")
-            lines.extend(ChatUseCase._format_quest_lines(sc.available_quests))
-
-        if sc.locked_quest_titles:
-            titles = ", ".join(f'"{t}"' for t in sc.locked_quest_titles)
-            lines.append(
-                "  Quêtes encore verrouillées (existent mais non accessibles — "
-                f"tu peux y faire allusion sous forme de rumeurs sans spoiler leur contenu) : {titles}"
-            )
-
-        if sc.active_flags:
-            lines.append(
-                "  Faits actifs : " + ", ".join(f"`{f}`" for f in sc.active_flags)
-            )
-
-        lines.append(
-            "  Conseille des actions cohérentes avec ces quêtes ouvertes. Ne fais "
-            "PAS comme si une quête verrouillée était déjà accessible aux PJ."
-        )
-        lines.append("")  # séparateur visuel avant le récap des sessions précédentes
-        return "\n".join(lines)
-
-    @staticmethod
-    def _format_quest_lines(quests: list[QuestSummary]) -> list[str]:
-        """Sérialise une liste de QuestSummary en lignes indentées."""
-        out: list[str] = []
-        for q in quests:
-            arc = f" [arc : {q.arc_name}]" if q.arc_name else ""
-            out.append(f"    - {q.name}{arc}")
-            if q.description:
-                out.append(f"      Synopsis : {q.description}")
-        return out
-
-    @staticmethod
-    def _format_previous_events(events: list[JournalEntrySummary]) -> str:
-        """Bloc "Story so far" : EVENTs marquants des sessions antérieures.
-
-        Vide si la campagne en est à sa première session. On groupe par
-        session source pour aider l'IA à situer chaque évènement temporellement.
-        """
-        if not events:
-            return ""
-
-        # Groupement par session source en préservant l'ordre d'apparition.
-        grouped: dict[str, list[JournalEntrySummary]] = {}
-        for e in events:
-            key = e.source_session_name or "(session inconnue)"
-            grouped.setdefault(key, []).append(e)
-
-        lines = ["\nRécapitulatif des sessions précédentes (évènements marquants uniquement) :"]
-        for session_name, items in grouped.items():
-            lines.append(f"  • {session_name} :")
-            for e in items:
-                ts = f" [{e.occurred_at}]" if e.occurred_at else ""
-                content = e.content.replace("\n", "\n        ")
-                lines.append(f"    - {content}{ts}")
-        lines.append("")  # ligne vide avant le bloc journal courant
-        return "\n".join(lines) + "\n"
-
     @staticmethod
     def _format_narrative_entity(ne: NarrativeEntityContext) -> str:
         """Bloc équivalent à _format_page mais pour Arc/Chapter/Scene."""

brain/app/application/chunking.py

@@ -1,79 +0,0 @@
-"""Découpage d'un long texte en morceaux qui tiennent dans la fenêtre LLM.
-
-Partagé par les imports (règles, campagne) : un livre dépasse la fenêtre de
-contexte, on le découpe par paragraphes jusqu'à une cible de tokens, en coupant
-les paragraphes géants si besoin. Dimensionnement via tiktoken (cl100k_base),
-approximation suffisante (±10% vs tokenizer natif).
-"""
-from __future__ import annotations
-
-# Cible conservatrice : tient dans une fenêtre Ollama (num_ctx 16384) en laissant
-# la place au prompt + à la sortie JSON. Les providers à grand contexte (1min.ai)
-# le supportent largement.
-CHUNK_TARGET_TOKENS = 6000
-
-
-def chunk_text(full_text: str, target_tokens: int = CHUNK_TARGET_TOKENS) -> list[str]:
-    """Découpe `full_text` en morceaux ~`target_tokens` tokens (frontières de §)."""
-    if not full_text.strip():
-        return []
-
-    import tiktoken
-
-    enc = tiktoken.get_encoding("cl100k_base")
-    paragraphs = [p for p in full_text.split("\n\n") if p.strip()]
-
-    chunks: list[str] = []
-    current: list[str] = []
-    current_tokens = 0
-    for para in paragraphs:
-        para_tokens = len(enc.encode(para))
-        # Un paragraphe seul plus gros que la cible : on le coupe en sous-blocs.
-        if para_tokens > target_tokens:
-            if current:
-                chunks.append("\n\n".join(current))
-                current, current_tokens = [], 0
-            chunks.extend(_split_oversized(para, enc, target_tokens))
-            continue
-        if current_tokens + para_tokens > target_tokens and current:
-            chunks.append("\n\n".join(current))
-            current, current_tokens = [], 0
-        current.append(para)
-        current_tokens += para_tokens
-
-    if current:
-        chunks.append("\n\n".join(current))
-    return chunks
-
-
-def _split_oversized(paragraph: str, enc, target_tokens: int) -> list[str]:
-    """Coupe un paragraphe géant en sous-blocs ~`target_tokens` tokens."""
-    tokens = enc.encode(paragraph)
-    out: list[str] = []
-    for i in range(0, len(tokens), target_tokens):
-        out.append(enc.decode(tokens[i : i + target_tokens]))
-    return out
-
-
-def split_in_half(text: str) -> tuple[str, str]:
-    """Coupe `text` en deux moitiés ~égales, de préférence sur un saut de ligne
-    proche du milieu (pour ne pas trancher en plein mot/phrase).
-
-    Sert au repli anti-troncature des imports : quand la SORTIE d'un morceau est
-    coupée (le modèle ne peut pas tout réécrire en une réponse), on retraite ce
-    morceau en deux moitiés. Renvoie ('', '') si le texte est trop court pour
-    être découpé utilement (garde-fou anti-récursion infinie).
-    """
-    text = text.strip()
-    if len(text) < 400:
-        return "", ""
-    mid = len(text) // 2
-    # Cherche un saut de ligne juste avant le milieu, sinon juste après.
-    cut = text.rfind("\n", 0, mid)
-    if cut < len(text) // 4:
-        nxt = text.find("\n", mid)
-        cut = nxt if nxt != -1 else mid
-    left, right = text[:cut].strip(), text[cut:].strip()
-    if not left or not right:
-        return "", ""
-    return left, right

brain/app/application/embeddings.py

@@ -1,20 +0,0 @@
-"""Port d'embeddings (RAG des notebooks).
-
-Abstraction du calcul de vecteurs : un texte → une liste de floats. Les adapters
-concrets (Ollama local, Mistral cloud) la satisfont par duck typing, comme pour
-les LLMProvider. Le RAG n'en dépend que via cette interface.
-"""
-from __future__ import annotations
-
-from typing import Protocol
-
-
-class EmbeddingError(Exception):
-    """Échec du calcul d'embeddings (modèle indisponible, réseau, quota…)."""
-
-
-class EmbeddingProvider(Protocol):
-    """Calcule les vecteurs d'une liste de textes (ordre préservé)."""
-
-    async def embed(self, texts: list[str]) -> list[list[float]]:
-        ...

brain/app/application/import_campaign.py

@@ -1,373 +0,0 @@
-"""Use case : import d'un PDF de campagne → arbre arc → chapitre → scène.
-
-Couche APPLICATION. Même chaîne que l'import de règles (extraction + OCR +
-chunking + map-reduce) mais la cible est une ARBORESCENCE narrative :
-  - MAP    : chaque morceau → un sous-arbre {arcs:[{chapters:[{scenes}]}]}
-  - REDUCE : fusion par NOM à chaque niveau (un chapitre coupé entre 2 morceaux
-             est recollé ; ses scènes s'accumulent).
-
-PROPOSITION non persistée : le Core crée les entités seulement après revue.
-"""
-from __future__ import annotations
-
-import logging
-
-from app.application.chunking import chunk_text, split_in_half
-from app.application.llm_json import load_json_object, looks_like_truncated_json
-from app.application.llm_retry import generate_with_retry
-from app.application.streaming import with_heartbeat
-
-# Repli anti-troncature : si la sortie d'un morceau est coupée, on le retraite en
-# 2 moitiés. Borné en profondeur (3 niveaux => jusqu'à 8 sous-blocs).
-_MAX_SPLIT_DEPTH = 3
-from app.domain.models import (
-    ArcProposal,
-    CampaignImportResult,
-    ChapterProposal,
-    RoomProposal,
-    SceneProposal,
-)
-from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
-
-logger = logging.getLogger(__name__)
-
-# Très basse : structuration = recopie/réorganisation fidèle, pas de créativité.
-# Plus la valeur est haute, plus le modèle "brode" (invente du contenu absent).
-_TEMPERATURE = 0.1
-
-# Nom de l'arc unique quand le livre n'est pas découpé en actes/parties.
-_DEFAULT_ARC_NAME = "Aventure principale"
-
-# Morceaux PLUS GROS que pour les règles : l'IA voit une quête/un chapitre entier
-# d'un coup et le structure de façon cohérente (1 scène par lieu) au lieu de le
-# fragmenter en dizaines de scènes. Adapté aux providers à grand contexte (1min.ai).
-_CHUNK_TARGET_TOKENS = 10000
-
-_MAP_SYSTEM = """Tu es un assistant qui structure un livre de campagne de jeu de rôle.
-On te donne un EXTRAIT brut d'un PDF de campagne (texte parfois mal coupé par la mise en page).
-
-Ta tâche : en dégager une ARBORESCENCE narrative à GROS GRAIN : arcs → chapitres → scènes,
-et — pour les lieux explorables — leurs PIÈCES (rooms).
-  - Un ARC = un acte / une grande partie de la campagne (souvent un seul pour une aventure courte).
-  - Un CHAPITRE = une étape majeure du récit : un chapitre du livre, OU — dans une
-    campagne "hub" / bac-à-sable — UNE QUÊTE ou UN LIEU principal débloqué depuis le
-    point central (ex : Dragon of Icespire Peak → chaque quête/lieu = un chapitre).
-  - Une SCÈNE = un temps fort jouable du chapitre : un lieu, une rencontre clé, un moment pivot.
-  - Une PIÈCE (room) = une salle d'un lieu explorable (donjon, crypte, manoir...).
-
-TYPE D'ARC ("type") :
-- "HUB" si la campagne est un bac-à-sable : des quêtes/lieux optionnels, parallèles,
-  débloqués depuis un point central, SANS ordre fixe imposé (ex : Dragon of Icespire Peak).
-- "LINEAR" si les chapitres se jouent dans un ordre séquentiel imposé.
-- Dans le doute : "LINEAR".
-
-GRANULARITÉ (évite la sur-détection) :
-- Vise PEU de scènes : typiquement 1 à 6 par chapitre. PAS des dizaines.
-- Un LIEU EXPLORABLE (donjon, crypte, manoir, grotte à plusieurs salles) = UNE SEULE
-  scène. Ses salles vont dans le tableau "rooms" de cette scène — JAMAIS en scènes séparées.
-- NE crée PAS une scène par rencontre isolée, par PNJ, par monstre ou par paragraphe.
-- IGNORE : blocs de stats, listes de monstres, encarts de règles, légendes de cartes,
-  pieds de page, sommaires, crédits.
-
-CONTENU D'UNE SCÈNE (fidélité au livre — important) :
-- `description` = synopsis de la scène, 2 à 4 phrases (plus que 1 ligne, mais pas le texte intégral).
-- `player_narration` = le texte d'AMBIANCE « à lire aux joueurs » (encadrés / boxed text /
-  « lecture à voix haute »), recopié FIDÈLEMENT s'il existe dans l'extrait. Vide sinon.
-- `gm_notes` = les informations pour le MJ : secrets, développement, ce qui se passe,
-  conséquences, indices cachés. Vide si rien de tel.
-- Ne RÉSUME pas abusivement player_narration et gm_notes : recopie le contenu utile du livre.
-
-PIÈCES (rooms) — uniquement pour les scènes qui sont des lieux explorables :
-- Une entrée par salle numérotée/nommée du donjon (ex : "1. Entrée", "2. Salle des gardes").
-- `enemies` = créatures/boss de la salle (vide si aucune). `loot` = trésor/récompense (vide si aucun).
-- Pour une scène narrative classique (pas un donjon), "rooms" est un tableau vide [].
-
-Format de réponse :
-- Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
-- Schéma EXACT :
-  {{"arcs": [{{"name": "...", "description": "...", "type": "LINEAR",
-     "chapters": [{{"name": "...", "description": "...", "scenes": [
-        {{"name": "...", "description": "...", "player_narration": "...", "gm_notes": "...",
-          "rooms": [{{"name": "...", "description": "...", "enemies": "...", "loot": "..."}}]}}
-     ]}}]}}
-  ]}}
-- Utilise les VRAIS titres du livre pour les noms (pas de paraphrase).
-- Si le livre n'est PAS découpé en actes/parties, regroupe tout sous un seul arc nommé "{default_arc}".
-- N'invente pas de contenu : tu réorganises et recopies ce qui est présent dans l'extrait.
-- Si l'extrait ne contient aucune matière narrative, renvoie {{"arcs": []}}."""
-
-
-class _TreeMerger:
-    """Fusionne les sous-arbres des morceaux en un seul arbre, ordre préservé.
-
-    Clés insensibles à la casse à chaque niveau (nom d'arc / chapitre / scène).
-    Description : la première non-vide rencontrée l'emporte (les morceaux suivants
-    ne l'écrasent pas).
-    """
-
-    def __init__(self) -> None:
-        # arc_key -> {"name", "description", "chapters": {chap_key -> {...}}}
-        self._arcs: dict[str, dict] = {}
-
-    def add(self, arcs_json: list[dict]) -> None:
-        for arc in arcs_json or []:
-            name = str(arc.get("name", "")).strip()
-            if not name:
-                continue
-            a = self._arcs.setdefault(
-                name.lower(), {"name": name, "description": "", "type": "LINEAR", "chapters": {}})
-            self._fill_desc(a, arc)
-            # Type d'arc : HUB l'emporte si un seul morceau le signale (propriété globale
-            # souvent énoncée une fois, dans l'intro du livre).
-            if str(arc.get("type", "")).strip().upper() == "HUB":
-                a["type"] = "HUB"
-            for chap in arc.get("chapters", []) or []:
-                cname = str(chap.get("name", "")).strip()
-                if not cname:
-                    continue
-                c = a["chapters"].setdefault(cname.lower(), {"name": cname, "description": "", "scenes": {}})
-                self._fill_desc(c, chap)
-                for sc in chap.get("scenes", []) or []:
-                    sname = str(sc.get("name", "")).strip()
-                    if not sname:
-                        continue
-                    s = c["scenes"].setdefault(
-                        sname.lower(),
-                        {"name": sname, "description": "", "player_narration": "",
-                         "gm_notes": "", "rooms": {}})
-                    self._fill_desc(s, sc)
-                    self._fill_field(s, sc, "player_narration")
-                    self._fill_field(s, sc, "gm_notes")
-                    for rm in sc.get("rooms", []) or []:
-                        rname = str(rm.get("name", "")).strip()
-                        if not rname:
-                            continue
-                        r = s["rooms"].setdefault(
-                            rname.lower(),
-                            {"name": rname, "description": "", "enemies": "", "loot": ""})
-                        self._fill_desc(r, rm)
-                        self._fill_field(r, rm, "enemies")
-                        self._fill_field(r, rm, "loot")
-
-    @staticmethod
-    def _fill_desc(node: dict, src: dict) -> None:
-        if not node["description"]:
-            node["description"] = str(src.get("description") or "").strip()
-
-    @staticmethod
-    def _fill_field(node: dict, src: dict, field_name: str) -> None:
-        if not node[field_name]:
-            node[field_name] = str(src.get(field_name) or "").strip()
-
-    def result(self) -> list[ArcProposal]:
-        arcs: list[ArcProposal] = []
-        for a in self._arcs.values():
-            chapters: list[ChapterProposal] = []
-            for c in a["chapters"].values():
-                scenes: list[SceneProposal] = []
-                for s in c["scenes"].values():
-                    rooms = [
-                        RoomProposal(r["name"], r["description"], r["enemies"], r["loot"])
-                        for r in s["rooms"].values()
-                    ]
-                    scenes.append(SceneProposal(
-                        s["name"], s["description"], s["player_narration"], s["gm_notes"], rooms))
-                chapters.append(ChapterProposal(c["name"], c["description"], scenes))
-            arcs.append(ArcProposal(a["name"], a["description"], a["type"], chapters))
-        return arcs
-
-    def counts(self) -> tuple[int, int, int]:
-        arcs = len(self._arcs)
-        chapters = sum(len(a["chapters"]) for a in self._arcs.values())
-        scenes = sum(len(c["scenes"]) for a in self._arcs.values() for c in a["chapters"].values())
-        return arcs, chapters, scenes
-
-
-class ImportCampaignUseCase:
-    """Transforme un PDF de campagne en proposition d'arbre arc→chapitre→scène."""
-
-    def __init__(
-        self,
-        llm: LLMProvider,
-        extractor: PdfTextExtractor,
-        chunk_target_tokens: int = _CHUNK_TARGET_TOKENS,
-    ) -> None:
-        self._llm = llm
-        self._extractor = extractor
-        self._chunk_target_tokens = chunk_target_tokens
-
-    async def execute(self, pdf_bytes: bytes) -> CampaignImportResult:
-        """Variante non-streamée : traite tout puis renvoie l'arbre complet."""
-        doc = self._extractor.extract(pdf_bytes)
-        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
-        merger = _TreeMerger()
-        for i, chunk in enumerate(chunks):
-            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
-        return CampaignImportResult(
-            arcs=merger.result(),
-            page_count=doc.page_count,
-            ocr_page_count=doc.ocr_page_count,
-        )
-
-    async def stream(self, pdf_bytes: bytes):
-        """Variante streamée : yield des évènements d'avancement.
-
-        {"type":"extracting"}, puis {"type":"start", page_count, ocr_page_count,
-        total}, puis un {"type":"progress", current, total, arc_count,
-        chapter_count, scene_count} par morceau, et enfin
-        {"type":"done", arcs:[...], page_count, ocr_page_count}.
-        """
-        yield {"type": "extracting"}
-
-        doc = self._extractor.extract(pdf_bytes)
-        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
-        total = len(chunks)
-        logger.info(
-            "Import campagne (stream) : %s page(s) (%s via OCR), %s morceau(x).",
-            doc.page_count, doc.ocr_page_count, total,
-        )
-        yield {
-            "type": "start",
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-            "total": total,
-        }
-
-        merger = _TreeMerger()
-        skipped = 0
-        last_error: str | None = None
-        for i, chunk in enumerate(chunks):
-            # RÉSILIENCE : un morceau qui échoue (provider saturé, quota, etc.) est
-            # SAUTÉ — on ne perd pas tout l'import pour autant. On n'abandonne que
-            # si AUCUN morceau ne passe (cf. après la boucle).
-            # HEARTBEAT : keep-alive pendant l'appel LLM pour ne jamais laisser le
-            # flux SSE silencieux (sinon le Core coupe sur timeout d'inactivité).
-            try:
-                arcs_payload: list[dict] | None = None
-                async for kind, payload in with_heartbeat(
-                    self._map_chunk(chunk, index=i, total=total)
-                ):
-                    if kind == "heartbeat":
-                        yield {"type": "heartbeat", "current": i + 1, "total": total}
-                    else:
-                        arcs_payload = payload
-                merger.add(arcs_payload or [])
-            except LLMProviderError as exc:
-                skipped += 1
-                last_error = str(exc)
-                logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
-                yield {"type": "chunk_failed", "current": i + 1, "total": total,
-                       "message": str(exc)[:300]}
-            arcs, chapters, scenes = merger.counts()
-            yield {
-                "type": "progress",
-                "current": i + 1,
-                "total": total,
-                "arc_count": arcs,
-                "chapter_count": chapters,
-                "scene_count": scenes,
-                "skipped": skipped,
-            }
-
-        if total > 0 and skipped == total:
-            # Tout a échoué : "done" vide serait trompeur → erreur explicite.
-            yield {"type": "error",
-                   "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
-                              f"Dernier message : {last_error or 'inconnu'}"}
-            return
-
-        yield {
-            "type": "done",
-            "arcs": _serialize_arcs(merger.result()),
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-            "skipped": skipped,
-        }
-
-    # --- MAP : un morceau → sous-arbre ---------------------------------------
-
-    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> list[dict]:
-        return await self._extract_arcs(chunk, index=index, total=total, depth=0)
-
-    async def _extract_arcs(
-        self, text: str, *, index: int, total: int, depth: int
-    ) -> list[dict]:
-        """Extrait l'arborescence d'un texte. Si la SORTIE est tronquée, retraite le
-        texte en DEUX moitiés et concatène — le `_TreeMerger` final dédoublonne par
-        nom (un arc/chapitre coupé entre les moitiés est recollé)."""
-        prompt = (
-            _MAP_SYSTEM.format(default_arc=_DEFAULT_ARC_NAME)
-            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
-            "Renvoie maintenant le JSON de l'arborescence."
-        )
-        raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-        arcs, truncated = self._parse_arcs(raw, index=index)
-
-        if truncated and depth < _MAX_SPLIT_DEPTH:
-            left, right = split_in_half(text)
-            if left and right:
-                logger.info(
-                    "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
-                    index, depth + 1)
-                a = await self._extract_arcs(left, index=index, total=total, depth=depth + 1)
-                b = await self._extract_arcs(right, index=index, total=total, depth=depth + 1)
-                return a + b
-        if truncated:
-            logger.warning(
-                "Morceau %s : sortie tronquée, profondeur max atteinte — partiel conservé.", index)
-        return arcs
-
-    @staticmethod
-    def _parse_arcs(raw: str, *, index: int) -> tuple[list[dict], bool]:
-        """Parse robuste → (arcs, tronqué). `tronqué`=True si récupération partielle."""
-        parsed, recovered = load_json_object(raw)
-        if parsed is None:
-            truncated = looks_like_truncated_json(raw)
-            if not truncated:
-                logger.warning(
-                    "Morceau %s : aucun objet JSON exploitable, ignoré. "
-                    "Début de la réponse du modèle : %r",
-                    index, (raw or "").strip()[:300] or "(réponse VIDE)")
-            return [], truncated
-        if isinstance(parsed, dict):
-            arcs = parsed.get("arcs", [])
-            return (arcs if isinstance(arcs, list) else []), recovered
-        return [], recovered
-
-
-def _serialize_arcs(arcs: list[ArcProposal]) -> list[dict]:
-    """Sérialise l'arbre de dataclasses en dicts JSON pour le flux SSE."""
-    return [
-        {
-            "name": a.name,
-            "description": a.description,
-            "type": a.arc_type,
-            "chapters": [
-                {
-                    "name": c.name,
-                    "description": c.description,
-                    "scenes": [
-                        {
-                            "name": s.name,
-                            "description": s.description,
-                            "player_narration": s.player_narration,
-                            "gm_notes": s.gm_notes,
-                            "rooms": [
-                                {
-                                    "name": r.name,
-                                    "description": r.description,
-                                    "enemies": r.enemies,
-                                    "loot": r.loot,
-                                }
-                                for r in s.rooms
-                            ],
-                        }
-                        for s in c.scenes
-                    ],
-                }
-                for c in a.chapters
-            ],
-        }
-        for a in arcs
-    ]

brain/app/application/import_rules.py

@@ -1,279 +0,0 @@
-"""Use case : import d'un PDF de règles → sections markdown structurées.
-
-Couche APPLICATION. Orchestre :
-  PDF (bytes) → extraction texte (port PdfTextExtractor)
-              → CHUNKING (le texte d'un livre dépasse la fenêtre de contexte)
-              → MAP   : chaque morceau → {titre de section → markdown}
-              → REDUCE: fusion des sections de même titre entre morceaux
-              → RulesImportResult (proposition, NON persistée)
-
-Ne dépend que des abstractions du domaine (ports LLMProvider + PdfTextExtractor)
-→ testable avec des fakes, et indépendant du provider concret (Ollama/1min.ai).
-"""
-from __future__ import annotations
-
-import logging
-
-from app.application.chunking import CHUNK_TARGET_TOKENS, chunk_text, split_in_half
-from app.application.llm_json import load_json_object, looks_like_truncated_json
-from app.application.llm_retry import generate_with_retry
-from app.application.streaming import with_heartbeat
-
-# Repli anti-troncature : si la SORTIE d'un morceau est coupée (le modèle ne peut
-# pas tout réécrire en une réponse), on retraite ce morceau en 2 moitiés. Borné en
-# profondeur pour éviter une récursion infinie (3 niveaux => jusqu'à 8 sous-blocs ;
-# 1-2 niveaux suffisent en pratique, le reste est un garde-fou).
-_MAX_SPLIT_DEPTH = 3
-from app.domain.models import RulesImportResult
-from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
-
-logger = logging.getLogger(__name__)
-
-# Température basse : tâche de tri/réécriture fidèle, pas de créativité.
-# Très basse : structuration = recopie/réorganisation fidèle, pas de créativité.
-# Plus la valeur est haute, plus le modèle "brode" (invente du contenu absent).
-_TEMPERATURE = 0.1
-
-# Taxonomie canonique suggérée au modèle pour homogénéiser les titres entre
-# morceaux (sinon "Combat" / "Le combat" / "Règles de combat" se dispersent).
-# Le modèle reste libre d'en créer d'autres si rien ne correspond.
-_CANONICAL_SECTIONS = [
-    "Règles générales",
-    "Création de personnage",
-    "Caractéristiques et tests",
-    "Compétences",
-    "Combat",
-    "Magie et sorts",
-    "Équipement et objets",
-    "États et conditions",
-    "Repos et récupération",
-    "Progression et niveaux",
-    "Conseils au Maître de Jeu",
-]
-
-_MAP_SYSTEM = """Tu es un assistant qui réorganise un livre de règles de jeu de rôle.
-On te donne un EXTRAIT brut d'un PDF de règles (texte parfois mal coupé par la mise en page).
-
-Ta tâche : répartir le contenu de cet extrait dans des SECTIONS THÉMATIQUES.
-
-Règles impératives :
-- Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
-- Les CLÉS sont des titres de section (texte court). Les VALEURS sont le contenu de la règle en markdown.
-- Utilise EN PRIORITÉ ces titres canoniques quand le contenu y correspond :
-{canonical}
-- Si un contenu ne rentre dans aucun, crée un titre clair et concis (en français).
-- Reproduis FIDÈLEMENT les règles : tu peux nettoyer la coupure des lignes, recoller les mots coupés
-  par un tiret en fin de ligne, retirer les en-têtes/pieds de page et numéros de page parasites.
-- N'INVENTE AUCUNE règle, ne résume pas abusivement : tu réorganises, tu ne réécris pas le fond.
-- Ignore les pages de garde, sommaires, crédits, pages vides (renvoie {{}} si l'extrait n'a aucune règle)."""
-
-
-class _SectionMerger:
-    """Fusionne les sections issues des différents morceaux, ordre préservé.
-
-    Titres insensibles à la casse ("Combat" / "combat" → une seule clé). Chaque
-    `add()` renvoie la liste (dé-dupliquée, ordonnée) des titres touchés par ce
-    morceau — sert au flux de progression pour annoncer les sections trouvées.
-    """
-
-    def __init__(self) -> None:
-        self._merged: dict[str, list[str]] = {}
-        self._canonical_key: dict[str, str] = {}
-
-    def add(self, sections: dict[str, str]) -> list[str]:
-        touched: list[str] = []
-        for title, content in sections.items():
-            title = title.strip()
-            content = (content or "").strip()
-            if not title or not content:
-                continue
-            key = title.lower()
-            if key not in self._canonical_key:
-                self._canonical_key[key] = title
-                self._merged[title] = []
-            canonical = self._canonical_key[key]
-            self._merged[canonical].append(content)
-            touched.append(canonical)
-        # Dé-duplication en préservant l'ordre d'apparition.
-        seen: set[str] = set()
-        return [t for t in touched if not (t in seen or seen.add(t))]
-
-    def result(self) -> dict[str, str]:
-        return {title: "\n\n".join(parts) for title, parts in self._merged.items()}
-
-
-def _combine_sections(a: dict[str, str], b: dict[str, str]) -> dict[str, str]:
-    """Fusionne deux dicts de sections (issus des 2 moitiés d'un morceau re-découpé).
-
-    Titres insensibles à la casse : un même titre présent des deux côtés (une section
-    coupée par le re-découpage) voit ses contenus concaténés au lieu d'être écrasés.
-    """
-    out = dict(a)
-    by_lower = {k.lower(): k for k in out}
-    for title, content in b.items():
-        key = by_lower.get(title.lower())
-        if key is not None:
-            out[key] = f"{out[key]}\n\n{content}".strip()
-        else:
-            out[title] = content
-            by_lower[title.lower()] = title
-    return out
-
-
-class ImportRulesUseCase:
-    """Transforme un PDF de règles en proposition de sections markdown."""
-
-    def __init__(
-        self,
-        llm: LLMProvider,
-        extractor: PdfTextExtractor,
-        chunk_target_tokens: int = CHUNK_TARGET_TOKENS,
-    ) -> None:
-        self._llm = llm
-        self._extractor = extractor
-        self._chunk_target_tokens = chunk_target_tokens
-
-    async def execute(self, pdf_bytes: bytes) -> RulesImportResult:
-        """Variante non-streamée : traite tout puis renvoie le résultat complet."""
-        doc = self._extractor.extract(pdf_bytes)
-        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
-        logger.info(
-            "Import règles : %s page(s) (%s via OCR), %s morceau(x) à traiter.",
-            doc.page_count, doc.ocr_page_count, len(chunks),
-        )
-        merger = _SectionMerger()
-        for i, chunk in enumerate(chunks):
-            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
-        return RulesImportResult(
-            sections=merger.result(),
-            page_count=doc.page_count,
-            ocr_page_count=doc.ocr_page_count,
-        )
-
-    async def stream(self, pdf_bytes: bytes):
-        """Variante streamée : yield des évènements d'avancement au fil de l'eau.
-
-        Évènements (dicts) : {"type": "extracting"}, puis
-        {"type": "start", page_count, ocr_page_count, total}, puis un
-        {"type": "progress", current, total, new_sections:[...]} par morceau,
-        et enfin {"type": "done", sections, page_count, ocr_page_count}.
-        """
-        # Émis AVANT l'extraction (potentiellement lente si OCR) pour que l'UI
-        # affiche tout de suite "Extraction…" plutôt qu'un écran figé.
-        yield {"type": "extracting"}
-
-        doc = self._extractor.extract(pdf_bytes)
-        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
-        total = len(chunks)
-        logger.info(
-            "Import règles (stream) : %s page(s) (%s via OCR), %s morceau(x).",
-            doc.page_count, doc.ocr_page_count, total,
-        )
-        yield {
-            "type": "start",
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-            "total": total,
-        }
-
-        merger = _SectionMerger()
-        skipped = 0
-        last_error: str | None = None
-        for i, chunk in enumerate(chunks):
-            # RÉSILIENCE : un morceau qui échoue est SAUTÉ, l'import continue.
-            # Abandon seulement si AUCUN morceau ne passe (cf. après la boucle).
-            # HEARTBEAT : on émet des keep-alive pendant l'appel LLM (long sur un
-            # provider lent) pour que le flux SSE ne soit jamais coupé par le Core.
-            new_titles: list[str] = []
-            try:
-                sections: dict[str, str] | None = None
-                async for kind, payload in with_heartbeat(
-                    self._map_chunk(chunk, index=i, total=total)
-                ):
-                    if kind == "heartbeat":
-                        yield {"type": "heartbeat", "current": i + 1, "total": total}
-                    else:
-                        sections = payload
-                new_titles = merger.add(sections or {})
-            except LLMProviderError as exc:
-                skipped += 1
-                last_error = str(exc)
-                logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
-                yield {"type": "chunk_failed", "current": i + 1, "total": total,
-                       "message": str(exc)[:300]}
-            yield {
-                "type": "progress",
-                "current": i + 1,
-                "total": total,
-                "new_sections": new_titles,
-                "skipped": skipped,
-            }
-
-        if total > 0 and skipped == total:
-            yield {"type": "error",
-                   "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
-                              f"Dernier message : {last_error or 'inconnu'}"}
-            return
-
-        yield {
-            "type": "done",
-            "sections": merger.result(),
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-            "skipped": skipped,
-        }
-
-    # --- MAP : un morceau → sections -----------------------------------------
-
-    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> dict[str, str]:
-        return await self._extract_sections(chunk, index=index, total=total, depth=0)
-
-    async def _extract_sections(
-        self, text: str, *, index: int, total: int, depth: int
-    ) -> dict[str, str]:
-        """Extrait les sections d'un texte. Si la SORTIE est tronquée, retraite le
-        texte en DEUX moitiés (chacune produit une réponse complète) et fusionne —
-        ainsi aucune section n'est perdue, quel que soit le plafond de sortie."""
-        prompt = (
-            _MAP_SYSTEM.format(
-                canonical="\n".join(f"  - {s}" for s in _CANONICAL_SECTIONS)
-            )
-            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
-            "Renvoie maintenant le JSON des sections."
-        )
-        raw = await generate_with_retry(
-            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-        sections, truncated = self._parse_sections(raw, index=index)
-
-        if truncated and depth < _MAX_SPLIT_DEPTH:
-            left, right = split_in_half(text)
-            if left and right:
-                logger.info(
-                    "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
-                    index, depth + 1)
-                a = await self._extract_sections(left, index=index, total=total, depth=depth + 1)
-                b = await self._extract_sections(right, index=index, total=total, depth=depth + 1)
-                return _combine_sections(a, b)
-        if truncated:
-            logger.warning(
-                "Morceau %s : sortie tronquée, profondeur max atteinte — partiel conservé.", index)
-        return sections
-
-    @staticmethod
-    def _parse_sections(raw: str, *, index: int) -> tuple[dict[str, str], bool]:
-        """Parse robuste → (sections, tronqué). `tronqué`=True si récupération partielle."""
-        parsed, recovered = load_json_object(raw)
-        if parsed is None:
-            # Rien d'exploitable : soit prose (échec), soit JSON coupé avant toute
-            # structure complète (→ on signalera 'tronqué' pour re-découper).
-            truncated = looks_like_truncated_json(raw)
-            if not truncated:
-                logger.warning(
-                    "Morceau %s : aucun objet JSON exploitable, ignoré. "
-                    "Début de la réponse du modèle : %r",
-                    index, (raw or "").strip()[:300] or "(réponse VIDE)")
-            return {}, truncated
-        if not isinstance(parsed, dict):
-            logger.warning("Morceau %s : le LLM n'a pas renvoyé un objet, ignoré.", index)
-            return {}, False
-        return {str(k): str(v) for k, v in parsed.items()}, recovered

brain/app/application/llm_json.py

@@ -1,149 +0,0 @@
-"""Extraction robuste d'un objet JSON depuis une réponse LLM.
-
-Les LLM enrobent souvent leur JSON : fences markdown ```json … ```, texte
-d'introduction, commentaire de fin, voire un 2e objet. Un simple
-`json.loads(raw)` ou un `raw[first_brace:last_brace]` échoue dans ces cas
-("Extra data", accolade parasite dans une string, etc.).
-
-Cette fonction scanne depuis la PREMIÈRE `{` et renvoie exactement le premier
-objet `{…}` ÉQUILIBRÉ, en ignorant les accolades à l'intérieur des chaînes JSON
-et tout ce qui suit. Renvoie None si aucun objet complet n'est trouvé
-(sortie tronquée / accolades non refermées).
-"""
-from __future__ import annotations
-
-import json
-import re
-
-# Blocs de "réflexion" des modèles raisonneurs (Nemotron, DeepSeek-R1, QwQ…).
-# Leur contenu est de la prose truffée d'accolades qui piège le détecteur de JSON
-# (et n'est jamais la réponse) → on le retire avant toute analyse.
-_REASONING_RE = re.compile(r"<think(?:ing)?>.*?</think(?:ing)?>", re.DOTALL | re.IGNORECASE)
-
-
-def _strip_reasoning(raw: str) -> str:
-    return _REASONING_RE.sub("", raw)
-
-
-def load_json_object(raw: str) -> tuple[object | None, bool]:
-    """Parse un objet JSON depuis une réponse LLM, avec récupération si tronqué.
-
-    Renvoie (objet_parsé, récupéré_partiellement) :
-      - d'abord on tente le 1er objet complet (extract_json_object) ;
-      - sinon on tente une réparation du JSON tronqué (repair_truncated_json),
-        auquel cas le second élément vaut True.
-    (None, False) si rien d'exploitable.
-    """
-    raw = _strip_reasoning(raw)
-    obj = extract_json_object(raw)
-    if obj is not None:
-        try:
-            return json.loads(obj), False
-        except json.JSONDecodeError:
-            pass
-    repaired = repair_truncated_json(raw)
-    if repaired is not None:
-        try:
-            return json.loads(repaired), True
-        except json.JSONDecodeError:
-            pass
-    return None, False
-
-
-def looks_like_truncated_json(raw: str) -> bool:
-    """La sortie ressemble-t-elle à un JSON COUPÉ (accolades/crochets non refermés)
-    plutôt qu'à de la prose ? Sert à déclencher un re-découpage même quand RIEN n'a
-    pu être récupéré (cas où le 1er contenu est si long qu'il est coupé avant toute
-    sous-structure complète). On exige un contenu substantiel pour éviter les
-    faux positifs sur une courte réponse non-JSON."""
-    s = (raw or "").strip()
-    if "{" not in s or len(s) < 100:
-        return False
-    return s.count("{") > s.count("}") or s.count("[") > s.count("]")
-
-
-def extract_json_object(raw: str) -> str | None:
-    if not raw:
-        return None
-    text = raw.strip()
-    start = text.find("{")
-    if start == -1:
-        return None
-
-    depth = 0
-    in_string = False
-    escape = False
-    for i in range(start, len(text)):
-        c = text[i]
-        if in_string:
-            if escape:
-                escape = False
-            elif c == "\\":
-                escape = True
-            elif c == '"':
-                in_string = False
-        else:
-            if c == '"':
-                in_string = True
-            elif c == "{":
-                depth += 1
-            elif c == "}":
-                depth -= 1
-                if depth == 0:
-                    return text[start : i + 1]
-    return None  # accolades non refermées (réponse probablement tronquée)
-
-
-# Fermeture correspondante de chaque ouvrant, pour reconstituer un JSON tronqué.
-_CLOSE_OF = {"{": "}", "[": "]"}
-
-
-def repair_truncated_json(raw: str) -> str | None:
-    """Répare un JSON COUPÉ (sortie LLM tronquée) en gardant les éléments complets.
-
-    On scanne depuis la première `{` et on retient le DERNIER point où un conteneur
-    (`}` ou `]`) vient de se fermer — donc juste après une sous-structure complète
-    (un arc / chapitre / scène / pièce / section entièrement écrit). On coupe là et
-    on referme les conteneurs encore ouverts. L'élément en cours d'écriture au moment
-    de la troncature est abandonné, mais tous les précédents sont sauvés.
-
-    Renvoie une chaîne JSON équilibrée (à valider par json.loads) ou None.
-    """
-    if not raw:
-        return None
-    text = raw.strip()
-    start = text.find("{")
-    if start == -1:
-        return None
-
-    stack: list[str] = []
-    in_string = False
-    escape = False
-    best_cut = -1            # index (exclusif) où couper
-    best_closing = ""        # fermetures à ajouter pour rééquilibrer
-
-    for i in range(start, len(text)):
-        c = text[i]
-        if in_string:
-            if escape:
-                escape = False
-            elif c == "\\":
-                escape = True
-            elif c == '"':
-                in_string = False
-        else:
-            if c == '"':
-                in_string = True
-            elif c in "{[":
-                stack.append(c)
-            elif c in "}]":
-                if stack:
-                    stack.pop()
-                # Point de coupe sûr : on vient de fermer une sous-structure complète.
-                best_cut = i + 1
-                best_closing = "".join(_CLOSE_OF[b] for b in reversed(stack))
-
-    if best_cut == -1:
-        return None  # rien de complet à sauver
-    head = text[start:best_cut].rstrip().rstrip(",")
-    return head + best_closing

brain/app/application/llm_retry.py

@@ -1,102 +0,0 @@
-"""Retry avec backoff pour les appels LLM one-shot (imports).
-
-Les imports enchaînent de nombreux appels en série ; un échec TRANSITOIRE sur un
-seul morceau (503/502 surcharge serveur, 504/524 passerelle, timeout réseau) ne
-doit pas faire échouer tout l'import. On réessaie quelques fois avec une attente
-croissante. Après épuisement, on relaie l'erreur (problème durable : quota, panne).
-
-Réservé aux appels `generate` (one-shot, bufferisé) : réessayer est propre, sans
-risque de doublons. À NE PAS utiliser sur le streaming (re-jouerait des tokens).
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-import re
-
-from app.domain.ports import LLMProvider, LLMProviderError
-
-logger = logging.getLogger(__name__)
-
-# 3 tentatives : assez pour absorber un hoquet transitoire, sans s'acharner des
-# minutes sur un modèle durablement lent/saturé (les heartbeats gardent le flux
-# vivant, mais inutile de faire patienter l'utilisateur 15 min pour rien).
-_ATTEMPTS = 3
-_BASE_DELAY_SECONDS = 3.0
-# Un rate limit (429) "par minute" ne se libère pas en 2-3s : on attend plus
-# longtemps pour ces erreurs-là (le free tier OpenRouter plafonne ~20 req/min).
-_RATE_LIMIT_DELAYS = [10.0, 25.0, 45.0]
-
-
-def _is_rate_limit(exc: LLMProviderError) -> bool:
-    msg = str(exc).lower()
-    return "429" in msg or "rate" in msg or "too many requests" in msg
-
-
-def _is_daily_quota(exc: LLMProviderError) -> bool:
-    """Limite PAR JOUR (vs par minute) : réessayer est inutile, elle ne se libère
-    qu'au reset quotidien. OpenRouter le précise dans le corps du 429."""
-    msg = str(exc).lower()
-    return "per-day" in msg or "per day" in msg or "free-models-per-day" in msg
-
-
-# OpenRouter renvoie souvent le délai conseillé (saturation amont) :
-# "retry_after_seconds": 8  ou  "Retry-After": "8". On le respecte plutôt que
-# d'attendre une durée fixe arbitraire.
-_RETRY_AFTER_RE = re.compile(r'retry[_-]?after(?:_seconds)?"?\s*:\s*"?([0-9]+(?:\.[0-9]+)?)', re.IGNORECASE)
-
-
-def _suggested_retry_after(exc: LLMProviderError) -> float | None:
-    match = _RETRY_AFTER_RE.search(str(exc))
-    if not match:
-        return None
-    try:
-        return float(match.group(1))
-    except ValueError:
-        return None
-
-
-async def generate_with_retry(
-    llm: LLMProvider,
-    prompt: str,
-    *,
-    output_format: str | None = None,
-    temperature: float | None = None,
-) -> str:
-    """Comme `llm.generate`, mais réessaie les erreurs transitoires (backoff).
-
-    Backoff plus long pour les 429 (rate limit) afin de laisser la fenêtre se
-    libérer. Nombre de tentatives borné : si le quota est durablement épuisé
-    (ex. limite/jour), l'erreur finit par remonter au lieu de boucler sans fin.
-    """
-    delay = _BASE_DELAY_SECONDS
-    last_error: LLMProviderError | None = None
-    for attempt in range(_ATTEMPTS):
-        try:
-            return await llm.generate(prompt, output_format=output_format, temperature=temperature)
-        except LLMProviderError as exc:
-            last_error = exc
-            # Quota JOURNALIER épuisé : inutile d'insister, on remonte tout de suite
-            # (sinon on enchaîne des attentes longues pour rien, et on spamme l'API).
-            if _is_daily_quota(exc):
-                logger.warning("Quota journalier du fournisseur épuisé — abandon : %s", exc)
-                raise
-            if attempt < _ATTEMPTS - 1:
-                if _is_rate_limit(exc):
-                    suggested = _suggested_retry_after(exc)
-                    if suggested is not None:
-                        # Indication serveur (saturation amont) + petite marge, plafonnée.
-                        wait = min(suggested + 2.0, 60.0)
-                    else:
-                        wait = _RATE_LIMIT_DELAYS[min(attempt, len(_RATE_LIMIT_DELAYS) - 1)]
-                else:
-                    wait = delay
-                    delay *= 2
-                logger.warning(
-                    "Appel LLM échoué (tentative %s/%s)%s : %s — nouvelle tentative dans %ss.",
-                    attempt + 1, _ATTEMPTS, " [rate limit]" if _is_rate_limit(exc) else "",
-                    exc, wait,
-                )
-                await asyncio.sleep(wait)
-    assert last_error is not None
-    raise last_error

brain/app/application/notebook_chat.py

@@ -1,90 +0,0 @@
-"""Use case : chat ANCRÉ sur les sources d'un notebook (RAG).
-
-À chaque message, on retrouve les passages pertinents des sources (via le RAG) et
-on les injecte dans le prompt système, en plus du contexte de campagne. Le modèle
-répond donc en s'appuyant sur la/les source(s) — pas sur ses connaissances générales.
-"""
-from __future__ import annotations
-
-from typing import AsyncIterator
-
-from app.application.notebook_rag import NotebookRagUseCase
-from app.domain.models import ChatMessage
-from app.domain.ports import LLMChatProvider
-
-_SYSTEM_PROMPT = """Tu es un assistant de jeu de rôle qui aide à ADAPTER une source (PDF) à la CAMPAGNE de l'utilisateur.
-
-Tu disposes de DEUX connaissances, toutes deux ci-dessous :
-1) LA CAMPAGNE de l'utilisateur (sa structure arcs/chapitres/scènes, ses PNJ, son univers) ;
-2) LA SOURCE (extraits pertinents du PDF).
-
-Règles :
-- Pour une question sur SA CAMPAGNE (ex. « mon chapitre 3 », « mes PNJ »), appuie-toi sur la section CAMPAGNE.
-- Pour une question sur le livre, appuie-toi sur les EXTRAITS DE LA SOURCE.
-- CROISE les deux pour proposer des adaptations cohérentes avec sa campagne existante.
-- N'invente pas ce qui ne figure ni dans la campagne ni dans la source ; si tu ne sais pas, dis-le.
-- Quand un extrait porte un numéro de page (« (p. 12) »), cite-le (« d'après la p. 12 »).
-
-{context_block}
---- EXTRAITS PERTINENTS DE LA SOURCE ---
-{sources_block}
---- FIN DES EXTRAITS ---
-
-PROPOSITIONS D'INTÉGRATION (IMPORTANT) :
-Quand l'utilisateur veut CRÉER ou ADAPTER un élément concret pour sa campagne (un PNJ,
-une scène, un chapitre, un arc, une table aléatoire), termine ta réponse par un ou
-plusieurs BLOCS D'ACTION — un objet JSON par bloc, dans une clôture ```loremind-action.
-L'interface les transformera en boutons « Créer dans la campagne ». N'en mets que si
-c'est pertinent et explicitement souhaité. Formats acceptés :
-
-```loremind-action
-{{"type": "npc", "name": "Nom", "description": "Fiche en quelques phrases."}}
-```
-```loremind-action
-{{"type": "scene", "name": "Nom", "description": "Résumé", "content": "Déroulé détaillé."}}
-```
-```loremind-action
-{{"type": "chapter", "name": "Nom", "description": "Résumé du chapitre."}}
-```
-```loremind-action
-{{"type": "arc", "name": "Nom", "description": "Résumé", "arcType": "LINEAR"}}
-```
-```loremind-action
-{{"type": "table", "name": "Nom", "diceFormula": "1d8", "entries": [{{"minRoll":1,"maxRoll":4,"label":"...","detail":"..."}}]}}
-```
-
-Réponds en français, de façon utile et concise. Mets le texte explicatif AVANT les blocs d'action."""
-
-
-class NotebookChatUseCase:
-    def __init__(self, rag: NotebookRagUseCase, llm: LLMChatProvider) -> None:
-        self._rag = rag
-        self._llm = llm
-
-    async def stream(
-        self,
-        source_ids: list[str],
-        messages: list[ChatMessage],
-        context: str = "",
-        top_k: int = 6,
-    ) -> AsyncIterator[str]:
-        last_user = next((m.content for m in reversed(messages) if m.role == "user"), "")
-        passages = await self._rag.retrieve(source_ids, last_user, top_k=top_k)
-        sources_block = (
-            "\n\n".join(self._format_passage(p) for p in passages)
-            if passages else "(aucun passage pertinent trouvé dans les sources)"
-        )
-        context_block = (
-            f"--- TA CAMPAGNE ---\n{context.strip()}\n--- FIN CAMPAGNE ---\n\n"
-            if context.strip() else "--- TA CAMPAGNE ---\n(aucune donnée de campagne)\n--- FIN CAMPAGNE ---\n\n"
-        )
-        system_prompt = _SYSTEM_PROMPT.format(
-            context_block=context_block, sources_block=sources_block)
-        async for token in self._llm.stream_chat(messages, system_prompt=system_prompt):
-            yield token
-
-    @staticmethod
-    def _format_passage(p: dict) -> str:
-        page = p.get("page")
-        prefix = f"(p. {page}) " if page else ""
-        return f"• {prefix}{p['text'].strip()}"

brain/app/application/notebook_deep.py

@@ -1,135 +0,0 @@
-"""Use case « Analyse approfondie » d'un notebook : map-reduce sur TOUT le document.
-
-Contrairement au chat RAG (qui ne ramène que les top-k extraits), ce mode lit
-l'INTÉGRALITÉ des sources par lots :
-  - MAP    : pour chaque lot, le modèle extrait ce qui est pertinent pour la question
-             (ou « RAS » si rien) ;
-  - REDUCE : il synthétise toutes les notes en une réponse finale (streamée).
-
-→ Répond aux questions globales/exhaustives (« liste tous les… ») quel que soit le
-modèle, au prix de plusieurs appels (comme l'import). Le lot est dimensionné par
-`batch_tokens` (= taille de morceau d'import) : avec un modèle gros-contexte, peu de
-lots ; avec un petit modèle local, plus de lots (mais ça reste exhaustif).
-"""
-from __future__ import annotations
-
-import logging
-from typing import AsyncIterator
-
-import tiktoken
-
-from app.application.llm_retry import generate_with_retry
-from app.domain.models import ChatMessage
-from app.domain.ports import LLMChatProvider, LLMProvider, LLMProviderError
-from app.infrastructure import vector_store
-
-logger = logging.getLogger(__name__)
-
-_NO_MATCH = "RAS"
-_MAP_TEMPERATURE = 0.2
-
-_MAP_PROMPT = """Voici un EXTRAIT d'un document. Extrais UNIQUEMENT les informations
-pertinentes pour répondre à la question ci-dessous. Conserve les détails utiles et
-indique les numéros de page (format « p. X »). Si l'extrait ne contient RIEN de
-pertinent, réponds EXACTEMENT « {no_match} » et rien d'autre.
-
-QUESTION : {question}
-
---- EXTRAIT ---
-{excerpt}
---- FIN EXTRAIT ---
-
-Informations pertinentes (ou « {no_match} ») :"""
-
-_REDUCE_SYSTEM = """Tu réponds à la question d'un MJ à partir de NOTES extraites de
-l'ENSEMBLE d'un document source (donc tu as une vue COMPLÈTE, pas un simple extrait).
-Synthétise ces notes en une réponse claire et structurée, cite les pages (« p. X »),
-et n'invente rien qui n'y figure pas. Si une CAMPAGNE est fournie ci-dessous, relie ta
-réponse à sa structure / ses PNJ pour des adaptations cohérentes.
-
-{context_block}
---- NOTES EXTRAITES DE TOUT LE DOCUMENT ---
-{notes_block}
---- FIN DES NOTES ---
-
-Réponds en français."""
-
-
-class NotebookDeepUseCase:
-    def __init__(self, llm: LLMProvider, batch_tokens: int = 10000) -> None:
-        self._llm = llm
-        self._batch_tokens = max(2000, batch_tokens)
-
-    async def stream(
-        self,
-        source_ids: list[str],
-        messages: list[ChatMessage],
-        context: str = "",
-        history_limit: int = 8,
-    ) -> AsyncIterator[dict]:
-        """Yield des évènements : {type:'progress',current,total}, {type:'token',token},
-        {type:'done'}. (Les erreurs LLM des lots sont tolérées : lot ignoré.)
-
-        La dernière question utilisateur sert à la LECTURE du document (map) ; la
-        SYNTHÈSE (reduce) reçoit les `history_limit` derniers messages → les relances
-        conversationnelles (« et pour les autres ? ») fonctionnent aussi en approfondi.
-        """
-        question = next((m.content for m in reversed(messages) if m.role == "user"), "")
-        chunks: list[dict] = []
-        for sid in source_ids:
-            chunks.extend(vector_store.all_chunks(sid))
-        if not chunks:
-            yield {"type": "token", "token": "Aucune source indexée à analyser."}
-            yield {"type": "done"}
-            return
-
-        batches = self._group(chunks)
-        total = len(batches)
-        notes: list[str] = []
-        for i, batch in enumerate(batches):
-            yield {"type": "progress", "current": i, "total": total}
-            excerpt = "\n\n".join(
-                f"(p. {c['page']}) {c['text'].strip()}" if c.get("page") else c["text"].strip()
-                for c in batch
-            )
-            prompt = _MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
-            try:
-                raw = await generate_with_retry(self._llm, prompt, temperature=_MAP_TEMPERATURE)
-            except LLMProviderError as exc:
-                logger.warning("Analyse approfondie : lot %s/%s ignoré : %s", i + 1, total, exc)
-                continue
-            answer = raw.strip()
-            if answer and answer.upper().rstrip(".") != _NO_MATCH:
-                notes.append(answer)
-        yield {"type": "progress", "current": total, "total": total}
-
-        notes_block = "\n\n".join(notes) if notes else "(aucune information pertinente trouvée dans le document)"
-        context_block = (
-            f"--- TA CAMPAGNE (structure, PNJ, univers) ---\n{context.strip()}\n--- FIN CAMPAGNE ---\n\n"
-            if context.strip() else ""
-        )
-        system_prompt = _REDUCE_SYSTEM.format(context_block=context_block, notes_block=notes_block)
-        # Historique récent pour la cohérence des relances ; on garantit que le
-        # dernier message est bien la question courante.
-        reduce_messages = messages[-history_limit:] if messages else [ChatMessage(role="user", content=question)]
-        llm_chat: LLMChatProvider = self._llm  # type: ignore[assignment]
-        async for token in llm_chat.stream_chat(reduce_messages, system_prompt=system_prompt):
-            yield {"type": "token", "token": token}
-        yield {"type": "done"}
-
-    def _group(self, chunks: list[dict]) -> list[list[dict]]:
-        """Regroupe les extraits en lots ~`batch_tokens` (compte tiktoken)."""
-        enc = tiktoken.get_encoding("cl100k_base")
-        batches: list[list[dict]] = []
-        current: list[dict] = []
-        current_tokens = 0
-        for c in chunks:
-            t = len(enc.encode(c.get("text", "")))
-            if current and current_tokens + t > self._batch_tokens:
-                batches.append(current)
-                current, current_tokens = [], 0
-            current.append(c)
-            current_tokens += t
-        if current:
-            batches.append(current)
-        return batches

brain/app/application/notebook_rag.py

@@ -1,79 +0,0 @@
-"""Use case RAG des notebooks : indexer une source PDF et retrouver les passages
-pertinents pour une question.
-
-Chaîne d'indexation : PDF → extraction texte (+OCR) → découpage en extraits courts
-→ embeddings → stockage vectoriel (fichier). À la requête : on embed la question
-et on récupère les extraits les plus proches (cosinus) pour ancrer le chat.
-
-Extraits PLUS COURTS que pour l'import (recopie) : ici on veut une granularité fine
-pour que la recherche pointe un passage précis, pas un demi-chapitre.
-"""
-from __future__ import annotations
-
-import logging
-
-from app.application.chunking import chunk_text
-from app.application.embeddings import EmbeddingProvider
-from app.domain.ports import PdfTextExtractor
-from app.infrastructure import vector_store
-
-logger = logging.getLogger(__name__)
-
-_RAG_CHUNK_TOKENS = 600
-# Un extrait avec quasi aucun texte réel (en-tête/pied de page, fragment de numéro
-# de page isolé « 249 250 ») ne sert à rien en RAG → on l'écarte. Seuil bas et
-# conservateur : on ne coupe QUE les fragments quasi-vides, jamais une vraie phrase.
-_MIN_LETTERS = 15
-
-
-def _has_enough_text(piece: str) -> bool:
-    return sum(c.isalpha() for c in piece) >= _MIN_LETTERS
-
-
-class NotebookRagUseCase:
-    def __init__(
-        self,
-        extractor: PdfTextExtractor,
-        embedder: EmbeddingProvider,
-        chunk_target_tokens: int = _RAG_CHUNK_TOKENS,
-    ) -> None:
-        self._extractor = extractor
-        self._embedder = embedder
-        self._chunk_target_tokens = chunk_target_tokens
-
-    async def index_source(self, source_id: str, pdf_bytes: bytes) -> dict:
-        """Extrait, découpe PAR PAGE (pour garder le n° de page → citations), embed
-        et stocke une source. Renvoie un récap."""
-        doc = self._extractor.extract(pdf_bytes)
-        chunks: list[str] = []
-        pages: list[int] = []
-        for page in doc.pages:
-            for piece in chunk_text(page.text, self._chunk_target_tokens):
-                if not _has_enough_text(piece):
-                    continue  # fragment quasi-vide (en-tête/pied/numéro) → ignoré
-                chunks.append(piece)
-                pages.append(page.index + 1)  # n° de page 1-based pour l'affichage
-        logger.info(
-            "Indexation notebook source=%s : %s page(s) (%s OCR), %s extrait(s).",
-            source_id, doc.page_count, doc.ocr_page_count, len(chunks),
-        )
-        if not chunks:
-            vector_store.save(source_id, [], [])
-            return {"chunks": 0, "page_count": doc.page_count, "ocr_page_count": doc.ocr_page_count}
-        vectors = await self._embedder.embed(chunks)
-        count = vector_store.save(source_id, chunks, vectors, pages)
-        return {
-            "chunks": count,
-            "page_count": doc.page_count,
-            "ocr_page_count": doc.ocr_page_count,
-        }
-
-    async def retrieve(self, source_ids: list[str], query: str, top_k: int = 6) -> list[dict]:
-        """Passages les plus pertinents (toutes sources) pour `query`."""
-        ids = [s for s in source_ids if vector_store.exists(s)]
-        if not ids or not query.strip():
-            return []
-        query_vectors = await self._embedder.embed([query])
-        if not query_vectors:
-            return []
-        return vector_store.search(ids, query_vectors[0], top_k)

brain/app/application/streaming.py

@@ -1,45 +0,0 @@
-"""Heartbeats pour garder un flux SSE 'vivant' pendant une coroutine longue.
-
-Problème résolu : pendant un appel LLM lent (import sur provider gratuit), le
-Brain ne produit AUCUN évènement SSE. Le Core (WebClient) ne 'voit aucun item'
-et coupe la connexion sur timeout d'inactivité :
-
-    ReactiveException: Did not observe any item or terminal signal within Nms
-
-C'est le piège classique du SSE long. La parade standard = envoyer un keep-alive
-périodique. `with_heartbeat` exécute une coroutine en émettant un évènement
-'heartbeat' toutes les `interval` secondes tant qu'elle tourne, puis son résultat
-('result', valeur). Le Core remet son chrono à zéro sur n'importe quel évènement
-reçu (même inconnu) → plus de coupure, quelle que soit la lenteur du modèle.
-"""
-from __future__ import annotations
-
-import asyncio
-from typing import Any, AsyncIterator, Awaitable
-
-# Bien sous le timeout d'inactivité du Core (600s) ET de tout proxy (nginx ~60s).
-HEARTBEAT_INTERVAL_SECONDS = 15.0
-
-
-async def with_heartbeat(
-    coro: Awaitable[Any],
-    *,
-    interval: float = HEARTBEAT_INTERVAL_SECONDS,
-) -> AsyncIterator[tuple[str, Any]]:
-    """Exécute `coro` en émettant ('heartbeat', None) toutes les `interval`s tant
-    qu'elle n'est pas terminée, puis ('result', valeur).
-
-    L'exception éventuelle de `coro` est propagée (re-levée par `task.result()`),
-    donc l'appelant peut l'attraper normalement. Si l'itération est abandonnée
-    (client déconnecté), la tâche sous-jacente est annulée.
-    """
-    task: asyncio.Task = asyncio.ensure_future(coro)
-    try:
-        while not task.done():
-            done, _ = await asyncio.wait({task}, timeout=interval)
-            if not done:
-                yield ("heartbeat", None)
-        yield ("result", task.result())
-    finally:
-        if not task.done():
-            task.cancel()

brain/app/core/config.py

@@ -25,16 +25,12 @@ class Settings(BaseSettings):
         extra="ignore",
     )
 
-    # Provider LLM actif. "ollama" = local ; "onemin" = 1min.ai ;
+    # Provider LLM actif. "ollama" = local ; "onemin" = 1min.ai (etage 2).
-    # "openrouter" = OpenRouter ; "mistral" = Mistral ; "gemini" = Google Gemini.
+    llm_provider: Literal["ollama", "onemin"] = "ollama"
-    llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"] = "ollama"
 
     ollama_base_url: str = "http://localhost:11434"
     llm_model: str = "gemma4:26b"
-    # Timeout HTTP des appels au LLM. Les imports/adaptations PDF génèrent de gros
+    llm_timeout_seconds: int = 120
-    # blocs (surtout avec l'extraction riche) → 120s était trop court. Surchargeable
-    # depuis l'UI (Paramètres) si un import lourd dépasse encore.
-    llm_timeout_seconds: int = 300
 
     # Fenêtre de contexte (num_ctx Ollama). Défaut Ollama = 2048, trop étroit
     # dès que le Structural Context du Lore dépasse ~10 pages (b9). On monte
@@ -48,48 +44,6 @@ class Settings(BaseSettings):
     onemin_api_key: str = ""
     onemin_model: str = "gpt-4o-mini"
 
-    # OpenRouter (OpenAI-compatible). Cle + modele modifiables depuis l'UI.
-    # Defaut = routeur `openrouter/free` : choisit un modele GRATUIT (0 credit).
-    # Pour un modele precis gratuit : id finissant par `:free`.
-    openrouter_api_key: str = ""
-    openrouter_model: str = "openrouter/free"
-
-    # Mistral (La Plateforme, OpenAI-compatible). Cle + modele modifiables depuis
-    # l'UI. Tier gratuit « Experiment » sur console.mistral.ai (sans CB). Defaut =
-    # mistral-large-latest (128k contexte, bon en francais et en JSON fidele).
-    mistral_api_key: str = ""
-    mistral_model: str = "mistral-large-latest"
-
-    # Google Gemini (endpoint OpenAI-compatible). Cle gratuite sur
-    # aistudio.google.com (sans CB). Defaut = gemini-2.0-flash : ~1M de contexte
-    # (un livre tient en 1-2 appels), rapide, fidele, quota gratuit genereux.
-    gemini_api_key: str = ""
-    gemini_model: str = "gemini-2.0-flash"
-
-    # Embeddings (RAG des notebooks/ateliers). Modele SEPARE du chat.
-    # "ollama" = local (gratuit, illimite, ideal pour indexer un livre = bcp
-    # d'appels) ; "mistral" = cloud EU (mistral-embed, soumis au rate limit).
-    embedding_provider: Literal["ollama", "mistral"] = "ollama"
-    ollama_embedding_model: str = "nomic-embed-text"
-    mistral_embedding_model: str = "mistral-embed"
-    # Au démarrage, si le provider d'embeddings est Ollama et que le modèle n'est
-    # pas présent, le Brain le télécharge automatiquement (en arrière-plan) → le RAG
-    # marche "out of the box" pour un nouvel utilisateur. Désactivable (connexion
-    # limitée, gestion manuelle des modèles).
-    auto_pull_embedding_model: bool = True
-
-    # Nombre d'extraits récupérés par question dans le chat des ateliers (RAG).
-    # Plus haut = plus de couverture pour les questions larges (« liste les… »),
-    # mais prompt plus long. 8 par défaut (montable jusqu'à ~20 sur grand contexte).
-    rag_top_k: int = 8
-
-    # Taille cible d'un morceau (en tokens) pour l'import de PDF (regles/campagne).
-    # Plus c'est gros, moins il y a de morceaux => moins de fragmentation et un
-    # import plus rapide, MAIS il faut que ca tienne dans la fenetre du modele.
-    # Defaut prudent (compatible Ollama num_ctx 16384). Sur un modele a grand
-    # contexte (ex: GPT-5 mini, 400k), monter a ~100000 traite un livre en 1 passe.
-    import_chunk_tokens: int = 10000
-
     # Secret partage entre le Core Spring et le Brain. Le Brain n'accepte une
     # requete que si l'entete X-Internal-Secret correspond. Volontairement
     # non-surchargeable via settings_store (securite critique, .env-only).

brain/app/core/settings_store.py

@@ -29,18 +29,6 @@ _ALLOWED_KEYS = frozenset({
     "llm_num_ctx",
     "onemin_api_key",
     "onemin_model",
-    "openrouter_api_key",
-    "openrouter_model",
-    "mistral_api_key",
-    "mistral_model",
-    "gemini_api_key",
-    "gemini_model",
-    "embedding_provider",
-    "ollama_embedding_model",
-    "mistral_embedding_model",
-    "auto_pull_embedding_model",
-    "rag_top_k",
-    "import_chunk_tokens",
 })
 
 

brain/app/domain/models.py

@@ -122,29 +122,9 @@ class SceneBranchHint:
     condition: str | None = None
 
 
-@dataclass(frozen=True)
-class RoomBranchHint:
-    """Indice d'une sortie entre pièces (donjon). target_room_name déjà résolu côté Core."""
-
-    label: str
-    target_room_name: str
-    condition: str | None = None
-
-
-@dataclass(frozen=True)
-class RoomSummary:
-    """Pièce d'un lieu explorable. Projection plate pour le prompt IA (pas de notes MJ)."""
-
-    name: str
-    floor: int | None = None
-    description: str | None = None
-    enemies: str | None = None
-    branches: list[RoomBranchHint] = field(default_factory=list)
-
-
 @dataclass(frozen=True)
 class SceneSummary:
-    """Résumé d'une scène : nom + description courte + illustrations + branches + pièces."""
+    """Résumé d'une scène : nom + description courte + illustrations + branches."""
 
     name: str
     description: str | None
@@ -153,8 +133,6 @@ class SceneSummary:
     illustration_count: int = 0
     # Connexions narratives sortantes (livre dont vous etes le heros).
     branches: list[SceneBranchHint] = field(default_factory=list)
-    # Pièces du lieu explorable (vide = scène classique).
-    rooms: list[RoomSummary] = field(default_factory=list)
 
 
 @dataclass(frozen=True)
@@ -251,178 +229,3 @@ class GameSystemContext:
     system_name: str
     system_description: str | None
     sections: dict[str, str]
-
-
-@dataclass(frozen=True)
-class JournalEntrySummary:
-    """Une entrée du journal d'une Session.
-
-    `source_session_name` n'est renseigné que pour les entrées issues de
-    sessions précédentes (option 3 : continuité narrative entre séances).
-    """
-
-    type: str
-    content: str
-    occurred_at: str | None
-    source_session_name: str | None = None
-
-
-@dataclass(frozen=True)
-class QuestSummary:
-    """Résumé d'une quête (Chapter dans un Arc HUB) pour le system prompt.
-
-    Volontairement sans notes MJ ni statut texte : c'est déjà classé côté Core
-    dans available_quests / in_progress_quests / locked_quest_titles.
-    """
-
-    name: str
-    arc_name: str
-    description: str | None = None
-
-
-@dataclass(frozen=True)
-class SessionContext:
-    """Contexte d'une Session de jeu en cours (Play Context).
-
-    Combine plusieurs niveaux :
-    - `entries` : journal COMPLET de la session courante (cappé ~80 entrées)
-    - `previous_events` : EVENTs marquants des sessions précédentes (continuité)
-    - `available_quests` / `in_progress_quests` : quêtes du Hub ouvertes
-    - `locked_quest_titles` : titres seuls des quêtes verrouillées (anti-spoiler)
-    - `active_flags` : noms des flags de campagne actuellement à true
-    """
-
-    session_name: str
-    active: bool
-    started_at: str | None
-    entries: list[JournalEntrySummary]
-    previous_events: list[JournalEntrySummary]
-    available_quests: list[QuestSummary] = field(default_factory=list)
-    in_progress_quests: list[QuestSummary] = field(default_factory=list)
-    locked_quest_titles: list[str] = field(default_factory=list)
-    active_flags: list[str] = field(default_factory=list)
-
-
-# ─────────────────────── Import de PDF (règles → GameSystem) ───────────────────────
-
-
-@dataclass(frozen=True)
-class ExtractedPage:
-    """Texte extrait d'UNE page de PDF, avec la trace de la méthode utilisée.
-
-    `used_ocr=True` signale que la page n'avait pas de couche texte exploitable
-    (born-digital absent) et a donc été rasterisée puis passée à l'OCR. Permet
-    au CLI/diagnostic de dire à l'utilisateur si son PDF est "texte" ou "scan".
-    """
-
-    index: int  # 0-based
-    text: str
-    used_ocr: bool
-
-
-@dataclass(frozen=True)
-class ExtractedDocument:
-    """Résultat brut de l'extraction d'un PDF : une entrée par page."""
-
-    pages: list[ExtractedPage]
-
-    @property
-    def page_count(self) -> int:
-        return len(self.pages)
-
-    @property
-    def ocr_page_count(self) -> int:
-        return sum(1 for p in self.pages if p.used_ocr)
-
-    @property
-    def full_text(self) -> str:
-        """Concatène le texte de toutes les pages, séparées par un saut double."""
-        return "\n\n".join(p.text for p in self.pages if p.text.strip())
-
-
-@dataclass(frozen=True)
-class RulesImportResult:
-    """Proposition structurée de règles : sections markdown indexées par titre.
-
-    `sections` = {titre H2 → contenu markdown}. C'est une PROPOSITION : rien
-    n'est persisté côté Core tant que l'utilisateur n'a pas validé/édité.
-    `page_count` / `ocr_page_count` remontent au diagnostic d'extraction.
-    """
-
-    sections: dict[str, str]
-    page_count: int
-    ocr_page_count: int
-
-    def to_markdown(self) -> str:
-        """Assemble les sections en un markdown monolithique (## titre + contenu).
-
-        Format aligné sur `GameSystem.rulesMarkdown` côté Core (découpé par H2).
-        """
-        blocks = [f"## {title}\n\n{content.strip()}" for title, content in self.sections.items()]
-        return "\n\n".join(blocks).strip() + "\n"
-
-
-# ─────────────────────── Import de PDF de campagne (arbre arc→chapitre→scène) ──────────────
-
-
-@dataclass(frozen=True)
-class RoomProposal:
-    """Pièce d'un lieu explorable (donjon) proposée pour une scène."""
-
-    name: str
-    description: str
-    enemies: str = ""
-    loot: str = ""
-
-
-@dataclass(frozen=True)
-class SceneProposal:
-    """Scène proposée. `rooms` non vide => donjon/lieu explorable.
-
-    On capture aussi, quand le livre les fournit, le texte d'encadré « à lire aux
-    joueurs » (`player_narration`) et les secrets/développement MJ (`gm_notes`).
-    """
-
-    name: str
-    description: str
-    player_narration: str = ""
-    gm_notes: str = ""
-    rooms: list[RoomProposal] = field(default_factory=list)
-
-
-@dataclass(frozen=True)
-class ChapterProposal:
-    """Chapitre proposé : nom + synopsis + ses scènes."""
-
-    name: str
-    description: str
-    scenes: list[SceneProposal] = field(default_factory=list)
-
-
-@dataclass(frozen=True)
-class ArcProposal:
-    """Arc proposé : nom + synopsis + type (LINEAR/HUB) + ses chapitres."""
-
-    name: str
-    description: str
-    arc_type: str = "LINEAR"
-    chapters: list[ChapterProposal] = field(default_factory=list)
-
-
-@dataclass(frozen=True)
-class CampaignImportResult:
-    """Proposition d'arborescence narrative extraite d'un PDF de campagne.
-
-    PROPOSITION non persistée : l'UI laisse l'utilisateur réviser/éditer l'arbre
-    avant la création effective des arcs/chapitres/scènes côté Core.
-    """
-
-    arcs: list[ArcProposal]
-    page_count: int
-    ocr_page_count: int
-
-    def counts(self) -> tuple[int, int, int]:
-        """(nb arcs, nb chapitres, nb scènes) — pour le diagnostic / la progression."""
-        chapters = sum(len(a.chapters) for a in self.arcs)
-        scenes = sum(len(c.scenes) for a in self.arcs for c in a.chapters)
-        return len(self.arcs), chapters, scenes

brain/app/domain/ports.py

@@ -7,10 +7,7 @@ En Python moderne on privilégie Protocol (PEP 544) sur ABC pour bénéficier
 du duck typing structurel : toute classe qui possède les bonnes méthodes
 satisfait le contrat, sans héritage explicite.
 """
-from typing import TYPE_CHECKING, AsyncIterator, Protocol
+from typing import AsyncIterator, Protocol
-
-if TYPE_CHECKING:
-    from app.domain.models import ExtractedDocument
 
 
 class LLMProvider(Protocol):
@@ -81,32 +78,6 @@ class LLMChatProvider(Protocol):
         ...
 
 
-class PdfTextExtractor(Protocol):
-    """Port sortant — extrait le texte d'un PDF (born-digital ou scan).
-
-    L'implémentation décide de sa stratégie (couche texte directe, repli OCR
-    page par page…). Le domaine ne connaît ni PyMuPDF ni Tesseract.
-    """
-
-    def extract(self, pdf_bytes: bytes) -> "ExtractedDocument":
-        """Extrait le texte du PDF fourni sous forme d'octets.
-
-        Args:
-            pdf_bytes: contenu binaire du fichier PDF.
-
-        Returns:
-            ExtractedDocument : une entrée par page (texte + flag OCR).
-
-        Raises:
-            PdfExtractionError: si le PDF est illisible/corrompu.
-        """
-        ...
-
-
-class PdfExtractionError(Exception):
-    """Erreur du domaine : un PDF n'a pas pu être lu/extrait."""
-
-
 class LLMProviderError(Exception):
     """Erreur du domaine signalant qu'un LLMProvider n'a pas pu générer.
 

brain/app/infrastructure/gemini_adapter.py

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

brain/app/infrastructure/mistral_adapter.py

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

brain/app/infrastructure/mistral_embedding_adapter.py

@@ -1,58 +0,0 @@
-"""Adapter d'embeddings Mistral (cloud, EU) — POST /v1/embeddings.
-
-Soumis au rate limit du tier gratuit : pour indexer un gros document on envoie
-les textes par lots (et l'appelant peut espacer les appels si besoin).
-"""
-from __future__ import annotations
-
-import httpx
-
-from app.application.embeddings import EmbeddingError
-from app.core.config import Settings
-
-_API_URL = "https://api.mistral.ai/v1/embeddings"
-# Lot raisonnable pour ne pas envoyer un payload géant d'un coup.
-_BATCH_SIZE = 64
-
-
-class MistralEmbeddingProvider:
-    """Implémente EmbeddingProvider via l'API Mistral embeddings."""
-
-    def __init__(self, settings: Settings) -> None:
-        if not settings.mistral_api_key:
-            raise EmbeddingError(
-                "Clé API Mistral manquante (requise pour les embeddings Mistral). "
-                "Configure-la dans les Paramètres ou choisis Ollama pour les embeddings."
-            )
-        self._api_key = settings.mistral_api_key
-        self._model = settings.mistral_embedding_model
-        self._timeout = settings.llm_timeout_seconds
-
-    async def embed(self, texts: list[str]) -> list[list[float]]:
-        if not texts:
-            return []
-        out: list[list[float]] = []
-        headers = {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
-        }
-        async with httpx.AsyncClient(timeout=self._timeout) as client:
-            for start in range(0, len(texts), _BATCH_SIZE):
-                batch = texts[start:start + _BATCH_SIZE]
-                try:
-                    response = await client.post(
-                        _API_URL, headers=headers, json={"model": self._model, "input": batch})
-                    if response.status_code >= 400:
-                        raise EmbeddingError(
-                            f"Mistral embeddings HTTP {response.status_code} : "
-                            f"{response.text.strip()[:300]}")
-                    data = response.json()
-                except httpx.HTTPError as exc:
-                    raise EmbeddingError(f"Erreur Mistral embeddings : {exc}") from exc
-
-                items = data.get("data")
-                if not isinstance(items, list) or len(items) != len(batch):
-                    raise EmbeddingError("Réponse d'embeddings Mistral inattendue (taille incohérente).")
-                for item in items:
-                    out.append([float(x) for x in item.get("embedding", [])])
-        return out

brain/app/infrastructure/ollama_embedding_adapter.py

@@ -1,43 +0,0 @@
-"""Adapter d'embeddings Ollama (local) — endpoint /api/embed.
-
-Gratuit et illimité (tourne sur la machine). Nécessite d'avoir pullé le modèle
-d'embedding (ex. `ollama pull nomic-embed-text`).
-"""
-from __future__ import annotations
-
-import httpx
-
-from app.application.embeddings import EmbeddingError
-from app.core.config import Settings
-
-
-class OllamaEmbeddingProvider:
-    """Implémente EmbeddingProvider via Ollama /api/embed (batch)."""
-
-    def __init__(self, settings: Settings) -> None:
-        self._base_url = settings.ollama_base_url
-        self._model = settings.ollama_embedding_model
-        self._timeout = settings.llm_timeout_seconds
-
-    async def embed(self, texts: list[str]) -> list[list[float]]:
-        if not texts:
-            return []
-        url = f"{self._base_url}/api/embed"
-        payload = {"model": self._model, "input": texts}
-        async with httpx.AsyncClient(timeout=self._timeout) as client:
-            try:
-                response = await client.post(url, json=payload)
-                if response.status_code >= 400:
-                    body = response.text
-                    raise EmbeddingError(
-                        f"Ollama embeddings HTTP {response.status_code} : {body.strip()[:300]}. "
-                        f"Le modèle '{self._model}' est-il installé ? (ollama pull {self._model})"
-                    )
-                data = response.json()
-            except httpx.HTTPError as exc:
-                raise EmbeddingError(f"Erreur Ollama embeddings : {exc}") from exc
-
-        vectors = data.get("embeddings")
-        if not isinstance(vectors, list) or len(vectors) != len(texts):
-            raise EmbeddingError("Réponse d'embeddings Ollama inattendue (taille incohérente).")
-        return [[float(x) for x in v] for v in vectors]

brain/app/infrastructure/onemin_adapter.py

@@ -14,7 +14,6 @@ avec des marqueurs de role lisibles pour le modele.
 from __future__ import annotations
 
 import json
-import logging
 from typing import AsyncIterator
 
 import httpx
@@ -23,8 +22,6 @@ from app.core.config import Settings
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError
 
-logger = logging.getLogger(__name__)
-
 _API_BASE = "https://api.1min.ai/api/chat-with-ai"
 _PAYLOAD_TYPE = "UNIFY_CHAT_WITH_AI"
 
@@ -51,18 +48,6 @@ class OneMinAiLLMProvider:
             "promptObject": {"prompt": prompt},
         }
 
-    def _format_http_error(self, exc: httpx.HTTPError) -> str:
-        """Message d'erreur lisible. Un timeout httpx a un str() vide → on le nomme."""
-        if isinstance(exc, httpx.TimeoutException):
-            return (
-                f"Erreur 1min.ai : délai dépassé (timeout {self._timeout}s). Le modèle a mis "
-                "trop de temps à répondre — typique d'un morceau d'import trop gros. "
-                "Réduisez « Taille des morceaux à l'import » (Paramètres → Import de PDF) "
-                "ou augmentez le timeout LLM."
-            )
-        detail = str(exc) or exc.__class__.__name__
-        return f"Erreur 1min.ai ({exc.__class__.__name__}) : {detail}"
-
     async def generate(
         self,
         prompt: str,
@@ -70,18 +55,18 @@ class OneMinAiLLMProvider:
         output_format: str | None = None,  # 1min.ai ne supporte pas format=json
         temperature: float | None = None,  # idem, pas d'hyperparam expose ici
     ) -> str:
-        """One-shot, mais via l'endpoint STREAMING (puis recollage).
+        """Appel one-shot : retourne la reponse complete sous forme de string."""
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            try:
+                response = await client.post(
+                    _API_BASE, headers=self._headers(), json=self._payload(prompt)
+                )
+                response.raise_for_status()
+                data = response.json()
+            except httpx.HTTPError as exc:
+                raise LLMProviderError(f"Erreur 1min.ai : {exc}") from exc
 
-        On NE passe PAS par l'endpoint non-streame `chat-with-ai` : sur les longues
+        return self._extract_result(data)
-        generations (gros imports), la passerelle Cloudflare de 1min.ai coupe la
-        connexion au bout de ~100s et renvoie un HTTP 524. En streaming, des octets
-        circulent en continu => pas de 524, quelle que soit la duree. On accumule
-        tous les fragments pour reconstituer la reponse complete.
-        """
-        chunks: list[str] = []
-        async for token in self._stream_prompt(prompt):
-            chunks.append(token)
-        return "".join(chunks)
 
     async def stream_chat(
         self,
@@ -90,18 +75,17 @@ class OneMinAiLLMProvider:
         system_prompt: str | None = None,
         temperature: float | None = None,
     ) -> AsyncIterator[str]:
-        """Streame une conversation : aplatit les messages puis delegue au coeur SSE."""
+        """Streame via SSE.
-        prompt = self._flatten_messages(messages, system_prompt)
-        async for token in self._stream_prompt(prompt):
-            yield token
 
-    async def _stream_prompt(self, prompt: str) -> AsyncIterator[str]:
+        1min.ai expose deux evenements utiles :
-        """Coeur du streaming SSE 1min.ai (`?isStreaming=true`) pour un prompt brut.
+          - `event: content`  → `data: {"content": "..."}`
-
+          - `event: done`     → fin du stream
-        1min.ai expose : `event: content` → `data: {"content": "..."}`, `event: done`,
+          - `event: error`    → erreur serveur
-        `event: error`. On yield le champ `content` au fil de l'arrivee.
+        On yield le champ `content` au fil de l'arrivee.
         """
+        prompt = self._flatten_messages(messages, system_prompt)
         url = f"{_API_BASE}?isStreaming=true"
+
         async with httpx.AsyncClient(timeout=self._timeout) as client:
             try:
                 async with client.stream(
@@ -111,7 +95,9 @@ class OneMinAiLLMProvider:
                     async for token in self._parse_sse(response):
                         yield token
             except httpx.HTTPError as exc:
-                raise LLMProviderError(self._format_http_error(exc)) from exc
+                raise LLMProviderError(
+                    f"Erreur lors du streaming 1min.ai : {exc}"
+                ) from exc
 
     # --- Helpers ------------------------------------------------------------
 
@@ -160,21 +146,12 @@ class OneMinAiLLMProvider:
         """
         record = payload.get("aiRecord") or {}
         detail = record.get("aiRecordDetail") or {}
-        result = detail.get("resultObject")
+        result = detail.get("resultObject") or []
-        if isinstance(result, list) and result:
+        if isinstance(result, list):
             return "".join(str(x) for x in result)
-        if isinstance(result, str) and result:
+        if isinstance(result, str):
             return result
-
+        raise LLMProviderError("Reponse 1min.ai inattendue : resultObject absent.")
-        # Schema inattendu : on remonte un EXTRAIT du vrai payload pour diagnostiquer.
-        # Causes frequentes : credits/quota 1min.ai epuises, moderation, modele
-        # indisponible, ou reponse asynchrone (record cree mais resultat pas encore
-        # pret). Sans ce detail, l'erreur "resultObject absent" est aveugle.
-        snippet = json.dumps(payload, ensure_ascii=False)
-        if len(snippet) > 800:
-            snippet = snippet[:800] + "…"
-        logger.warning("Reponse 1min.ai inattendue (resultObject absent) : %s", snippet)
-        raise LLMProviderError(f"Reponse 1min.ai inattendue (resultObject absent) : {snippet}")
 
     @staticmethod
     def _flatten_messages(

brain/app/infrastructure/openrouter_adapter.py

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

brain/app/infrastructure/pdf_extractor.py

@@ -1,102 +0,0 @@
-"""Adapter d'extraction de texte PDF — implémente le port PdfTextExtractor.
-
-Stratégie HYBRIDE auto :
-  1. On tente d'abord l'extraction de la couche texte (PyMuPDF). Les PDF
-     "born-digital" (livres de règles officiels type Nimble, faits dans
-     InDesign/Affinity : très graphiques mais avec une vraie couche texte)
-     passent par là → rapide, fidèle, AUCUN OCR.
-  2. Si une page ne rend (quasi) aucun texte → c'est probablement une image
-     (scan ou page 100% illustrée). On rasterise la page et on la passe à
-     Tesseract (OCR). Gère donc aussi les scans purs et les PDF mixtes.
-
-Tesseract est un binaire SYSTÈME (installé dans l'image Docker du Brain). S'il
-est absent (ex: exécution locale Windows sans install), l'OCR est désactivé
-proprement : les pages-images ressortent vides mais l'extraction ne plante pas,
-et le diagnostic le signale (used_ocr reste False, texte vide).
-"""
-from __future__ import annotations
-
-import logging
-
-import pymupdf as fitz  # PyMuPDF — on importe par le nom canonique `pymupdf`
-# (et NON `import fitz`) pour éviter la collision avec le faux paquet PyPI "fitz"
-# qui échoue sur `from frontend import *`.
-
-from app.domain.models import ExtractedDocument, ExtractedPage
-from app.domain.ports import PdfExtractionError
-
-logger = logging.getLogger(__name__)
-
-# En dessous de ce nombre de caractères "significatifs" sur une page, on
-# considère qu'il n'y a pas de couche texte exploitable → repli OCR.
-_MIN_TEXT_CHARS = 20
-
-# DPI de rasterisation avant OCR. 300 = bon compromis qualité/vitesse pour du
-# texte de livre. Plus haut = plus lent et plus gourmand en mémoire.
-_OCR_DPI = 300
-
-# Langues Tesseract : français + anglais (la plupart des règles de JDR FR ont
-# des termes anglais résiduels). Doivent être installées dans l'image Docker
-# (tesseract-ocr-fra, tesseract-ocr-eng).
-_OCR_LANGS = "fra+eng"
-
-
-class PyMuPdfTextExtractor:
-    """Extracteur PDF basé sur PyMuPDF, avec repli OCR Tesseract optionnel."""
-
-    def __init__(self) -> None:
-        # On détecte la disponibilité de l'OCR une seule fois (le binaire
-        # Tesseract ne va pas apparaître/disparaître en cours d'exécution).
-        self._ocr_available = self._detect_ocr()
-
-    @staticmethod
-    def _detect_ocr() -> bool:
-        """True si pytesseract + le binaire Tesseract sont disponibles."""
-        try:
-            import pytesseract
-
-            pytesseract.get_tesseract_version()
-            return True
-        except Exception as exc:  # ImportError, TesseractNotFoundError, etc.
-            logger.warning(
-                "OCR indisponible (Tesseract non installé ?) : %s. "
-                "Les pages sans couche texte ressortiront vides.",
-                exc,
-            )
-            return False
-
-    def extract(self, pdf_bytes: bytes) -> ExtractedDocument:
-        try:
-            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
-        except Exception as exc:
-            raise PdfExtractionError(f"PDF illisible ou corrompu : {exc}") from exc
-
-        pages: list[ExtractedPage] = []
-        try:
-            for index, page in enumerate(doc):
-                text = (page.get_text() or "").strip()
-                used_ocr = False
-                if len(text) < _MIN_TEXT_CHARS and self._ocr_available:
-                    ocr_text = self._ocr_page(page)
-                    if ocr_text.strip():
-                        text = ocr_text.strip()
-                        used_ocr = True
-                pages.append(ExtractedPage(index=index, text=text, used_ocr=used_ocr))
-        finally:
-            doc.close()
-
-        return ExtractedDocument(pages=pages)
-
-    @staticmethod
-    def _ocr_page(page: "fitz.Page") -> str:
-        """Rasterise une page et lui applique l'OCR Tesseract."""
-        import pytesseract
-        from PIL import Image
-
-        pix = page.get_pixmap(dpi=_OCR_DPI)
-        img = Image.frombytes("RGB", (pix.width, pix.height), pix.samples)
-        try:
-            return pytesseract.image_to_string(img, lang=_OCR_LANGS)
-        except Exception as exc:
-            logger.warning("Échec OCR sur la page %s : %s", page.number, exc)
-            return ""

brain/app/infrastructure/vector_store.py

@@ -1,109 +0,0 @@
-"""Stockage vectoriel fichier (RAG des notebooks) — sans dépendance lourde.
-
-Chaque SOURCE est persistée en un fichier JSON sur le volume `data/` du Brain :
-  data/notebooks/{source_id}.json = {"dim": N, "chunks": [{"text":..., "vector":[...]}]}
-
-À l'échelle d'un livre (quelques centaines d'extraits), une recherche cosinus en
-Python pur est instantanée — inutile d'ajouter numpy/pgvector/une base vectorielle.
-"""
-from __future__ import annotations
-
-import json
-import math
-import re
-from pathlib import Path
-
-_STORE_DIR = Path("data/notebooks")
-_SAFE_ID = re.compile(r"[^A-Za-z0-9_-]")
-
-
-def _path(source_id: str) -> Path:
-    safe = _SAFE_ID.sub("_", str(source_id))
-    return _STORE_DIR / f"{safe}.json"
-
-
-def save(
-    source_id: str,
-    chunks: list[str],
-    vectors: list[list[float]],
-    pages: list[int] | None = None,
-) -> int:
-    """Persiste les (chunk, vecteur[, page]) d'une source. Renvoie le nb d'extraits."""
-    if len(chunks) != len(vectors):
-        raise ValueError("chunks et vectors de tailles différentes")
-    if pages is not None and len(pages) != len(chunks):
-        raise ValueError("pages et chunks de tailles différentes")
-    _STORE_DIR.mkdir(parents=True, exist_ok=True)
-    items = []
-    for i, (c, v) in enumerate(zip(chunks, vectors)):
-        item = {"text": c, "vector": v}
-        if pages is not None:
-            item["page"] = pages[i]
-        items.append(item)
-    payload = {"dim": len(vectors[0]) if vectors else 0, "chunks": items}
-    _path(source_id).write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
-    return len(chunks)
-
-
-def exists(source_id: str) -> bool:
-    return _path(source_id).exists()
-
-
-def delete(source_id: str) -> None:
-    _path(source_id).unlink(missing_ok=True)
-
-
-def _load(source_id: str) -> list[dict]:
-    p = _path(source_id)
-    if not p.exists():
-        return []
-    try:
-        data = json.loads(p.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return []
-    return data.get("chunks", []) if isinstance(data, dict) else []
-
-
-def all_chunks(source_id: str) -> list[dict]:
-    """Tous les extraits d'une source (texte + page), sans vecteurs — pour le mode
-    « analyse approfondie » (map-reduce sur tout le document)."""
-    return [{"text": c.get("text", ""), "page": c.get("page")} for c in _load(source_id)]
-
-
-def _cosine(a: list[float], b: list[float]) -> float:
-    if not a or not b or len(a) != len(b):
-        return 0.0
-    dot = 0.0
-    na = 0.0
-    nb = 0.0
-    for x, y in zip(a, b):
-        dot += x * y
-        na += x * x
-        nb += y * y
-    if na == 0.0 or nb == 0.0:
-        return 0.0
-    return dot / (math.sqrt(na) * math.sqrt(nb))
-
-
-def search(
-    source_ids: list[str],
-    query_vector: list[float],
-    top_k: int = 6,
-) -> list[dict]:
-    """Renvoie les `top_k` extraits les plus proches, toutes sources confondues.
-
-    Chaque résultat : {"text": str, "score": float, "source_id": str}.
-    """
-    scored: list[dict] = []
-    for sid in source_ids:
-        for chunk in _load(sid):
-            vector = chunk.get("vector") or []
-            score = _cosine(query_vector, vector)
-            scored.append({
-                "text": chunk.get("text", ""),
-                "score": score,
-                "source_id": sid,
-                "page": chunk.get("page"),
-            })
-    scored.sort(key=lambda c: c["score"], reverse=True)
-    return scored[:top_k]

brain/requirements.txt

@@ -2,8 +2,6 @@ fastapi==0.115.*
 uvicorn[standard]==0.32.*
 httpx==0.27.*
 pydantic-settings==2.6.*
-# Requis par FastAPI pour les uploads multipart (UploadFile) — import de PDF.
-python-multipart==0.0.*
 
 pydantic
 
@@ -12,12 +10,3 @@ pydantic
 # la plupart des modeles Llama/Gemma/Mistral (~5-10% d'ecart) — suffisant
 # pour une jauge visuelle.
 tiktoken==0.8.*
-
-# Import de PDF de regles (-> GameSystem). Extraction de la couche texte
-# (born-digital) avec repli OCR par page pour les scans.
-#   - pymupdf  : extraction texte + rasterisation des pages (pas besoin de poppler)
-#   - pytesseract + Pillow : OCR Tesseract sur les pages sans couche texte
-#     (le binaire tesseract-ocr est installe dans le Dockerfile, langues fra+eng)
-pymupdf==1.24.*
-pytesseract==0.3.*
-Pillow==11.*

brain/scripts/test_import_rules.py

@@ -1,107 +0,0 @@
-"""CLI de test pour l'import de règles PDF — boucle de feedback rapide.
-
-But : tester l'extraction + la structuration en sections sur un VRAI PDF
-(ex: livre Nimble), SANS passer par HTTP, le Core ou l'UI.
-
-Usage (depuis le dossier brain/, venv activé) :
-    python scripts/test_import_rules.py "chemin/vers/regles.pdf"
-
-Le provider LLM utilisé est celui configuré (.env + overrides de l'écran
-Paramètres) — donc 1min.ai si tu l'as sélectionné. Le script :
-  1. extrait le texte (et dit, page par page, si l'OCR s'est déclenché),
-  2. découpe + structure via le LLM,
-  3. affiche un résumé des sections,
-  4. écrit le markdown complet dans "<pdf>.rules.md" à côté du PDF.
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-import sys
-from pathlib import Path
-
-# Permet `import app...` quel que soit le cwd : on ajoute la racine brain/.
-_BRAIN_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(_BRAIN_ROOT))
-
-from app.application.import_rules import ImportRulesUseCase  # noqa: E402
-from app.core.config import get_settings  # noqa: E402
-from app.domain.ports import LLMProvider, LLMProviderError, PdfExtractionError  # noqa: E402
-from app.infrastructure.ollama_adapter import OllamaLLMProvider  # noqa: E402
-from app.infrastructure.onemin_adapter import OneMinAiLLMProvider  # noqa: E402
-from app.infrastructure.pdf_extractor import PyMuPdfTextExtractor  # noqa: E402
-
-
-def _build_provider() -> LLMProvider:
-    """Réplique la factory de main.py (choix provider selon les settings)."""
-    settings = get_settings()
-    print(f"→ Provider LLM : {settings.llm_provider} "
-          f"(modèle : {settings.onemin_model if settings.llm_provider == 'onemin' else settings.llm_model})")
-    if settings.llm_provider == "onemin":
-        return OneMinAiLLMProvider(settings)
-    return OllamaLLMProvider(settings)
-
-
-async def _run(pdf_path: Path) -> None:
-    pdf_bytes = pdf_path.read_bytes()
-    print(f"→ PDF chargé : {pdf_path.name} ({len(pdf_bytes) // 1024} Ko)\n")
-
-    extractor = PyMuPdfTextExtractor()
-
-    # 1. Extraction seule d'abord, pour le diagnostic page/OCR avant tout LLM.
-    try:
-        doc = extractor.extract(pdf_bytes)
-    except PdfExtractionError as exc:
-        print(f"✗ Extraction impossible : {exc}")
-        return
-
-    print(f"=== Extraction : {doc.page_count} page(s), "
-          f"{doc.ocr_page_count} via OCR, "
-          f"{len(doc.full_text)} caractères ===")
-    if doc.ocr_page_count == 0:
-        print("  → PDF born-digital détecté (couche texte présente, OCR non nécessaire).")
-    else:
-        print(f"  → {doc.ocr_page_count} page(s) sans couche texte : OCR déclenché.")
-    if not doc.full_text.strip():
-        print("\n✗ Aucun texte extrait. Si le PDF est un scan, vérifie que Tesseract "
-              "est installé (sinon l'OCR est désactivé).")
-        return
-
-    # 2. Structuration via le LLM (réutilise l'extraction déjà faite indirectement :
-    #    le use case ré-extrait, coût négligeable vs l'appel LLM).
-    print("\n=== Structuration via LLM (peut prendre un moment selon le nombre de morceaux)… ===")
-    use_case = ImportRulesUseCase(llm=_build_provider(), extractor=extractor)
-    try:
-        result = await use_case.execute(pdf_bytes)
-    except LLMProviderError as exc:
-        print(f"✗ Échec LLM : {exc}")
-        return
-
-    if not result.sections:
-        print("\n✗ Aucune section proposée (le modèle n'a rien renvoyé d'exploitable).")
-        return
-
-    print(f"\n=== {len(result.sections)} section(s) proposée(s) ===")
-    for title, content in result.sections.items():
-        preview = content.strip().replace("\n", " ")[:90]
-        print(f"  • {title}  ({len(content)} car.)  — {preview}…")
-
-    out_path = pdf_path.with_suffix(".rules.md")
-    out_path.write_text(result.to_markdown(), encoding="utf-8")
-    print(f"\n✓ Markdown complet écrit dans : {out_path}")
-
-
-def main() -> None:
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s — %(message)s")
-    if len(sys.argv) != 2:
-        print("Usage : python scripts/test_import_rules.py \"chemin/vers/regles.pdf\"")
-        sys.exit(1)
-    pdf_path = Path(sys.argv[1]).expanduser()
-    if not pdf_path.is_file():
-        print(f"✗ Fichier introuvable : {pdf_path}")
-        sys.exit(1)
-    asyncio.run(_run(pdf_path))
-
-
-if __name__ == "__main__":
-    main()

core/pom.xml

@@ -14,7 +14,7 @@
 
     <groupId>com.loremind</groupId>
     <artifactId>loremind-core</artifactId>
-    <version>0.11.1-beta</version>
+    <version>0.8.4-beta</version>
     <name>LoreMind Core</name>
     <description>Backend Core - Architecture Hexagonale</description>
 

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

@@ -50,15 +50,6 @@ public class ArcService {
         return arcRepository.save(arc);
     }
 
-    /**
-     * Création à partir d'un Arc complet (utilisé par le controller pour faire passer
-     * les nouveaux champs comme type sans démultiplier les paramètres).
-     */
-    public Arc createArc(Arc input) {
-        input.setId(null);
-        return arcRepository.save(input);
-    }
-
     public Optional<Arc> getArcById(String id) {
         return arcRepository.findById(id);
     }

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

@@ -1,46 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Campaign;
-import com.loremind.domain.campaigncontext.ports.CampaignPdfAdvisor;
-import com.loremind.domain.campaigncontext.ports.CampaignRepository;
-import org.springframework.stereotype.Service;
-
-import java.util.function.Consumer;
-
-/**
- * Service applicatif : conseils d'adaptation d'un PDF à une campagne existante.
- *
- * <p>Assemble un « brief » de la campagne (structure + PNJ + univers/lore) via
- * {@link CampaignBriefBuilder} et délègue la génération streamée au Brain via
- * {@link CampaignPdfAdvisor}. Ne persiste rien : la sortie est du conseil libre.</p>
- */
-@Service
-public class CampaignAdaptService {
-
-    private final CampaignRepository campaignRepository;
-    private final CampaignBriefBuilder briefBuilder;
-    private final CampaignPdfAdvisor advisor;
-
-    public CampaignAdaptService(
-            CampaignRepository campaignRepository,
-            CampaignBriefBuilder briefBuilder,
-            CampaignPdfAdvisor advisor) {
-        this.campaignRepository = campaignRepository;
-        this.briefBuilder = briefBuilder;
-        this.advisor = advisor;
-    }
-
-    public void adviseStreaming(
-            String campaignId,
-            byte[] pdfBytes,
-            String filename,
-            String messagesJson,
-            Consumer<String> onToken,
-            Runnable onComplete,
-            Consumer<Throwable> onError) {
-        Campaign campaign = campaignRepository.findById(campaignId)
-                .orElseThrow(() -> new IllegalArgumentException("Campagne introuvable : " + campaignId));
-        advisor.adviseStreaming(
-                pdfBytes, filename, briefBuilder.build(campaign), messagesJson, onToken, onComplete, onError);
-    }
-}

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

@@ -1,93 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.application.generationcontext.CampaignStructuralContextBuilder;
-import com.loremind.application.generationcontext.LoreStructuralContextBuilder;
-import com.loremind.domain.campaigncontext.Campaign;
-import com.loremind.domain.generationcontext.CampaignStructuralContext;
-import com.loremind.domain.generationcontext.CampaignStructuralContext.ArcSummary;
-import com.loremind.domain.generationcontext.CampaignStructuralContext.ChapterSummary;
-import com.loremind.domain.generationcontext.CampaignStructuralContext.NpcSummary;
-import com.loremind.domain.generationcontext.CampaignStructuralContext.SceneSummary;
-import com.loremind.domain.generationcontext.LoreStructuralContext;
-import com.loremind.domain.generationcontext.LoreStructuralContext.PageSummary;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * Construit un résumé markdown d'une campagne (structure arcs→chapitres→scènes +
- * PNJ + univers/lore). Partagé par les fonctions IA qui doivent « voir » la
- * campagne : conseils d'adaptation PDF (CampaignAdaptService) et ateliers RAG
- * (NotebookService). Centralisé ici pour une seule source de vérité.
- */
-@Service
-public class CampaignBriefBuilder {
-
-    private final CampaignStructuralContextBuilder campaignContextBuilder;
-    private final LoreStructuralContextBuilder loreContextBuilder;
-
-    public CampaignBriefBuilder(
-            CampaignStructuralContextBuilder campaignContextBuilder,
-            LoreStructuralContextBuilder loreContextBuilder) {
-        this.campaignContextBuilder = campaignContextBuilder;
-        this.loreContextBuilder = loreContextBuilder;
-    }
-
-    public String build(Campaign campaign) {
-        CampaignStructuralContext cc = campaignContextBuilder.build(campaign.getId());
-        StringBuilder sb = new StringBuilder();
-
-        sb.append("# Campagne : ").append(cc.campaignName()).append("\n");
-        if (notBlank(cc.campaignDescription())) sb.append(cc.campaignDescription()).append("\n");
-
-        sb.append("\n## Structure (arcs → chapitres → scènes)\n");
-        if (cc.arcs().isEmpty()) {
-            sb.append("_(aucun arc pour le moment)_\n");
-        }
-        for (ArcSummary arc : cc.arcs()) {
-            sb.append("### Arc : ").append(arc.name());
-            if (notBlank(arc.description())) sb.append(" — ").append(arc.description());
-            sb.append("\n");
-            for (ChapterSummary ch : arc.chapters()) {
-                sb.append("- Chapitre : ").append(ch.name());
-                if (notBlank(ch.description())) sb.append(" — ").append(ch.description());
-                sb.append("\n");
-                for (SceneSummary sc : ch.scenes()) {
-                    sb.append("  - Scène : ").append(sc.name());
-                    if (notBlank(sc.description())) sb.append(" — ").append(sc.description());
-                    sb.append("\n");
-                }
-            }
-        }
-
-        if (!cc.npcs().isEmpty()) {
-            sb.append("\n## PNJ existants\n");
-            for (NpcSummary n : cc.npcs()) {
-                sb.append("- ").append(n.name());
-                if (notBlank(n.snippet())) sb.append(" : ").append(n.snippet());
-                sb.append("\n");
-            }
-        }
-
-        if (campaign.isLinkedToLore()) {
-            loreContextBuilder.buildOptional(campaign.getLoreId()).ifPresent(lore -> appendLore(sb, lore));
-        }
-        return sb.toString();
-    }
-
-    private void appendLore(StringBuilder sb, LoreStructuralContext lore) {
-        sb.append("\n## Univers (Lore) : ").append(lore.loreName()).append("\n");
-        if (notBlank(lore.loreDescription())) sb.append(lore.loreDescription()).append("\n");
-        for (Map.Entry<String, List<PageSummary>> entry : lore.folders().entrySet()) {
-            sb.append("### ").append(entry.getKey()).append("\n");
-            for (PageSummary page : entry.getValue()) {
-                sb.append("- ").append(page.title()).append("\n");
-            }
-        }
-    }
-
-    private static boolean notBlank(String s) {
-        return s != null && !s.isBlank();
-    }
-}

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

@@ -1,181 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Arc;
-import com.loremind.domain.campaigncontext.ArcType;
-import com.loremind.domain.campaigncontext.CampaignImportProgress;
-import com.loremind.domain.campaigncontext.CampaignImportProposal;
-import com.loremind.domain.campaigncontext.CampaignImportProposal.ArcProposal;
-import com.loremind.domain.campaigncontext.CampaignImportProposal.ChapterProposal;
-import com.loremind.domain.campaigncontext.CampaignImportProposal.RoomProposal;
-import com.loremind.domain.campaigncontext.CampaignImportProposal.SceneProposal;
-import com.loremind.domain.campaigncontext.Chapter;
-import com.loremind.domain.campaigncontext.Room;
-import com.loremind.domain.campaigncontext.Scene;
-import com.loremind.domain.campaigncontext.ports.CampaignPdfImporter;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-import java.util.function.Consumer;
-
-/**
- * Service applicatif pour l'import d'un PDF de campagne.
- *
- * <p>Deux temps, conformes au principe « revue avant écriture » :
- *  1. {@link #importStructureStreaming} génère une PROPOSITION d'arbre (rien
- *     n'est persisté), streamée pour l'avancement.
- *  2. {@link #applyStructure} crée réellement les arcs/chapitres/scènes une fois
- *     l'arbre révisé/édité par l'utilisateur.</p>
- */
-@Service
-public class CampaignImportService {
-
-    private final CampaignPdfImporter campaignPdfImporter;
-    private final CampaignService campaignService;
-    private final ArcService arcService;
-    private final ChapterService chapterService;
-    private final SceneService sceneService;
-
-    public CampaignImportService(
-            CampaignPdfImporter campaignPdfImporter,
-            CampaignService campaignService,
-            ArcService arcService,
-            ChapterService chapterService,
-            SceneService sceneService) {
-        this.campaignPdfImporter = campaignPdfImporter;
-        this.campaignService = campaignService;
-        this.arcService = arcService;
-        this.chapterService = chapterService;
-        this.sceneService = sceneService;
-    }
-
-    /** Résumé de ce qui a été créé par {@link #applyStructure}. */
-    public record ApplyResult(int arcsCreated, int chaptersCreated, int scenesCreated) {}
-
-    /** Génère la proposition d'arbre (streamée). Ne persiste rien. */
-    public void importStructureStreaming(
-            byte[] pdfBytes,
-            String filename,
-            Consumer<CampaignImportProgress> onProgress,
-            Consumer<CampaignImportProposal> onDone,
-            Consumer<Throwable> onError) {
-        campaignPdfImporter.importCampaignStreaming(pdfBytes, filename, onProgress, onDone, onError);
-    }
-
-    /**
-     * Crée les arcs/chapitres/scènes de l'arbre révisé dans la campagne. Les
-     * arcs sont ajoutés APRÈS les arcs existants (ordre continué). Tout est créé
-     * dans une seule transaction (rollback si une étape échoue).
-     */
-    @Transactional
-    public ApplyResult applyStructure(String campaignId, CampaignImportProposal proposal) {
-        if (!campaignService.campaignExists(campaignId)) {
-            throw new IllegalArgumentException("Campagne introuvable : " + campaignId);
-        }
-
-        int arcsCreated = 0, chaptersCreated = 0, scenesCreated = 0;
-
-        // Les nouveaux nœuds sont ordonnés APRÈS les frères existants (déjà comptés
-        // via leur existingId dans l'arbre fusionné venu de la revue).
-        int arcOrder = countExisting(proposal.arcs(), ArcProposal::existingId);
-        for (ArcProposal arcP : proposal.arcs()) {
-            if (isBlank(arcP.name())) continue;
-            String arcId;
-            if (!isBlank(arcP.existingId())) {
-                arcId = arcP.existingId();  // arc déjà présent → on s'y rattache
-            } else {
-                arcOrder++;
-                Arc arc = arcService.createArc(Arc.builder()
-                        .name(arcP.name().trim())
-                        .description(nullIfBlank(arcP.description()))
-                        .campaignId(campaignId)
-                        .order(arcOrder)
-                        .type(parseArcType(arcP.type()))
-                        .build());
-                arcId = arc.getId();
-                arcsCreated++;
-            }
-
-            int chapterOrder = countExisting(arcP.chapters(), ChapterProposal::existingId);
-            for (ChapterProposal chapP : safe(arcP.chapters())) {
-                if (isBlank(chapP.name())) continue;
-                String chapId;
-                if (!isBlank(chapP.existingId())) {
-                    chapId = chapP.existingId();
-                } else {
-                    chapterOrder++;
-                    Chapter chapter = chapterService.createChapter(
-                            chapP.name().trim(), nullIfBlank(chapP.description()), arcId, chapterOrder);
-                    chapId = chapter.getId();
-                    chaptersCreated++;
-                }
-
-                int sceneOrder = countExisting(chapP.scenes(), SceneProposal::existingId);
-                for (SceneProposal sceneP : safe(chapP.scenes())) {
-                    if (isBlank(sceneP.name())) continue;
-                    if (!isBlank(sceneP.existingId())) continue;  // scène déjà présente
-                    sceneOrder++;
-                    sceneService.createScene(Scene.builder()
-                            .name(sceneP.name().trim())
-                            .description(nullIfBlank(sceneP.description()))
-                            .playerNarration(nullIfBlank(sceneP.playerNarration()))
-                            .gmSecretNotes(nullIfBlank(sceneP.gmNotes()))
-                            .chapterId(chapId)
-                            .order(sceneOrder)
-                            .rooms(toRooms(sceneP.rooms()))
-                            .build());
-                    scenesCreated++;
-                }
-            }
-        }
-        return new ApplyResult(arcsCreated, chaptersCreated, scenesCreated);
-    }
-
-    /** Compte les nœuds déjà présents (existingId non vide) d'une liste. */
-    private static <T> int countExisting(List<T> list, java.util.function.Function<T, String> idOf) {
-        if (list == null) return 0;
-        int n = 0;
-        for (T t : list) {
-            if (!isBlank(idOf.apply(t))) n++;
-        }
-        return n;
-    }
-
-    /** "HUB" (insensible à la casse) → {@link ArcType#HUB} ; tout le reste → LINEAR. */
-    private static ArcType parseArcType(String type) {
-        return "HUB".equalsIgnoreCase(type == null ? "" : type.trim()) ? ArcType.HUB : ArcType.LINEAR;
-    }
-
-    /** Convertit les pièces proposées en {@link Room} (ID généré, ordre = index). */
-    private static List<Room> toRooms(List<RoomProposal> proposals) {
-        List<Room> rooms = new ArrayList<>();
-        if (proposals == null) return rooms;
-        int order = 0;
-        for (RoomProposal r : proposals) {
-            if (isBlank(r.name())) continue;
-            rooms.add(Room.builder()
-                    .id(UUID.randomUUID().toString())
-                    .name(r.name().trim())
-                    .description(nullIfBlank(r.description()))
-                    .enemies(nullIfBlank(r.enemies()))
-                    .loot(nullIfBlank(r.loot()))
-                    .order(order++)
-                    .build());
-        }
-        return rooms;
-    }
-
-    private static <T> java.util.List<T> safe(java.util.List<T> list) {
-        return list == null ? java.util.List.of() : list;
-    }
-
-    private static boolean isBlank(String s) {
-        return s == null || s.isBlank();
-    }
-
-    private static String nullIfBlank(String s) {
-        return isBlank(s) ? null : s.trim();
-    }
-}

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

@@ -1,49 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Arc;
-import com.loremind.domain.campaigncontext.Chapter;
-import com.loremind.domain.campaigncontext.Prerequisite;
-import com.loremind.domain.campaigncontext.ports.ArcRepository;
-import com.loremind.domain.campaigncontext.ports.ChapterRepository;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-import java.util.TreeSet;
-
-/**
- * Service applicatif : énumère les noms de faits ({@link Prerequisite.FlagSet})
- * référencés par les chapitres d'une Campagne.
- *
- * <p>Modèle "déclaration implicite" : il n'existe pas de table de faits déclarés
- * globalement. Un fait existe dès qu'au moins une quête le référence dans ses
- * prérequis. Ce service expose la liste dédupliquée pour les UIs (toggle dans
- * la Partie, autocomplete dans l'éditeur de prérequis).</p>
- */
-@Service
-public class CampaignReferencedFlagsService {
-
-    private final ArcRepository arcRepository;
-    private final ChapterRepository chapterRepository;
-
-    public CampaignReferencedFlagsService(ArcRepository arcRepository,
-                                          ChapterRepository chapterRepository) {
-        this.arcRepository = arcRepository;
-        this.chapterRepository = chapterRepository;
-    }
-
-    /** Retourne la liste triée alphabétiquement des noms de faits référencés. */
-    public List<String> listForCampaign(String campaignId) {
-        TreeSet<String> unique = new TreeSet<>();
-        for (Arc arc : arcRepository.findByCampaignId(campaignId)) {
-            for (Chapter chapter : chapterRepository.findByArcId(arc.getId())) {
-                if (chapter.getPrerequisites() == null) continue;
-                for (Prerequisite p : chapter.getPrerequisites()) {
-                    if (p instanceof Prerequisite.FlagSet f && f.flagName() != null && !f.flagName().isBlank()) {
-                        unique.add(f.flagName());
-                    }
-                }
-            }
-        }
-        return List.copyOf(unique);
-    }
-}

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

@@ -1,15 +1,13 @@
 package com.loremind.application.campaigncontext;
 
-import com.loremind.application.playcontext.PlaythroughService;
 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 com.loremind.domain.playcontext.Playthrough;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -17,11 +15,9 @@ import java.util.List;
 import java.util.Optional;
 
 /**
- * Service d'application pour le contexte Campaign (scénario).
+ * Service d'application pour le contexte Campaign.
- *
+ * Orchestre la logique métier en utilisant le Port CampaignRepository.
- * <p>Depuis Playthrough : les PJ et les sessions ne sont plus rattachés directement
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
- * à la Campagne ; ils dépendent d'un Playthrough (Partie). La cascade de suppression
- * d'une campagne englobe donc ses Playthroughs (qui à leur tour cascadent).</p>
  */
 @Service
 public class CampaignService {
@@ -30,27 +26,35 @@ public class CampaignService {
     private final ArcRepository arcRepository;
     private final ChapterRepository chapterRepository;
     private final SceneRepository sceneRepository;
-    private final PlaythroughRepository playthroughRepository;
+    private final CharacterRepository characterRepository;
-    private final PlaythroughService playthroughService;
 
     public CampaignService(
             CampaignRepository campaignRepository,
             ArcRepository arcRepository,
             ChapterRepository chapterRepository,
             SceneRepository sceneRepository,
-            PlaythroughRepository playthroughRepository,
+            CharacterRepository characterRepository) {
-            PlaythroughService playthroughService) {
         this.campaignRepository = campaignRepository;
         this.arcRepository = arcRepository;
         this.chapterRepository = chapterRepository;
         this.sceneRepository = sceneRepository;
-        this.playthroughRepository = playthroughRepository;
+        this.characterRepository = characterRepository;
-        this.playthroughService = playthroughService;
     }
 
+    /**
+     * Parameter Object pour la création / mise à jour d'une Campaign.
+     * Évite une signature à rallonge et rend les évolutions futures (theme,
+     * coverImageUrl, etc.) sans casser les appelants.
+     *
+     * <p>{@code loreId} est nullable : une campagne peut exister sans univers associé.</p>
+     */
     public record CampaignData(String name, String description, String loreId, String gameSystemId) {}
 
-    public record DeletionImpact(int arcs, int chapters, int scenes, int playthroughs) {}
+    /**
+     * 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()
@@ -60,12 +64,7 @@ public class CampaignService {
                 .gameSystemId(normalizeId(data.gameSystemId()))
                 .arcsCount(0)
                 .build();
-        Campaign saved = campaignRepository.save(campaign);
+        return campaignRepository.save(campaign);
-
-        // Une campagne sans Partie n'a pas de sens jouable : on crée d'office
-        // une "Partie principale" pour que l'utilisateur puisse jouer immédiatement.
-        playthroughService.create(saved.getId(), "Partie principale", null);
-        return saved;
     }
 
     public Optional<Campaign> getCampaignById(String id) {
@@ -90,10 +89,19 @@ public class CampaignService {
         return campaignRepository.save(campaign);
     }
 
+    /**
+     * Normalise un ID entrant : une chaîne vide/blanche est traitée comme "pas de lien".
+     * Utile car les payloads JSON peuvent envoyer "" au lieu de null.
+     */
     private String normalizeId(String id) {
         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;
@@ -105,21 +113,22 @@ public class CampaignService {
                 sceneTotal += sceneRepository.findByChapterId(chapter.getId()).size();
             }
         }
-        int playthroughTotal = playthroughRepository.findByCampaignId(id).size();
+        int characterTotal = characterRepository.findByCampaignId(id).size();
-        return new DeletionImpact(arcs.size(), chapterTotal, sceneTotal, playthroughTotal);
+        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) {
-        // 1. Cascade des Playthroughs (qui cascadent eux-mêmes sur PJ/sessions/valeurs flags/progressions).
+        List<Arc> arcs = arcRepository.findByCampaignId(id);
-        for (Playthrough p : playthroughRepository.findByCampaignId(id)) {
+        for (Arc arc : arcs) {
-            playthroughService.delete(p.getId());
+            List<Chapter> chapters = chapterRepository.findByArcId(arc.getId());
-        }
+            for (Chapter chapter : chapters) {
-        // 2. Cascade du scénario : arcs → chapitres → scènes
-        //    (Pas de déclarations globales de faits : ils existent implicitement via les
-        //    prérequis FLAG_SET des chapitres, qui partent avec les chapitres.)
-        for (Arc arc : arcRepository.findByCampaignId(id)) {
-            for (Chapter chapter : chapterRepository.findByArcId(arc.getId())) {
                 for (var scene : sceneRepository.findByChapterId(chapter.getId())) {
                     sceneRepository.deleteById(scene.getId());
                 }
@@ -127,6 +136,9 @@ public class CampaignService {
             }
             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

@@ -44,16 +44,6 @@ public class ChapterService {
         return chapterRepository.save(chapter);
     }
 
-    /**
-     * Création à partir d'un Chapter complet (utilisé par le controller pour faire passer
-     * les nouveaux champs comme progressionStatus / prerequisites sans démultiplier les
-     * paramètres). L'id est forcé à null pour laisser la DB le générer.
-     */
-    public Chapter createChapter(Chapter input) {
-        input.setId(null);
-        return chapterRepository.save(input);
-    }
-
     public Optional<Chapter> getChapterById(String id) {
         return chapterRepository.findById(id);
     }

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

@@ -1,104 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Chapter;
-import com.loremind.domain.campaigncontext.PrerequisiteEvaluator;
-import com.loremind.domain.campaigncontext.ProgressionStatus;
-import com.loremind.domain.campaigncontext.QuestStatus;
-import com.loremind.domain.playcontext.QuestProgression;
-import com.loremind.domain.playcontext.ports.PlaythroughFlagRepository;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
-import com.loremind.domain.playcontext.ports.QuestProgressionRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import com.loremind.infrastructure.web.dto.campaigncontext.ChapterDTO;
-import org.springframework.stereotype.Service;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * Service applicatif : enrichit des ChapterDTO avec leur {@link QuestStatus} effectif,
- * relatif à un Playthrough donné.
- *
- * <p>Depuis l'introduction de Playthrough : la progression et les flags vivent au niveau
- * de la Partie, plus de la Campagne. L'enrichissement nécessite donc un playthroughId.</p>
- */
-@Service
-public class ChapterStatusEnricher {
-
-    private final PlaythroughRepository playthroughRepository;
-    private final QuestProgressionRepository progressionRepository;
-    private final PlaythroughFlagRepository flagRepository;
-    private final SessionRepository sessionRepository;
-    private final PrerequisiteEvaluator evaluator = new PrerequisiteEvaluator();
-
-    public ChapterStatusEnricher(PlaythroughRepository playthroughRepository,
-                                 QuestProgressionRepository progressionRepository,
-                                 PlaythroughFlagRepository flagRepository,
-                                 SessionRepository sessionRepository) {
-        this.playthroughRepository = playthroughRepository;
-        this.progressionRepository = progressionRepository;
-        this.flagRepository = flagRepository;
-        this.sessionRepository = sessionRepository;
-    }
-
-    /** Contexte d'évaluation + map chapterId -> ProgressionStatus pour ce Playthrough. */
-    public record PlaythroughEvalSnapshot(
-            PrerequisiteEvaluator.EvaluationContext ctx,
-            Map<String, ProgressionStatus> progressionByChapterId
-    ) {}
-
-    /** Construit le snapshot d'évaluation pour un Playthrough. */
-    public PlaythroughEvalSnapshot buildSnapshot(String playthroughId) {
-        if (playthroughId == null || playthroughRepository.findById(playthroughId).isEmpty()) {
-            return new PlaythroughEvalSnapshot(
-                    new PrerequisiteEvaluator.EvaluationContext(Collections.emptySet(), 0, Collections.emptyMap()),
-                    Collections.emptyMap()
-            );
-        }
-        Map<String, Boolean> flags = flagRepository.findByPlaythroughId(playthroughId);
-        Set<String> completedQuestIds = progressionRepository.findCompletedChapterIdsByPlaythroughId(playthroughId);
-        int sessionCount = sessionRepository.findByPlaythroughId(playthroughId).size();
-
-        Map<String, ProgressionStatus> progressionMap = new HashMap<>();
-        for (QuestProgression qp : progressionRepository.findByPlaythroughId(playthroughId)) {
-            progressionMap.put(qp.getChapterId(), qp.getStatus());
-        }
-
-        return new PlaythroughEvalSnapshot(
-                new PrerequisiteEvaluator.EvaluationContext(completedQuestIds, sessionCount, flags),
-                progressionMap
-        );
-    }
-
-    /** Calcule le statut effectif d'un seul chapitre relatif à un Playthrough. */
-    public QuestStatus computeFor(Chapter chapter, String playthroughId) {
-        PlaythroughEvalSnapshot snap = buildSnapshot(playthroughId);
-        ProgressionStatus progression = snap.progressionByChapterId()
-                .getOrDefault(chapter.getId(), ProgressionStatus.NOT_STARTED);
-        return evaluator.computeStatus(progression, chapter.getPrerequisites(), snap.ctx());
-    }
-
-    /**
-     * Injecte le {@code effectiveStatus} et le {@code progressionStatus} dans une liste de DTOs.
-     * Un seul build du snapshot pour toute la liste (optimal pour les vues qui listent un arc).
-     */
-    public void enrich(List<ChapterDTO> dtos, List<Chapter> domain, String playthroughId) {
-        if (dtos == null || dtos.isEmpty()) return;
-        PlaythroughEvalSnapshot snap = buildSnapshot(playthroughId);
-        Map<String, Chapter> byId = domain.stream()
-                .collect(Collectors.toMap(Chapter::getId, c -> c));
-        for (ChapterDTO dto : dtos) {
-            Chapter c = byId.get(dto.getId());
-            if (c == null) continue;
-            ProgressionStatus progression = snap.progressionByChapterId()
-                    .getOrDefault(c.getId(), ProgressionStatus.NOT_STARTED);
-            QuestStatus status = evaluator.computeStatus(progression, c.getPrerequisites(), snap.ctx());
-            dto.setProgressionStatus(progression.name());
-            dto.setEffectiveStatus(status.name());
-        }
-    }
-}

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

@@ -11,7 +11,6 @@ import java.util.Optional;
 
 /**
  * Service d'application pour les fiches de personnages (PJ).
- * Les PJ appartiennent désormais à un Playthrough (Partie), pas à la Campagne.
  */
 @Service
 public class CharacterService {
@@ -22,6 +21,11 @@ public class CharacterService {
         this.characterRepository = characterRepository;
     }
 
+    /**
+     * Parameter Object pour la création / mise à jour d'un Character.
+     * `order` est fourni par le controller ; si absent, le service le calcule.
+     * Les maps {@code values}/{@code imageValues} peuvent etre null (interpretees vides).
+     */
     public record CharacterData(
             String name,
             String portraitImageId,
@@ -29,14 +33,14 @@ public class CharacterService {
             Map<String, String> values,
             Map<String, List<String>> imageValues,
             Map<String, Map<String, String>> keyValueValues,
-            String playthroughId,
+            String campaignId,
             Integer order
     ) {}
 
     public Character createCharacter(CharacterData data) {
         int order = data.order() != null
                 ? data.order()
-                : nextOrderFor(data.playthroughId());
+                : nextOrderFor(data.campaignId());
         Character character = Character.builder()
                 .name(data.name())
                 .portraitImageId(data.portraitImageId())
@@ -44,7 +48,7 @@ public class CharacterService {
                 .values(data.values() != null ? new HashMap<>(data.values()) : new HashMap<>())
                 .imageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>())
                 .keyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>())
-                .playthroughId(data.playthroughId())
+                .campaignId(data.campaignId())
                 .order(order)
                 .build();
         return characterRepository.save(character);
@@ -54,8 +58,8 @@ public class CharacterService {
         return characterRepository.findById(id);
     }
 
-    public List<Character> getCharactersByPlaythroughId(String playthroughId) {
+    public List<Character> getCharactersByCampaignId(String campaignId) {
-        return characterRepository.findByPlaythroughId(playthroughId);
+        return characterRepository.findByCampaignId(campaignId);
     }
 
     public Character updateCharacter(String id, CharacterData data) {
@@ -70,7 +74,7 @@ public class CharacterService {
         if (data.order() != null) {
             existing.setOrder(data.order());
         }
-        // playthroughId immuable après création.
+        // campaignId n'est pas modifiable après création (cross-campagne move hors scope MVP).
         return characterRepository.save(existing);
     }
 
@@ -78,8 +82,9 @@ public class CharacterService {
         characterRepository.deleteById(id);
     }
 
-    private int nextOrderFor(String playthroughId) {
+    /** Renvoie la prochaine position libre — append en fin de liste. */
-        return characterRepository.findByPlaythroughId(playthroughId).stream()
+    private int nextOrderFor(String campaignId) {
+        return characterRepository.findByCampaignId(campaignId).stream()
                 .mapToInt(Character::getOrder)
                 .max()
                 .orElse(-1) + 1;

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

@@ -1,132 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Campaign;
-import com.loremind.domain.campaigncontext.Notebook;
-import com.loremind.domain.campaigncontext.NotebookMessage;
-import com.loremind.domain.campaigncontext.NotebookSource;
-import com.loremind.domain.campaigncontext.ports.CampaignRepository;
-import com.loremind.domain.campaigncontext.ports.NotebookIndexer;
-import com.loremind.domain.campaigncontext.ports.NotebookRepository;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-
-/**
- * Service d'application des notebooks (atelier RAG) : CRUD, indexation des sources
- * (déléguée au Brain), conversation persistée, et assemblage du contexte campagne.
- */
-@Service
-public class NotebookService {
-
-    private final NotebookRepository repository;
-    private final NotebookIndexer indexer;
-    private final CampaignRepository campaignRepository;
-    private final CampaignBriefBuilder briefBuilder;
-
-    public NotebookService(
-            NotebookRepository repository,
-            NotebookIndexer indexer,
-            CampaignRepository campaignRepository,
-            CampaignBriefBuilder briefBuilder) {
-        this.repository = repository;
-        this.indexer = indexer;
-        this.campaignRepository = campaignRepository;
-        this.briefBuilder = briefBuilder;
-    }
-
-    // --- Notebooks ---
-
-    public Notebook createNotebook(String campaignId, String name) {
-        String safeName = (name == null || name.isBlank()) ? "Nouvel atelier" : name.trim();
-        return repository.save(Notebook.builder().campaignId(campaignId).name(safeName).build());
-    }
-
-    public java.util.Optional<Notebook> getNotebook(String id) {
-        return repository.findById(id);
-    }
-
-    public List<Notebook> getNotebooksByCampaign(String campaignId) {
-        return repository.findByCampaignId(campaignId);
-    }
-
-    public Notebook renameNotebook(String id, String name) {
-        Notebook nb = repository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Notebook introuvable: " + id));
-        nb.setName((name == null || name.isBlank()) ? nb.getName() : name.trim());
-        return repository.save(nb);
-    }
-
-    public void deleteNotebook(String id) {
-        // Supprime les vecteurs de chaque source côté Brain (best-effort) avant la BDD.
-        for (NotebookSource s : repository.findSourcesByNotebookId(id)) {
-            indexer.delete(s.getId());
-        }
-        repository.deleteById(id);
-    }
-
-    // --- Sources ---
-
-    public List<NotebookSource> getSources(String notebookId) {
-        return repository.findSourcesByNotebookId(notebookId);
-    }
-
-    /**
-     * Ajoute une source : crée la ligne (INDEXING), lance l'indexation Brain, puis
-     * met à jour (READY + compteurs) ou (FAILED) en cas d'échec — et relaie l'erreur.
-     */
-    public NotebookSource addSource(String notebookId, String filename, byte[] pdfBytes) {
-        if (!repository.existsById(notebookId)) {
-            throw new IllegalArgumentException("Notebook introuvable: " + notebookId);
-        }
-        NotebookSource source = repository.saveSource(NotebookSource.builder()
-                .notebookId(notebookId)
-                .filename(filename != null && !filename.isBlank() ? filename : "source.pdf")
-                .status("INDEXING")
-                .build());
-        try {
-            NotebookIndexer.IndexResult result = indexer.index(source.getId(), pdfBytes, filename);
-            source.setStatus("READY");
-            source.setChunkCount(result.chunks());
-            source.setPageCount(result.pageCount());
-            return repository.saveSource(source);
-        } catch (RuntimeException e) {
-            source.setStatus("FAILED");
-            repository.saveSource(source);
-            throw e;
-        }
-    }
-
-    public void deleteSource(String sourceId) {
-        repository.findSourceById(sourceId).ifPresent(s -> indexer.delete(s.getId()));
-        repository.deleteSourceById(sourceId);
-    }
-
-    public List<String> readySourceIds(String notebookId) {
-        return repository.findSourcesByNotebookId(notebookId).stream()
-                .filter(s -> "READY".equals(s.getStatus()))
-                .map(NotebookSource::getId)
-                .toList();
-    }
-
-    // --- Conversation ---
-
-    public List<NotebookMessage> getMessages(String notebookId) {
-        return repository.findMessagesByNotebookId(notebookId);
-    }
-
-    public NotebookMessage addMessage(String notebookId, String role, String content) {
-        return repository.saveMessage(NotebookMessage.builder()
-                .notebookId(notebookId).role(role).content(content).build());
-    }
-
-    // --- Contexte campagne (oriente l'IA) ---
-
-    /** Brief COMPLET de la campagne (structure arcs/chapitres/scènes + PNJ + lore) :
-     *  l'IA « voit » la campagne, pas seulement son nom. */
-    public String buildContext(String campaignId) {
-        if (campaignId == null) return "";
-        Campaign campaign = campaignRepository.findById(campaignId).orElse(null);
-        if (campaign == null) return "";
-        return briefBuilder.build(campaign);
-    }
-}

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

@@ -29,7 +29,6 @@ public class NpcService {
             Map<String, List<String>> imageValues,
             Map<String, Map<String, String>> keyValueValues,
             String campaignId,
-            String folder,
             Integer order
     ) {}
 
@@ -45,7 +44,6 @@ public class NpcService {
                 .imageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>())
                 .keyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>())
                 .campaignId(data.campaignId())
-                .folder(normalizeFolder(data.folder()))
                 .order(order)
                 .build();
         return npcRepository.save(npc);
@@ -68,7 +66,6 @@ public class NpcService {
         existing.setValues(data.values() != null ? new HashMap<>(data.values()) : new HashMap<>());
         existing.setImageValues(data.imageValues() != null ? new HashMap<>(data.imageValues()) : new HashMap<>());
         existing.setKeyValueValues(data.keyValueValues() != null ? new HashMap<>(data.keyValueValues()) : new HashMap<>());
-        existing.setFolder(normalizeFolder(data.folder()));
         if (data.order() != null) {
             existing.setOrder(data.order());
         }
@@ -79,13 +76,6 @@ public class NpcService {
         npcRepository.deleteById(id);
     }
 
-    /** Trim le dossier ; chaîne vide → null (= non classé). */
-    private static String normalizeFolder(String folder) {
-        if (folder == null) return null;
-        String trimmed = folder.trim();
-        return trimmed.isEmpty() ? null : trimmed;
-    }
-
     private int nextOrderFor(String campaignId) {
         return npcRepository.findByCampaignId(campaignId).stream()
                 .mapToInt(Npc::getOrder)

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

@@ -1,133 +0,0 @@
-package com.loremind.application.campaigncontext;
-
-import com.loremind.domain.campaigncontext.Campaign;
-import com.loremind.domain.campaigncontext.RandomTable;
-import com.loremind.domain.campaigncontext.RandomTableEntry;
-import com.loremind.domain.campaigncontext.ports.CampaignRepository;
-import com.loremind.domain.campaigncontext.ports.RandomTableGenerator;
-import com.loremind.domain.campaigncontext.ports.RandomTableRepository;
-import com.loremind.domain.gamesystemcontext.ports.GameSystemRepository;
-import org.springframework.stereotype.Service;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Service d'application pour les tables aléatoires (campagne).
- */
-@Service
-public class RandomTableService {
-
-    private final RandomTableRepository repository;
-    private final RandomTableGenerator generator;
-    private final CampaignRepository campaignRepository;
-    private final GameSystemRepository gameSystemRepository;
-
-    public RandomTableService(
-            RandomTableRepository repository,
-            RandomTableGenerator generator,
-            CampaignRepository campaignRepository,
-            GameSystemRepository gameSystemRepository) {
-        this.repository = repository;
-        this.generator = generator;
-        this.campaignRepository = campaignRepository;
-        this.gameSystemRepository = gameSystemRepository;
-    }
-
-    public record TableData(
-            String name,
-            String description,
-            String diceFormula,
-            String icon,
-            List<RandomTableEntry> entries,
-            String campaignId,
-            Integer order
-    ) {}
-
-    public RandomTable createTable(TableData data) {
-        int order = data.order() != null ? data.order() : nextOrderFor(data.campaignId());
-        RandomTable table = RandomTable.builder()
-                .name(data.name())
-                .description(data.description())
-                .diceFormula(data.diceFormula())
-                .icon(data.icon())
-                .entries(copyEntries(data.entries()))
-                .campaignId(data.campaignId())
-                .order(order)
-                .build();
-        return repository.save(table);
-    }
-
-    public Optional<RandomTable> getTableById(String id) {
-        return repository.findById(id);
-    }
-
-    public List<RandomTable> getTablesByCampaignId(String campaignId) {
-        return repository.findByCampaignId(campaignId);
-    }
-
-    public RandomTable updateTable(String id, TableData data) {
-        RandomTable existing = repository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Table aléatoire introuvable: " + id));
-        existing.setName(data.name());
-        existing.setDescription(data.description());
-        existing.setDiceFormula(data.diceFormula());
-        existing.setIcon(data.icon());
-        existing.setEntries(copyEntries(data.entries()));
-        if (data.order() != null) {
-            existing.setOrder(data.order());
-        }
-        return repository.save(existing);
-    }
-
-    public void deleteTable(String id) {
-        repository.deleteById(id);
-    }
-
-    /** Génère une PROPOSITION de table (non persistée) via l'IA, contextualisée campagne. */
-    public RandomTable generateProposal(String campaignId, String description, String diceFormula) {
-        String formula = (diceFormula == null || diceFormula.isBlank()) ? "1d20" : diceFormula;
-        RandomTableGenerator.GeneratedTable g = generator.generate(description, formula, buildContext(campaignId));
-        return RandomTable.builder()
-                .name(g.name())
-                .description(g.description())
-                .diceFormula(formula)
-                .campaignId(campaignId)
-                .entries(g.entries() != null ? new ArrayList<>(g.entries()) : new ArrayList<>())
-                .build();
-    }
-
-    /** Brode un court récit IA sur un résultat tiré (pour la partie). */
-    public String improviseRoll(String campaignId, String tableName, String resultLabel, String resultDetail) {
-        return generator.improvise(tableName, resultLabel, resultDetail, buildContext(campaignId));
-    }
-
-    /** Contexte libre (nom de campagne + description + système) pour orienter l'IA. */
-    private String buildContext(String campaignId) {
-        if (campaignId == null) return "";
-        Campaign campaign = campaignRepository.findById(campaignId).orElse(null);
-        if (campaign == null) return "";
-        StringBuilder sb = new StringBuilder();
-        sb.append("Campagne : ").append(campaign.getName());
-        if (campaign.getDescription() != null && !campaign.getDescription().isBlank()) {
-            sb.append(" — ").append(campaign.getDescription().trim());
-        }
-        if (campaign.getGameSystemId() != null && !campaign.getGameSystemId().isBlank()) {
-            gameSystemRepository.findById(campaign.getGameSystemId())
-                    .ifPresent(gs -> sb.append("\nSystème de jeu : ").append(gs.getName()));
-        }
-        return sb.toString();
-    }
-
-    private static List<RandomTableEntry> copyEntries(List<RandomTableEntry> entries) {
-        return entries != null ? new ArrayList<>(entries) : new ArrayList<>();
-    }
-
-    private int nextOrderFor(String campaignId) {
-        return repository.findByCampaignId(campaignId).stream()
-                .mapToInt(RandomTable::getOrder)
-                .max()
-                .orElse(-1) + 1;
-    }
-}

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

@@ -6,7 +6,6 @@ import com.loremind.domain.campaigncontext.ports.SceneRepository;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -41,19 +40,6 @@ public class SceneService {
         return sceneRepository.save(scene);
     }
 
-    /**
-     * Crée une scène à partir d'un objet Scene complet (tous les champs : narration
-     * joueurs, notes MJ, pièces…). Utilisé par l'import de campagne. L'ID est forcé
-     * à null pour laisser le repo en générer un nouveau.
-     */
-    public Scene createScene(Scene input) {
-        input.setId(null);
-        if (input.getRooms() == null) {
-            input.setRooms(new ArrayList<>());
-        }
-        return sceneRepository.save(input);
-    }
-
     public Optional<Scene> getSceneById(String id) {
         return sceneRepository.findById(id);
     }

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

@@ -1,9 +1,7 @@
 package com.loremind.application.gamesystemcontext;
 
 import com.loremind.domain.gamesystemcontext.GameSystem;
-import com.loremind.domain.gamesystemcontext.RulesImportResult;
 import com.loremind.domain.gamesystemcontext.ports.GameSystemRepository;
-import com.loremind.domain.gamesystemcontext.ports.RulesPdfImporter;
 import com.loremind.domain.shared.template.TemplateField;
 import org.springframework.stereotype.Service;
 
@@ -14,34 +12,9 @@ import java.util.Optional;
 public class GameSystemService {
 
     private final GameSystemRepository gameSystemRepository;
-    private final RulesPdfImporter rulesPdfImporter;
 
-    public GameSystemService(GameSystemRepository gameSystemRepository,
+    public GameSystemService(GameSystemRepository gameSystemRepository) {
-                             RulesPdfImporter rulesPdfImporter) {
         this.gameSystemRepository = gameSystemRepository;
-        this.rulesPdfImporter = rulesPdfImporter;
-    }
-
-    /**
-     * Importe un PDF de règles et renvoie une PROPOSITION de sections (titre →
-     * markdown). Ne persiste rien : l'UI laisse l'utilisateur réviser/éditer
-     * puis enregistrer le GameSystem via {@link #updateGameSystem}/{@link #createGameSystem}.
-     */
-    public RulesImportResult importRulesFromPdf(byte[] pdfBytes, String filename) {
-        return rulesPdfImporter.importRules(pdfBytes, filename);
-    }
-
-    /**
-     * Variante streamée de {@link #importRulesFromPdf} : remonte l'avancement via
-     * callbacks (import long → l'UI affiche une progression). Ne persiste rien.
-     */
-    public void importRulesFromPdfStreaming(
-            byte[] pdfBytes,
-            String filename,
-            java.util.function.Consumer<com.loremind.domain.gamesystemcontext.RulesImportProgress> onProgress,
-            java.util.function.Consumer<RulesImportResult> onDone,
-            java.util.function.Consumer<Throwable> onError) {
-        rulesPdfImporter.importRulesStreaming(pdfBytes, filename, onProgress, onDone, onError);
     }
 
     /**

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

@@ -18,8 +18,6 @@ import com.loremind.domain.generationcontext.CampaignStructuralContext.BranchHin
 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.RoomBranchHint;
-import com.loremind.domain.generationcontext.CampaignStructuralContext.RoomSummary;
 import com.loremind.domain.generationcontext.CampaignStructuralContext.SceneSummary;
 import org.springframework.stereotype.Component;
 
@@ -68,18 +66,11 @@ public class CampaignStructuralContextBuilder {
     private static final int CHARACTER_SNIPPET_MAX_LEN = 160;
 
     /**
-     * Construit la carte narrative d'une Campagne. Sans playthroughId, les PJ
+     * Construit la carte narrative d'une Campagne (arcs → chapitres → scènes,
-     * sont omis (ils sont propres à une Partie).
+     * nom + description courte à chaque niveau).
+     * @throws IllegalArgumentException si la Campagne est introuvable
      */
     public CampaignStructuralContext build(String campaignId) {
-        return build(campaignId, null);
-    }
-
-    /**
-     * Variante avec playthroughId : injecte les PJ de la Partie indiquée.
-     * Les PNJ restent campagne-scope (donnée de scénario).
-     */
-    public CampaignStructuralContext build(String campaignId, String playthroughId) {
         Campaign campaign = campaignRepository.findById(campaignId)
                 .orElseThrow(() -> new IllegalArgumentException(
                         "Campagne non trouvée avec l'ID: " + campaignId));
@@ -89,12 +80,10 @@ public class CampaignStructuralContextBuilder {
                 .map(this::toArcSummary)
                 .collect(Collectors.toList());
 
-        List<CharacterSummary> characters = (playthroughId == null || playthroughId.isBlank())
+        List<CharacterSummary> characters = characterRepository.findByCampaignId(campaignId).stream()
-                ? List.of()
+                .sorted(Comparator.comparingInt(Character::getOrder))
-                : characterRepository.findByPlaythroughId(playthroughId).stream()
+                .map(this::toCharacterSummary)
-                        .sorted(Comparator.comparingInt(Character::getOrder))
+                .collect(Collectors.toList());
-                        .map(this::toCharacterSummary)
-                        .collect(Collectors.toList());
 
         List<NpcSummary> npcs = npcRepository.findByCampaignId(campaignId).stream()
                 .sorted(Comparator.comparingInt(Npc::getOrder))
@@ -186,42 +175,11 @@ public class CampaignStructuralContextBuilder {
                             b.condition()))
                     .collect(Collectors.toList());
 
-        List<RoomSummary> rooms = toRoomSummaries(scene);
-
         return new SceneSummary(
                 scene.getName(),
                 scene.getDescription(),
                 countImages(scene.getIllustrationImageIds()),
-                hints,
+                hints);
-                rooms);
-    }
-
-    /**
-     * Projette les pièces d'une scène en RoomSummary pour le contexte IA.
-     * Pas de notes MJ, pas de loot ni pièges : le prompt reste lisible. L'IA
-     * connaît la structure du lieu (nom des pièces, ennemis, sorties) — c'est
-     * suffisant pour proposer de la narration ou anticiper les choix.
-     */
-    private List<RoomSummary> toRoomSummaries(Scene scene) {
-        if (scene.getRooms() == null || scene.getRooms().isEmpty()) return List.of();
-        Map<String, String> nameById = scene.getRooms().stream()
-                .collect(Collectors.toMap(
-                        com.loremind.domain.campaigncontext.Room::getId,
-                        com.loremind.domain.campaigncontext.Room::getName,
-                        (a, b) -> a));
-        return scene.getRooms().stream()
-                .map(r -> {
-                    List<RoomBranchHint> hints = r.getBranches() == null
-                            ? List.of()
-                            : r.getBranches().stream()
-                                .map(b -> new RoomBranchHint(
-                                        b.label(),
-                                        nameById.getOrDefault(b.targetRoomId(), "(pièce inconnue)"),
-                                        b.condition()))
-                                .collect(Collectors.toList());
-                    return new RoomSummary(r.getName(), r.getFloor(), r.getDescription(), r.getEnemies(), hints);
-                })
-                .collect(Collectors.toList());
     }
 
     /** Helper defensif : compte les illustrations attachees (null-safe). */

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

@@ -1,234 +0,0 @@
-package com.loremind.application.generationcontext;
-
-import com.loremind.domain.campaigncontext.Arc;
-import com.loremind.domain.campaigncontext.ArcType;
-import com.loremind.domain.campaigncontext.Chapter;
-import com.loremind.domain.campaigncontext.PrerequisiteEvaluator;
-import com.loremind.domain.campaigncontext.ProgressionStatus;
-import com.loremind.domain.campaigncontext.QuestStatus;
-import com.loremind.domain.campaigncontext.ports.ArcRepository;
-import com.loremind.domain.campaigncontext.ports.ChapterRepository;
-import com.loremind.domain.generationcontext.SessionContext;
-import com.loremind.domain.generationcontext.SessionContext.JournalEntrySummary;
-import com.loremind.domain.generationcontext.SessionContext.QuestSummary;
-import com.loremind.domain.playcontext.EntryType;
-import com.loremind.domain.playcontext.Playthrough;
-import com.loremind.domain.playcontext.QuestProgression;
-import com.loremind.domain.playcontext.Session;
-import com.loremind.domain.playcontext.SessionEntry;
-import com.loremind.domain.playcontext.ports.PlaythroughFlagRepository;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
-import com.loremind.domain.playcontext.ports.QuestProgressionRepository;
-import com.loremind.domain.playcontext.ports.SessionEntryRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import org.springframework.stereotype.Component;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-/**
- * Construit le SessionContext injecté dans le prompt IA pendant une partie.
- *
- * <p>Depuis la refonte Playthrough : la session connaît son playthroughId ; la progression
- * et les flags viennent du Playthrough (pas plus de la Campagne ni du Chapter).</p>
- */
-@Component
-public class SessionStructuralContextBuilder {
-
-    private static final int MAX_CURRENT_ENTRIES = 80;
-    private static final int MAX_PREVIOUS_EVENTS = 60;
-
-    private final SessionRepository sessionRepository;
-    private final SessionEntryRepository entryRepository;
-    private final PlaythroughRepository playthroughRepository;
-    private final ArcRepository arcRepository;
-    private final ChapterRepository chapterRepository;
-    private final PlaythroughFlagRepository playthroughFlagRepository;
-    private final QuestProgressionRepository questProgressionRepository;
-    private final PrerequisiteEvaluator prerequisiteEvaluator = new PrerequisiteEvaluator();
-
-    public SessionStructuralContextBuilder(SessionRepository sessionRepository,
-                                           SessionEntryRepository entryRepository,
-                                           PlaythroughRepository playthroughRepository,
-                                           ArcRepository arcRepository,
-                                           ChapterRepository chapterRepository,
-                                           PlaythroughFlagRepository playthroughFlagRepository,
-                                           QuestProgressionRepository questProgressionRepository) {
-        this.sessionRepository = sessionRepository;
-        this.entryRepository = entryRepository;
-        this.playthroughRepository = playthroughRepository;
-        this.arcRepository = arcRepository;
-        this.chapterRepository = chapterRepository;
-        this.playthroughFlagRepository = playthroughFlagRepository;
-        this.questProgressionRepository = questProgressionRepository;
-    }
-
-    public Optional<SessionContext> buildOptional(String sessionId) {
-        return sessionRepository.findById(sessionId).map(this::toContext);
-    }
-
-    public SessionContext build(String sessionId) {
-        Session session = sessionRepository.findById(sessionId)
-                .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + sessionId));
-        return toContext(session);
-    }
-
-    private SessionContext toContext(Session session) {
-        List<JournalEntrySummary> currentEntries = loadCurrentEntries(session);
-        List<JournalEntrySummary> previousEvents = loadPreviousEvents(session);
-        HubStatus hub = computeHubStatus(session.getPlaythroughId());
-
-        return new SessionContext(
-                session.getName(),
-                session.isActive(),
-                session.getStartedAt(),
-                currentEntries,
-                previousEvents,
-                hub.available(),
-                hub.inProgress(),
-                hub.lockedTitles(),
-                hub.activeFlags());
-    }
-
-    private List<JournalEntrySummary> loadCurrentEntries(Session session) {
-        List<SessionEntry> allEntries = entryRepository.findBySessionId(session.getId());
-        List<SessionEntry> kept = allEntries.size() <= MAX_CURRENT_ENTRIES
-                ? allEntries
-                : allEntries.subList(allEntries.size() - MAX_CURRENT_ENTRIES, allEntries.size());
-
-        return kept.stream()
-                .map(e -> toSummary(e, null))
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * EVENTs des sessions précédentes du MÊME Playthrough (même table).
-     * On ne mélange jamais les EVENTs de tables différentes.
-     */
-    private List<JournalEntrySummary> loadPreviousEvents(Session current) {
-        if (current.getPlaythroughId() == null) return List.of();
-        List<Session> siblingSessions = sessionRepository.findByPlaythroughId(current.getPlaythroughId());
-        List<JournalEntrySummary> events = new ArrayList<>();
-
-        for (Session past : siblingSessions) {
-            if (past.getId().equals(current.getId())) continue;
-            for (SessionEntry entry : entryRepository.findBySessionId(past.getId())) {
-                if (entry.getType() == EntryType.EVENT) {
-                    events.add(toSummary(entry, past.getName()));
-                }
-            }
-        }
-
-        events.sort(Comparator.comparing(
-                JournalEntrySummary::occurredAt,
-                Comparator.nullsLast(Comparator.naturalOrder())));
-
-        if (events.size() > MAX_PREVIOUS_EVENTS) {
-            return events.subList(events.size() - MAX_PREVIOUS_EVENTS, events.size());
-        }
-        return events;
-    }
-
-    private JournalEntrySummary toSummary(SessionEntry entry, String sourceSessionName) {
-        return new JournalEntrySummary(
-                entry.getType() != null ? entry.getType().name() : "NOTE",
-                entry.getContent(),
-                entry.getOccurredAt(),
-                sourceSessionName);
-    }
-
-    /** Agrégat interne des données Hub à injecter dans le SessionContext. */
-    private record HubStatus(
-            List<QuestSummary> available,
-            List<QuestSummary> inProgress,
-            List<String> lockedTitles,
-            List<String> activeFlags
-    ) {}
-
-    /**
-     * Calcule l'état des quêtes Hub du Playthrough courant :
-     *   - AVAILABLE / IN_PROGRESS → résumé complet
-     *   - LOCKED                  → titre uniquement (anti-spoiler)
-     *   - COMPLETED               → omis (déjà raconté par les EVENTs)
-     */
-    private HubStatus computeHubStatus(String playthroughId) {
-        if (playthroughId == null) {
-            return new HubStatus(List.of(), List.of(), List.of(), List.of());
-        }
-        Optional<Playthrough> maybePlaythrough = playthroughRepository.findById(playthroughId);
-        if (maybePlaythrough.isEmpty()) {
-            return new HubStatus(List.of(), List.of(), List.of(), List.of());
-        }
-        String campaignId = maybePlaythrough.get().getCampaignId();
-
-        Map<String, Boolean> flags = playthroughFlagRepository.findByPlaythroughId(playthroughId);
-        List<String> activeFlags = buildActiveFlags(flags);
-
-        List<Arc> arcs = arcRepository.findByCampaignId(campaignId);
-        Map<String, Arc> arcsById = arcs.stream()
-                .filter(a -> a.getId() != null)
-                .collect(Collectors.toMap(Arc::getId, a -> a));
-
-        // On suit comme "quêtes" les chapitres CONDITIONNELS : ceux d'un arc HUB, ET
-        // ceux d'un arc linéaire qui portent des prérequis. Un chapitre linéaire sans
-        // condition reste hors du tableau (sinon tous les chapitres deviendraient des quêtes).
-
-        // Map chapterId -> ProgressionStatus pour ce Playthrough
-        Map<String, ProgressionStatus> progressionByChapter = new HashMap<>();
-        for (QuestProgression qp : questProgressionRepository.findByPlaythroughId(playthroughId)) {
-            progressionByChapter.put(qp.getChapterId(), qp.getStatus());
-        }
-
-        // IDs des chapitres COMPLETED dans la campagne (pour les prérequis QuestCompleted)
-        var completedIds = questProgressionRepository.findCompletedChapterIdsByPlaythroughId(playthroughId);
-
-        int sessionCount = sessionRepository.findByPlaythroughId(playthroughId).size();
-        PrerequisiteEvaluator.EvaluationContext ctx =
-                new PrerequisiteEvaluator.EvaluationContext(completedIds, sessionCount, flags);
-
-        List<QuestSummary> available = new ArrayList<>();
-        List<QuestSummary> inProgress = new ArrayList<>();
-        List<String> lockedTitles = new ArrayList<>();
-
-        for (Arc arc : arcs) {
-            boolean isHub = arc.getType() == ArcType.HUB;
-            for (Chapter c : chapterRepository.findByArcId(arc.getId())) {
-                boolean hasPrereqs = c.getPrerequisites() != null && !c.getPrerequisites().isEmpty();
-                if (!isHub && !hasPrereqs) continue;  // chapitre linéaire sans condition : ignoré
-                ProgressionStatus prog = progressionByChapter.getOrDefault(c.getId(), ProgressionStatus.NOT_STARTED);
-                QuestStatus status = prerequisiteEvaluator.computeStatus(prog, c.getPrerequisites(), ctx);
-                Arc parent = arcsById.get(c.getArcId());
-                String arcName = parent != null ? parent.getName() : null;
-                switch (status) {
-                    case AVAILABLE:
-                        available.add(new QuestSummary(c.getName(), arcName, c.getDescription()));
-                        break;
-                    case IN_PROGRESS:
-                        inProgress.add(new QuestSummary(c.getName(), arcName, c.getDescription()));
-                        break;
-                    case LOCKED:
-                        lockedTitles.add(c.getName());
-                        break;
-                    case COMPLETED:
-                        // Omis (déjà dans le journal des EVENTs).
-                        break;
-                }
-            }
-        }
-
-        return new HubStatus(available, inProgress, lockedTitles, activeFlags);
-    }
-
-    private List<String> buildActiveFlags(Map<String, Boolean> flags) {
-        return flags.entrySet().stream()
-                .filter(Map.Entry::getValue)
-                .map(Map.Entry::getKey)
-                .sorted()
-                .collect(Collectors.toList());
-    }
-}

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

@@ -1,122 +0,0 @@
-package com.loremind.application.generationcontext;
-
-import com.loremind.application.gamesystemcontext.GameSystemContextBuilder;
-import com.loremind.domain.campaigncontext.Campaign;
-import com.loremind.domain.campaigncontext.ports.CampaignRepository;
-import com.loremind.domain.gamesystemcontext.GenerationIntent;
-import com.loremind.domain.generationcontext.CampaignStructuralContext;
-import com.loremind.domain.generationcontext.ChatMessage;
-import com.loremind.domain.generationcontext.ChatRequest;
-import com.loremind.domain.generationcontext.ChatUsage;
-import com.loremind.domain.generationcontext.GameSystemContext;
-import com.loremind.domain.generationcontext.LoreStructuralContext;
-import com.loremind.domain.generationcontext.SessionContext;
-import com.loremind.domain.generationcontext.ports.AiChatProvider;
-import com.loremind.domain.playcontext.Playthrough;
-import com.loremind.domain.playcontext.Session;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-import java.util.function.Consumer;
-
-/**
- * Use case applicatif : chat IA pendant une Session de jeu.
- * <p>
- * Orchestre la composition des contextes :
- *  1. Charge la Session puis la Campagne associée (weak reference).
- *  2. Construit le CampaignStructuralContext (carte narrative + PJ/PNJ).
- *  3. Construit le LoreStructuralContext si la campagne est liée à un Lore.
- *  4. Construit le GameSystemContext si elle a un système de JDR.
- *  5. Construit le SessionContext (journal horodaté, statut).
- *  6. Délègue au port {@link AiChatProvider} pour le streaming.
- * </p>
- *
- * <p>La conversation est éphémère (pas de persistance) : pendant une partie,
- * l'utilité est d'avoir une assistance immédiate, pas de garder un historique.
- * Le journal de session joue déjà ce rôle de mémoire persistante.</p>
- */
-@Service
-public class StreamChatForSessionUseCase {
-
-    private final SessionRepository sessionRepository;
-    private final PlaythroughRepository playthroughRepository;
-    private final CampaignRepository campaignRepository;
-    private final CampaignStructuralContextBuilder campaignContextBuilder;
-    private final LoreStructuralContextBuilder loreContextBuilder;
-    private final GameSystemContextBuilder gameSystemContextBuilder;
-    private final SessionStructuralContextBuilder sessionContextBuilder;
-    private final AiChatProvider aiChatProvider;
-
-    public StreamChatForSessionUseCase(
-            SessionRepository sessionRepository,
-            PlaythroughRepository playthroughRepository,
-            CampaignRepository campaignRepository,
-            CampaignStructuralContextBuilder campaignContextBuilder,
-            LoreStructuralContextBuilder loreContextBuilder,
-            GameSystemContextBuilder gameSystemContextBuilder,
-            SessionStructuralContextBuilder sessionContextBuilder,
-            AiChatProvider aiChatProvider) {
-        this.sessionRepository = sessionRepository;
-        this.playthroughRepository = playthroughRepository;
-        this.campaignRepository = campaignRepository;
-        this.campaignContextBuilder = campaignContextBuilder;
-        this.loreContextBuilder = loreContextBuilder;
-        this.gameSystemContextBuilder = gameSystemContextBuilder;
-        this.sessionContextBuilder = sessionContextBuilder;
-        this.aiChatProvider = aiChatProvider;
-    }
-
-    public void execute(
-            String sessionId,
-            List<ChatMessage> messages,
-            Consumer<ChatUsage> onUsage,
-            Consumer<String> onToken,
-            Runnable onComplete,
-            Consumer<Throwable> onError) {
-
-        Session session = sessionRepository.findById(sessionId)
-                .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + sessionId));
-
-        // Chaîne de résolution : Session → Playthrough → Campaign.
-        Playthrough playthrough = playthroughRepository.findById(session.getPlaythroughId())
-                .orElseThrow(() -> new IllegalArgumentException(
-                        "Partie associée à la session introuvable : " + session.getPlaythroughId()));
-
-        Campaign campaign = campaignRepository.findById(playthrough.getCampaignId())
-                .orElseThrow(() -> new IllegalArgumentException(
-                        "Campagne associée à la partie introuvable : " + playthrough.getCampaignId()));
-
-        // Le campaign context inclut les PJ de CE Playthrough (les PJ sont par-table).
-        CampaignStructuralContext campaignContext = campaignContextBuilder.build(campaign.getId(), playthrough.getId());
-        LoreStructuralContext loreContext = loadLoreContextOrNull(campaign);
-        GameSystemContext gameSystemContext = loadGameSystemContextOrNull(campaign);
-        SessionContext sessionContext = sessionContextBuilder.build(sessionId);
-
-        ChatRequest request = ChatRequest.builder()
-                .messages(messages)
-                .loreContext(loreContext)
-                .campaignContext(campaignContext)
-                .gameSystemContext(gameSystemContext)
-                .sessionContext(sessionContext)
-                .build();
-
-        aiChatProvider.streamChat(request, onUsage, onToken, onComplete, onError);
-    }
-
-    private LoreStructuralContext loadLoreContextOrNull(Campaign campaign) {
-        if (!campaign.isLinkedToLore()) return null;
-        return loreContextBuilder.buildOptional(campaign.getLoreId()).orElse(null);
-    }
-
-    /**
-     * Pendant une session active, on injecte les sections les plus utiles en partie
-     * (combats, PNJ, mécaniques) — intent SCENE est le plus proche de ce besoin.
-     */
-    private GameSystemContext loadGameSystemContextOrNull(Campaign campaign) {
-        if (!campaign.isLinkedToGameSystem()) return null;
-        return gameSystemContextBuilder.buildOptional(campaign.getGameSystemId(), GenerationIntent.SCENE)
-                .orElse(null);
-    }
-}

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

@@ -1,135 +0,0 @@
-package com.loremind.application.licensing;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardCopyOption;
-import java.time.Instant;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * Orchestre la bascule de canal stable <-> beta via le sidecar `switcher`.
- *
- * <p>Le sidecar tourne en permanence et watch un fichier {@code command.json}
- * dans un volume partage. Quand on depose une commande, il :
- * <ol>
- *   <li>Sed la ligne IMAGE_NAMESPACE du .env</li>
- *   <li>Lance docker compose pull + up -d</li>
- *   <li>Ecrit son resultat dans {@code result.json}</li>
- * </ol>
- *
- * <p>Le Core n'a PAS acces au socket Docker — il delegue tout au sidecar
- * via fichiers, ce qui evite que la compromission du Core ne donne RCE
- * sur l'hote. Le sidecar valide strictement le contenu de la commande
- * (channel ∈ {stable, beta} uniquement).
- *
- * <p>Le canal actuel se deduit du prefixe d'image courant (recupere via
- * la variable d'env {@code IMAGE_NAMESPACE} ou {@code UPDATE_CHECK_IMAGES}) :
- * presence de "loremind-beta-" => canal beta, sinon stable.
- */
-@Service
-public class ChannelSwitcherService {
-
-    private static final Logger log = LoggerFactory.getLogger(ChannelSwitcherService.class);
-
-    public enum Channel { STABLE, BETA }
-
-    public enum SwitchStatus { IN_PROGRESS, SUCCESS, ERROR }
-
-    /** Snapshot du dernier resultat de switch ecrit par le sidecar. */
-    @JsonInclude(JsonInclude.Include.NON_NULL)
-    public record SwitchResult(
-            String id,
-            SwitchStatus status,
-            Channel channel,
-            String message,
-            Instant completedAt) {}
-
-    private final Path switcherDataPath;
-    private final String imageNamespace;
-    private final ObjectMapper json = new ObjectMapper();
-
-    public ChannelSwitcherService(
-            @Value("${SWITCHER_DATA_PATH:/shared/switcher}") String switcherDataPath,
-            // On lit IMAGE_NAMESPACE en priorite, puis UPDATE_CHECK_IMAGES en fallback
-            // (la deuxieme est toujours injectee par compose, contrairement a la premiere
-            // qui peut etre absente dans les .env legacy).
-            @Value("${IMAGE_NAMESPACE:${UPDATE_CHECK_IMAGES:}}") String imageNamespaceRaw) {
-        this.switcherDataPath = Path.of(switcherDataPath);
-        this.imageNamespace = imageNamespaceRaw != null ? imageNamespaceRaw : "";
-        log.info("ChannelSwitcherService initialized: dataPath={} imageNamespace={}",
-                switcherDataPath, this.imageNamespace);
-    }
-
-    /**
-     * Detection du canal courant a partir du prefixe d'image charge au demarrage.
-     * Pas de magie : si le namespace contient "beta-" on est en beta, sinon stable.
-     */
-    public Channel getCurrentChannel() {
-        return imageNamespace.contains("loremind-beta-") ? Channel.BETA : Channel.STABLE;
-    }
-
-    /**
-     * Indique si le sidecar est disponible (volume partage accessible).
-     * Si non, on degrade en lecture seule (l'UI affichera l'ancien message
-     * avec instructions manuelles).
-     */
-    public boolean isSwitcherAvailable() {
-        return Files.isDirectory(switcherDataPath) && Files.isWritable(switcherDataPath);
-    }
-
-    /**
-     * Depose une commande de switch dans le volume partage. Renvoie l'ID
-     * de la commande, que le client peut utiliser pour poller le status.
-     *
-     * @throws IllegalStateException si le sidecar n'est pas disponible
-     * @throws IOException si l'ecriture du fichier echoue
-     */
-    public String requestSwitch(Channel target) throws IOException {
-        if (!isSwitcherAvailable()) {
-            throw new IllegalStateException("Switcher sidecar not available (volume mount missing)");
-        }
-        String id = UUID.randomUUID().toString();
-        Map<String, Object> command = new LinkedHashMap<>();
-        command.put("id", id);
-        command.put("channel", target.name().toLowerCase());
-        command.put("requestedAt", Instant.now().toString());
-
-        Path commandFile = switcherDataPath.resolve("command.json");
-        Path tmp = Files.createTempFile(switcherDataPath, "command-", ".tmp");
-        try {
-            json.writerWithDefaultPrettyPrinter().writeValue(tmp.toFile(), command);
-            // Atomic move : evite que le sidecar lise un fichier partiellement ecrit.
-            Files.move(tmp, commandFile, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
-        } finally {
-            // Cleanup au cas ou move aurait echoue avant le rename.
-            Files.deleteIfExists(tmp);
-        }
-        log.info("Switch command written: id={} channel={}", id, target);
-        return id;
-    }
-
-    /**
-     * Lit le dernier resultat ecrit par le sidecar, s'il existe.
-     * Renvoie null si aucun switch n'a encore ete tente sur cette instance.
-     */
-    public SwitchResult getLastResult() {
-        Path resultFile = switcherDataPath.resolve("result.json");
-        if (!Files.exists(resultFile)) return null;
-        try {
-            return json.readValue(resultFile.toFile(), SwitchResult.class);
-        } catch (IOException e) {
-            log.warn("Cannot parse switcher result.json: {}", e.getMessage());
-            return null;
-        }
-    }
-}

core/src/main/java/com/loremind/application/playcontext/PlaythroughService.java

@@ -1,110 +0,0 @@
-package com.loremind.application.playcontext;
-
-import com.loremind.domain.campaigncontext.ports.CampaignRepository;
-import com.loremind.domain.campaigncontext.ports.CharacterRepository;
-import com.loremind.domain.playcontext.Playthrough;
-import com.loremind.domain.playcontext.Session;
-import com.loremind.domain.playcontext.ports.PlaythroughFlagRepository;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
-import com.loremind.domain.playcontext.ports.QuestProgressionRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import org.springframework.beans.BeanUtils;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Service applicatif pour le cycle de vie d'un Playthrough (Partie).
- *
- * <p>Cascade de suppression : un Playthrough supprime ses flags, ses progressions,
- * ses PJ et ses sessions (avec leurs entrées de journal).</p>
- */
-@Service
-public class PlaythroughService {
-
-    private final PlaythroughRepository playthroughRepository;
-    private final CampaignRepository campaignRepository;
-    private final PlaythroughFlagRepository flagRepository;
-    private final QuestProgressionRepository progressionRepository;
-    private final CharacterRepository characterRepository;
-    private final SessionRepository sessionRepository;
-    private final SessionService sessionService;
-
-    public PlaythroughService(PlaythroughRepository playthroughRepository,
-                              CampaignRepository campaignRepository,
-                              PlaythroughFlagRepository flagRepository,
-                              QuestProgressionRepository progressionRepository,
-                              CharacterRepository characterRepository,
-                              SessionRepository sessionRepository,
-                              SessionService sessionService) {
-        this.playthroughRepository = playthroughRepository;
-        this.campaignRepository = campaignRepository;
-        this.flagRepository = flagRepository;
-        this.progressionRepository = progressionRepository;
-        this.characterRepository = characterRepository;
-        this.sessionRepository = sessionRepository;
-        this.sessionService = sessionService;
-    }
-
-    /** Compte des entités qui seront supprimées en cascade avec la Partie. */
-    public record DeletionImpact(int sessions, int characters, int flags, int progressions) {}
-
-    public Playthrough create(String campaignId, String name, String description) {
-        if (campaignId == null || campaignId.isBlank()) {
-            throw new IllegalArgumentException("campaignId requis.");
-        }
-        if (!campaignRepository.existsById(campaignId)) {
-            throw new IllegalArgumentException("Campagne introuvable : " + campaignId);
-        }
-        Playthrough p = Playthrough.builder()
-                .campaignId(campaignId)
-                .name((name == null || name.isBlank()) ? "Partie principale" : name.trim())
-                .description(description)
-                .build();
-        return playthroughRepository.save(p);
-    }
-
-    public Playthrough update(String id, Playthrough updated) {
-        Playthrough existing = playthroughRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Partie introuvable : " + id));
-        BeanUtils.copyProperties(updated, existing, "id", "campaignId", "createdAt");
-        return playthroughRepository.save(existing);
-    }
-
-    public Optional<Playthrough> getById(String id) {
-        return playthroughRepository.findById(id);
-    }
-
-    public List<Playthrough> getByCampaignId(String campaignId) {
-        return playthroughRepository.findByCampaignId(campaignId);
-    }
-
-    public DeletionImpact getDeletionImpact(String id) {
-        int sessions = sessionRepository.findByPlaythroughId(id).size();
-        int characters = characterRepository.findByPlaythroughId(id).size();
-        int flags = flagRepository.findByPlaythroughId(id).size();
-        int progressions = progressionRepository.findByPlaythroughId(id).size();
-        return new DeletionImpact(sessions, characters, flags, progressions);
-    }
-
-    @Transactional
-    public void delete(String id) {
-        if (!playthroughRepository.existsById(id)) {
-            throw new IllegalArgumentException("Partie introuvable : " + id);
-        }
-        // Cascade : sessions (et leurs entries), PJ, flags, progressions
-        for (Session s : sessionRepository.findByPlaythroughId(id)) {
-            sessionService.deleteSession(s.getId());
-        }
-        characterRepository.findByPlaythroughId(id).forEach(c -> characterRepository.deleteById(c.getId()));
-        flagRepository.deleteAllByPlaythroughId(id);
-        progressionRepository.deleteAllByPlaythroughId(id);
-        playthroughRepository.deleteById(id);
-    }
-
-    public boolean exists(String id) {
-        return playthroughRepository.existsById(id);
-    }
-}

core/src/main/java/com/loremind/application/playcontext/SessionEntryService.java

@@ -1,81 +0,0 @@
-package com.loremind.application.playcontext;
-
-import com.loremind.domain.playcontext.EntryType;
-import com.loremind.domain.playcontext.SessionEntry;
-import com.loremind.domain.playcontext.ports.SessionEntryRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import org.springframework.stereotype.Service;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Service d'application pour le journal d'une Session.
- * Gère le cycle CRUD des entrées (note, évènement, jet, action joueur).
- */
-@Service
-public class SessionEntryService {
-
-    private final SessionEntryRepository entryRepository;
-    private final SessionRepository sessionRepository;
-
-    public SessionEntryService(SessionEntryRepository entryRepository,
-                               SessionRepository sessionRepository) {
-        this.entryRepository = entryRepository;
-        this.sessionRepository = sessionRepository;
-    }
-
-    /** Données fournies par l'API pour créer ou éditer une entrée. */
-    public record EntryData(EntryType type, String content, LocalDateTime occurredAt) {}
-
-    public SessionEntry createEntry(String sessionId, EntryData data) {
-        if (sessionId == null || sessionId.isBlank()) {
-            throw new IllegalArgumentException("sessionId est requis.");
-        }
-        if (!sessionRepository.existsById(sessionId)) {
-            throw new IllegalArgumentException("Session introuvable : " + sessionId);
-        }
-        validateContent(data.content());
-
-        LocalDateTime now = LocalDateTime.now();
-        SessionEntry entry = SessionEntry.builder()
-                .sessionId(sessionId)
-                .type(data.type() != null ? data.type() : EntryType.NOTE)
-                .content(data.content().trim())
-                .occurredAt(data.occurredAt() != null ? data.occurredAt() : now)
-                .build();
-        return entryRepository.save(entry);
-    }
-
-    public SessionEntry updateEntry(String id, EntryData data) {
-        validateContent(data.content());
-        SessionEntry existing = entryRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Entrée introuvable : " + id));
-        if (data.type() != null) existing.setType(data.type());
-        existing.setContent(data.content().trim());
-        if (data.occurredAt() != null) existing.setOccurredAt(data.occurredAt());
-        return entryRepository.save(existing);
-    }
-
-    public Optional<SessionEntry> getById(String id) {
-        return entryRepository.findById(id);
-    }
-
-    public List<SessionEntry> getBySessionId(String sessionId) {
-        return entryRepository.findBySessionId(sessionId);
-    }
-
-    public void deleteEntry(String id) {
-        if (!entryRepository.existsById(id)) {
-            throw new IllegalArgumentException("Entrée introuvable : " + id);
-        }
-        entryRepository.deleteById(id);
-    }
-
-    private void validateContent(String content) {
-        if (content == null || content.isBlank()) {
-            throw new IllegalArgumentException("Le contenu d'une entrée ne peut pas être vide.");
-        }
-    }
-}

core/src/main/java/com/loremind/application/playcontext/SessionService.java

@@ -1,118 +0,0 @@
-package com.loremind.application.playcontext;
-
-import com.loremind.domain.playcontext.Session;
-import com.loremind.domain.playcontext.ports.PlaythroughRepository;
-import com.loremind.domain.playcontext.ports.SessionEntryRepository;
-import com.loremind.domain.playcontext.ports.SessionRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Service d'application pour le Play Context.
- * Orchestre le cycle de vie d'une Session (lancement, fin, renommage).
- *
- * <p>Règle métier : une seule Session peut être active (endedAt null) à la fois.</p>
- * <p>Depuis Playthrough : une Session appartient à un Playthrough (pas directement à une Campaign).</p>
- */
-@Service
-public class SessionService {
-
-    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
-
-    private final SessionRepository sessionRepository;
-    private final SessionEntryRepository entryRepository;
-    private final PlaythroughRepository playthroughRepository;
-
-    public SessionService(SessionRepository sessionRepository,
-                          SessionEntryRepository entryRepository,
-                          PlaythroughRepository playthroughRepository) {
-        this.sessionRepository = sessionRepository;
-        this.entryRepository = entryRepository;
-        this.playthroughRepository = playthroughRepository;
-    }
-
-    /**
-     * Lance une nouvelle session sur le Playthrough donné.
-     * Échoue si une session est déjà active ou si le Playthrough n'existe pas.
-     */
-    public Session startSession(String playthroughId) {
-        if (playthroughId == null || playthroughId.isBlank()) {
-            throw new IllegalArgumentException("playthroughId est requis pour démarrer une session.");
-        }
-        if (!playthroughRepository.existsById(playthroughId)) {
-            throw new IllegalArgumentException("Partie introuvable : " + playthroughId);
-        }
-        // Règle métier : une seule session active par Partie (pas de verrou global cross-Partie).
-        sessionRepository.findActiveByPlaythroughId(playthroughId).ifPresent(s -> {
-            throw new IllegalStateException(
-                    "Une session est déjà en cours pour cette Partie (id=" + s.getId() +
-                    "). Termine-la avant d'en lancer une nouvelle.");
-        });
-
-        LocalDateTime now = LocalDateTime.now();
-        Session session = Session.builder()
-                .name(generateDefaultName(now))
-                .playthroughId(playthroughId)
-                .startedAt(now)
-                .build();
-        return sessionRepository.save(session);
-    }
-
-    public Session endSession(String id) {
-        Session session = sessionRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + id));
-        if (!session.isActive()) {
-            throw new IllegalStateException("Cette session est déjà terminée.");
-        }
-        session.setEndedAt(LocalDateTime.now());
-        return sessionRepository.save(session);
-    }
-
-    public Session renameSession(String id, String newName) {
-        if (newName == null || newName.isBlank()) {
-            throw new IllegalArgumentException("Le nom de la session ne peut pas être vide.");
-        }
-        Session session = sessionRepository.findById(id)
-                .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + id));
-        session.setName(newName.trim());
-        return sessionRepository.save(session);
-    }
-
-    public Optional<Session> getById(String id) {
-        return sessionRepository.findById(id);
-    }
-
-    public Optional<Session> getActive() {
-        return sessionRepository.findActive();
-    }
-
-    public Optional<Session> getActiveByPlaythrough(String playthroughId) {
-        return sessionRepository.findActiveByPlaythroughId(playthroughId);
-    }
-
-    public List<Session> getAll() {
-        return sessionRepository.findAll();
-    }
-
-    public List<Session> getByPlaythroughId(String playthroughId) {
-        return sessionRepository.findByPlaythroughId(playthroughId);
-    }
-
-    @Transactional
-    public void deleteSession(String id) {
-        if (!sessionRepository.existsById(id)) {
-            throw new IllegalArgumentException("Session introuvable : " + id);
-        }
-        entryRepository.deleteBySessionId(id);
-        sessionRepository.deleteById(id);
-    }
-
-    private String generateDefaultName(LocalDateTime startedAt) {
-        return "Session du " + startedAt.format(DATE_FORMATTER);
-    }
-}

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

@@ -21,14 +21,6 @@ public class Arc {
     private String campaignId;       // Référence vers la Campaign parente
     private int order;               // Ordre de l'arc dans la campagne
 
-    /**
-     * Type structurel de l'arc. Détermine son rendu UI et la sémantique de ses chapitres
-     * (séquence narrative LINEAR vs. quêtes parallèles d'un HUB).
-     * Défaut LINEAR pour rétro-compatibilité avec les arcs existants.
-     */
-    @Builder.Default
-    private ArcType type = ArcType.LINEAR;
-
     /** Cle d'icone choisie par l'utilisateur (cf. CAMPAIGN_ICON_OPTIONS cote front). */
     private String icon;
 

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

@@ -1,14 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Type structurel d'un Arc.
- * - LINEAR : narration séquentielle classique (chapitres joués dans l'ordre).
- * - HUB    : narration non linéaire ; les chapitres sont des "quêtes" satellites
- *            potentiellement parallèles, soumises à des prérequis pour être débloquées.
- *
- * Value Object du domaine (Bounded Context : Campaign).
- */
-public enum ArcType {
-    LINEAR,
-    HUB
-}

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

@@ -6,12 +6,8 @@ import java.time.LocalDateTime;
 
 /**
  * Entité de domaine représentant une Campaign.
- * Conteneur du SCÉNARIO (générique, ré-utilisable par plusieurs tables).
+ * Conteneur global pour organiser la narration d'une campagne.
- *
+ * Entité pure du domaine, sans dépendance technique.
- * <p>Toute donnée dynamique propre à une table jouée (progression des quêtes,
- * flags narratifs, sessions, PJ) vit dans un {@link com.loremind.domain.playcontext.Playthrough}.</p>
- *
- * <p>Entité pure du domaine, sans dépendance technique.</p>
  */
 @Data
 @Builder
@@ -25,13 +21,17 @@ public class Campaign {
     private int arcsCount;
 
     /**
-     * Référence faible vers un Lore. Nullable.
+     * Référence faible (weak reference) vers un Lore.
-     * Ce n'est qu'un ID : le Campaign Context ne dépend PAS du Lore Context.
+     * Nullable : une campagne peut exister sans univers associé (one-shot, test, pitch libre).
+     * Ce n'est qu'un ID : le Campaign Context ne dépend PAS du Lore Context
+     * (respect des Bounded Contexts en DDD).
      */
     private String loreId;
 
     /**
-     * Référence faible vers un GameSystem. Nullable.
+     * Référence faible (weak reference) vers un GameSystem.
+     * Nullable : une campagne peut être "générique" (pas de système de JDR déclaré).
+     * Weak reference pour respecter la séparation des Bounded Contexts.
      */
     private String gameSystemId;
 

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

@@ -1,18 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Évènement d'avancement émis pendant l'import streamé d'un PDF de campagne.
- * <p>
- * {@code total} = nombre de morceaux à traiter (0 pendant l'extraction).
- * {@code current} = morceaux traités. Les compteurs arc/chapitre/scène donnent
- * un aperçu de l'arbre trouvé jusqu'ici (affichage « au fil de l'eau »).
- */
-public record CampaignImportProgress(
-        int current,
-        int total,
-        int pageCount,
-        int ocrPageCount,
-        int arcCount,
-        int chapterCount,
-        int sceneCount) {
-}

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

@@ -1,40 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import java.util.List;
-
-/**
- * Proposition d'arborescence narrative extraite d'un PDF de campagne.
- * <p>
- * PROPOSITION non persistée : l'UI laisse l'utilisateur réviser/éditer l'arbre
- * avant la création effective des arcs/chapitres/scènes. Records purs (domaine).
- */
-public record CampaignImportProposal(List<ArcProposal> arcs) {
-
-    /**
-     * {@code existingId} (nullable) : si présent, le nœud existe DÉJÀ dans la
-     * campagne (rempli côté UI lors de la revue pré-chargée) → l'apply ne le
-     * recrée pas, il l'utilise comme parent des nouveaux enfants. Null = à créer.
-     */
-
-    /** {@code type} = "LINEAR" ou "HUB" (mappé sur {@link ArcType} à l'apply). */
-    public record ArcProposal(
-            String name, String description, String type,
-            List<ChapterProposal> chapters, String existingId) {
-    }
-
-    public record ChapterProposal(
-            String name, String description, List<SceneProposal> scenes, String existingId) {
-    }
-
-    /**
-     * {@code rooms} non vide => lieu explorable (donjon). {@code playerNarration}
-     * = encadré « à lire aux joueurs », {@code gmNotes} = secrets/développement MJ.
-     */
-    public record SceneProposal(
-            String name, String description, String playerNarration, String gmNotes,
-            List<RoomProposal> rooms, String existingId) {
-    }
-
-    public record RoomProposal(String name, String description, String enemies, String loot) {
-    }
-}

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

@@ -21,14 +21,6 @@ public class Chapter {
     private String arcId;              // Référence vers l'Arc parent
     private int order;                 // Ordre du chapitre dans l'arc
 
-    /**
-     * Conditions de déblocage (combinées en ET). Vide => quête immédiatement AVAILABLE.
-     * Pertinent surtout pour les chapitres d'un Arc HUB ; ignoré pour LINEAR.
-     * Donnée de SCÉNARIO — partagée par toutes les Parties de la campagne.
-     */
-    @Builder.Default
-    private List<Prerequisite> prerequisites = new ArrayList<>();
-
     /** Cle d'icone choisie par l'utilisateur (cf. CAMPAIGN_ICON_OPTIONS cote front). */
     private String icon;
 

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

@@ -59,14 +59,10 @@ public class Character {
      */
     private Map<String, Map<String, String>> keyValueValues;
 
-    /**
+    /** Référence vers la Campaign parente. */
-     * Référence vers le Playthrough (= la partie / table) auquel ce PJ appartient.
+    private String campaignId;
-     * Les PJ sont propres à une table jouée, pas au scénario générique de la campagne.
-     * Weak reference cross-context.
-     */
-    private String playthroughId;
 
-    /** Ordre d'affichage dans la liste des PJ de la Partie. */
+    /** Ordre d'affichage dans la liste des PJ de la campagne. */
     private int order;
 
     private LocalDateTime createdAt;

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

@@ -1,23 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Atelier d'adaptation (« notebook ») d'une campagne : une ou plusieurs sources
- * PDF indexées (RAG) + une conversation, persistés pour y revenir.
- * <p>
- * Les SOURCES ({@link NotebookSource}) et les MESSAGES ({@link NotebookMessage})
- * sont gérés comme entités liées par {@code notebookId} (chargées séparément).
- */
-@Data
-@Builder
-public class Notebook {
-    private String id;
-    private String name;
-    private String campaignId;
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-}

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

@@ -1,20 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Un message de la conversation d'un {@link Notebook}. {@code role} = "user" ou
- * "assistant". Persisté pour recharger l'historique de l'atelier.
- */
-@Data
-@Builder
-public class NotebookMessage {
-    private String id;
-    private String notebookId;
-    private String role;
-    private String content;
-    private LocalDateTime createdAt;
-}

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

@@ -1,24 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Une source (PDF) d'un {@link Notebook}. Son {@code id} sert de clé d'indexation
- * vectorielle côté Brain (les vecteurs vivent sur le volume du Brain).
- * <p>
- * {@code status} : INDEXING (en cours), READY (interrogeable), FAILED (échec).
- */
-@Data
-@Builder
-public class NotebookSource {
-    private String id;
-    private String notebookId;
-    private String filename;
-    private String status;
-    private int chunkCount;
-    private int pageCount;
-    private LocalDateTime createdAt;
-}

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

@@ -46,9 +46,6 @@ public class Npc {
     /** Référence vers la Campaign parente (cross-aggregate via ID). */
     private String campaignId;
 
-    /** Dossier de classement (texte libre, ex. « Bard's Gate »). Nullable = non classé. */
-    private String folder;
-
     /** Ordre d'affichage dans la liste des PNJ de la campagne. */
     private int order;
 

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

@@ -1,26 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Condition de déblocage d'une quête (Chapter dans un Arc HUB).
- *
- * Sealed : la liste des types est CLOSE et connue à la compilation. Pour ajouter
- * un nouveau type (ex : NpcMet), il faudra l'ajouter ici ET dans
- * {@link PrerequisiteEvaluator}.
- *
- * Sémantique MVP : une quête a une LISTE de prérequis, tous combinés en ET logique
- * (pas de OR pour le moment).
- */
-public sealed interface Prerequisite
-        permits Prerequisite.QuestCompleted,
-                Prerequisite.SessionReached,
-                Prerequisite.FlagSet {
-
-    /** La quête référencée par {@code questId} doit être en COMPLETED. */
-    record QuestCompleted(String questId) implements Prerequisite {}
-
-    /** Le compteur de sessions de la campagne doit avoir atteint {@code minSessionNumber}. */
-    record SessionReached(int minSessionNumber) implements Prerequisite {}
-
-    /** Le flag campagne nommé {@code flagName} doit être à true. */
-    record FlagSet(String flagName) implements Prerequisite {}
-}

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

@@ -1,65 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Service de domaine (pur, sans effet de bord) : évalue les prérequis d'une quête
- * et en dérive le {@link QuestStatus} effectif.
- *
- * NB Java 17 : on utilise instanceof pattern matching (finalisé en Java 16) plutôt que
- * switch pattern matching (preview en 17, final en 21). La perte de l'exhaustivité
- * compile-time est compensée par le throw final qui fait crasher tout nouvel
- * implémentant non câblé.
- */
-public final class PrerequisiteEvaluator {
-
-    /**
-     * Contexte minimal nécessaire à l'évaluation. On ne passe pas la Campaign entière
-     * pour ne pas créer de couplage fort ; juste les faits nécessaires.
-     */
-    public record EvaluationContext(
-            Set<String> completedQuestIds,
-            int currentSessionCount,
-            Map<String, Boolean> campaignFlags
-    ) {}
-
-    /** True si TOUS les prérequis sont satisfaits (ET logique). Vide => true. */
-    public boolean areAllSatisfied(List<Prerequisite> prerequisites, EvaluationContext ctx) {
-        if (prerequisites == null || prerequisites.isEmpty()) return true;
-        return prerequisites.stream().allMatch(p -> isSatisfied(p, ctx));
-    }
-
-    /** Évalue un seul prérequis. */
-    public boolean isSatisfied(Prerequisite prereq, EvaluationContext ctx) {
-        if (prereq instanceof Prerequisite.QuestCompleted q) {
-            return ctx.completedQuestIds().contains(q.questId());
-        }
-        if (prereq instanceof Prerequisite.SessionReached s) {
-            return ctx.currentSessionCount() >= s.minSessionNumber();
-        }
-        if (prereq instanceof Prerequisite.FlagSet f) {
-            return Boolean.TRUE.equals(ctx.campaignFlags().get(f.flagName()));
-        }
-        throw new IllegalStateException("Prerequisite non géré : " + prereq.getClass().getName());
-    }
-
-    /** Dérive le statut effectif à partir de la progression manuelle + des prérequis. */
-    public QuestStatus computeStatus(
-            ProgressionStatus progression,
-            List<Prerequisite> prerequisites,
-            EvaluationContext ctx
-    ) {
-        switch (progression) {
-            case COMPLETED:   return QuestStatus.COMPLETED;
-            case IN_PROGRESS: return QuestStatus.IN_PROGRESS;
-            case NOT_STARTED:
-                return areAllSatisfied(prerequisites, ctx)
-                        ? QuestStatus.AVAILABLE
-                        : QuestStatus.LOCKED;
-            default:
-                throw new IllegalStateException("ProgressionStatus non géré : " + progression);
-        }
-    }
-}

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

@@ -1,17 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Statut de progression d'une quête (= Chapter dans un Arc HUB), piloté manuellement par le MJ.
- *
- * NOT_STARTED : pas encore commencée. Peut être visible (AVAILABLE) ou cachée (LOCKED)
- *               selon les prérequis — voir {@link QuestStatus}.
- * IN_PROGRESS : démarrée par le MJ via le bouton "Démarrer cette quête".
- * COMPLETED   : marquée terminée par le MJ.
- *
- * NB : un Chapter d'Arc LINEAR conserve NOT_STARTED par défaut sans impact visible.
- */
-public enum ProgressionStatus {
-    NOT_STARTED,
-    IN_PROGRESS,
-    COMPLETED
-}

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

@@ -1,19 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Statut effectif d'une quête tel qu'affiché dans la vue Hub.
- * DÉRIVÉ — jamais persisté. Calculé par {@link PrerequisiteEvaluator} à partir
- * de la {@link ProgressionStatus} persistée et de l'évaluation des prérequis.
- *
- * Table de vérité :
- *   NOT_STARTED + prérequis non remplis -> LOCKED
- *   NOT_STARTED + prérequis remplis     -> AVAILABLE
- *   IN_PROGRESS                          -> IN_PROGRESS
- *   COMPLETED                            -> COMPLETED
- */
-public enum QuestStatus {
-    LOCKED,
-    AVAILABLE,
-    IN_PROGRESS,
-    COMPLETED
-}

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

@@ -1,50 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Table aléatoire d'une campagne : on jette un dé ({@code diceFormula}) et la
- * valeur tombée désigne une {@link RandomTableEntry} (par sa plage) → un résultat.
- * <p>
- * Outil MJ classique (rencontres, butin, complications, noms…). Le JET lui-même
- * est effectué côté client (instantané, comme le panneau de dés) ; le domaine ne
- * fait que stocker la table et ses entrées. Scope campagne (cross-aggregate via ID).
- */
-@Data
-@Builder
-public class RandomTable {
-
-    private String id;
-    private String name;
-
-    /** Description libre (à quoi sert la table). Nullable. */
-    private String description;
-
-    /** Formule du dé à lancer : "1d20", "2d6", "d100"… */
-    private String diceFormula;
-
-    /** Clé d'icône (lucide) pour la sidebar/fiche. Nullable. */
-    private String icon;
-
-    /** Référence vers la Campaign parente (cross-aggregate via ID). */
-    private String campaignId;
-
-    /** Ordre d'affichage dans la liste des tables de la campagne. */
-    private int order;
-
-    /** Entrées ordonnées (par plage de jet). Jamais null après construction. */
-    private List<RandomTableEntry> entries;
-
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-
-    public List<RandomTableEntry> getEntries() {
-        if (entries == null) entries = new ArrayList<>();
-        return entries;
-    }
-}

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

@@ -1,29 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-/**
- * Une entrée d'une {@link RandomTable} : une PLAGE de jet (minRoll..maxRoll, bornes
- * incluses) qui mappe vers un résultat. Les plages permettent les tables PONDÉRÉES
- * (un résultat couvrant 1–10 est plus probable qu'un couvrant 11–12).
- * <p>
- * Value object possédé par la table (pas d'identité propre côté domaine) : à chaque
- * mise à jour, les entrées sont remplacées en bloc.
- */
-@Data
-@Builder
-public class RandomTableEntry {
-
-    /** Borne basse du jet (incluse). */
-    private int minRoll;
-
-    /** Borne haute du jet (incluse). Pour une entrée unitaire, min == max. */
-    private int maxRoll;
-
-    /** Résultat court affiché (ex. "Embuscade de gobelins"). */
-    private String label;
-
-    /** Détail markdown : « ce que c'est » (effet, description). Nullable. */
-    private String detail;
-}

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

@@ -1,69 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Pièce d'un lieu explorable (donjon, crypte…) attaché à une Scene.
- *
- * <p>Une Scene devient « explorable » dès qu'elle a au moins une Room. Tant
- * qu'elle n'en a pas, elle se comporte comme un beat narratif classique.</p>
- *
- * <p>Pas un record Java parce que la liste {@code branches} est mutable côté
- * builder ; on garde la classe Lombok pour la cohérence avec le reste du
- * domaine (Arc, Chapter, Scene). L'ID est généré côté front (UUID) au moment
- * de la création — pas d'auto-increment DB puisque c'est un Value Object
- * sérialisé en JSONB sur Scene.</p>
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class Room {
-
-    /** ID stable (UUID généré côté client). Sert de cible aux {@link RoomBranch}. */
-    private String id;
-
-    /** Nom de la pièce (« Antichambre », « Salle du trône »). */
-    private String name;
-
-    /** Narration / description lue ou résumée aux joueurs en entrant. */
-    private String description;
-
-    /** Énemis, créatures, boss éventuels (markdown libre). */
-    private String enemies;
-
-    /** Loot / récompenses présentes dans la pièce. */
-    private String loot;
-
-    /** Pièges / dangers environnementaux. */
-    private String traps;
-
-    /** Notes privées du MJ (cachées des joueurs). */
-    private String gmNotes;
-
-    /** Étage / niveau de la pièce. 0 = rez-de-chaussée. Nullable = pas d'étage défini. */
-    private Integer floor;
-
-    /** Ordre d'affichage dans la liste (au sein d'un même étage le cas échéant). */
-    private int order;
-
-    /** IDs d'images d'illustration / ambiance. */
-    @Builder.Default
-    private List<String> illustrationImageIds = new ArrayList<>();
-
-    /** ID de l'image « plan » de la pièce (1 image dédiée, schéma tactique). */
-    private String mapImageId;
-
-    /**
-     * Sorties vers d'autres pièces. {@link RoomBranch#targetRoomId()} doit pointer
-     * vers une Room de la même Scene.
-     */
-    @Builder.Default
-    private List<RoomBranch> branches = new ArrayList<>();
-}

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

@@ -1,22 +0,0 @@
-package com.loremind.domain.campaigncontext;
-
-/**
- * Sortie d'une pièce vers une autre pièce de la même Scene explorable.
- * Équivalent inter-pièces de {@link SceneBranch}.
- *
- * <p>Record Java immuable, sérialisé via Jackson dans la liste JSONB
- * {@code rooms} de la Scene.</p>
- *
- * <p>Règle métier : {@code targetRoomId} doit pointer vers une Room de la
- * MÊME Scene (validation côté service).</p>
- *
- * @param label         Libellé visible (« Porte nord », « Trappe au sol »).
- * @param targetRoomId  ID stable de la Room de destination (UUID Room.id).
- * @param condition     Condition optionnelle (« si les PJ ont la clé en argent »).
- */
-public record RoomBranch(String label, String targetRoomId, String condition) {
-
-    public static RoomBranch of(String label, String targetRoomId) {
-        return new RoomBranch(label, targetRoomId, null);
-    }
-}

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

@@ -72,15 +72,6 @@ public class Scene {
     @Builder.Default
     private List<SceneBranch> branches = new ArrayList<>();
 
-    /**
-     * Pièces du lieu explorable représenté par cette scène (donjon, crypte, manoir…).
-     * Vide => scène classique « beat narratif » (comportement inchangé).
-     * Non vide => la scène devient explorable, l'UI affiche un layout dédié pièce-par-pièce.
-     * Sérialisé en JSONB.
-     */
-    @Builder.Default
-    private List<Room> rooms = new ArrayList<>();
-
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
 }

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

@@ -1,16 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-/**
- * Erreur de domaine : l'import d'un PDF de campagne a échoué (PDF illisible,
- * Brain injoignable, LLM en erreur...).
- */
-public class CampaignImportException extends RuntimeException {
-
-    public CampaignImportException(String message) {
-        super(message);
-    }
-
-    public CampaignImportException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

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

@@ -1,32 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-import java.util.function.Consumer;
-
-/**
- * Port de sortie : produit des CONSEILS d'adaptation d'un PDF à une campagne
- * existante, streamés token par token. Délègue au Brain (LLM + extraction PDF).
- * <p>
- * Contrairement à {@link CampaignPdfImporter} (qui structure pour créer), ici la
- * sortie est du texte libre (markdown) : l'utilisateur applique à la main.
- */
-public interface CampaignPdfAdvisor {
-
-    /**
-     * @param pdfBytes contenu du PDF à adapter.
-     * @param filename nom d'origine (diagnostic ; peut être null).
-     * @param brief    description de la campagne existante (structure + PNJ + lore).
-     * @param messagesJson JSON de l'échange conversationnel ([{role, content}, …]) ;
-     *                     "[]" au 1er tour. Permet à l'utilisateur de répondre/corriger.
-     * @param onToken  invoqué à chaque fragment de texte généré.
-     * @param onComplete invoqué à la fin normale du flux.
-     * @param onError  invoqué en cas d'échec (PDF illisible, Brain/LLM en erreur).
-     */
-    void adviseStreaming(
-            byte[] pdfBytes,
-            String filename,
-            String brief,
-            String messagesJson,
-            Consumer<String> onToken,
-            Runnable onComplete,
-            Consumer<Throwable> onError);
-}

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

@@ -1,28 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-import com.loremind.domain.campaigncontext.CampaignImportProgress;
-import com.loremind.domain.campaigncontext.CampaignImportProposal;
-
-import java.util.function.Consumer;
-
-/**
- * Port de sortie : extrait et structure un PDF de campagne en arbre
- * arc → chapitre → scène. L'implémentation délègue au Brain Python.
- */
-public interface CampaignPdfImporter {
-
-    /**
-     * Variante streamée : l'import peut durer plusieurs minutes, on remonte
-     * l'avancement au fil de l'eau, puis la proposition finale.
-     *
-     * @param onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onDone     invoqué une fois avec l'arbre proposé (non persisté).
-     * @param onError    invoqué si l'extraction/structuration échoue.
-     */
-    void importCampaignStreaming(
-            byte[] pdfBytes,
-            String filename,
-            Consumer<CampaignImportProgress> onProgress,
-            Consumer<CampaignImportProposal> onDone,
-            Consumer<Throwable> onError);
-}

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

@@ -14,7 +14,7 @@ public interface CharacterRepository {
 
     Optional<Character> findById(String id);
 
-    List<Character> findByPlaythroughId(String playthroughId);
+    List<Character> findByCampaignId(String campaignId);
 
     void deleteById(String id);
 

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

@@ -1,36 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-import java.util.List;
-import java.util.function.Consumer;
-
-/**
- * Port de sortie : chat ANCRÉ (RAG) sur les sources d'un notebook, streamé.
- * Le Brain récupère les passages pertinents puis streame la réponse token par token.
- */
-public interface NotebookChatStreamer {
-
-    /** Un message de la conversation transmis au Brain. */
-    record Msg(String role, String content) {}
-
-    /** Avancement de l'analyse approfondie (lecture du document par lots). */
-    record Progress(int current, int total) {}
-
-    /**
-     * Streame la réponse ancrée sur les sources. Les callbacks sont invoqués au fil
-     * de l'eau : {@code onToken} par fragment, {@code onProgress} (mode approfondi
-     * uniquement) pendant la lecture du document, {@code onDone} à la fin,
-     * {@code onError} en cas d'échec.
-     *
-     * @param deep true = analyse approfondie (map-reduce sur tout le document) ;
-     *             false = chat RAG (top-k).
-     */
-    void stream(
-            List<String> sourceIds,
-            List<Msg> messages,
-            String context,
-            boolean deep,
-            Consumer<String> onToken,
-            Consumer<Progress> onProgress,
-            Runnable onDone,
-            Consumer<Throwable> onError);
-}

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

@@ -1,15 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-/**
- * Échec d'indexation/chat d'un notebook (Brain injoignable, erreur du modèle…).
- * Mappée en HTTP 502 par le contrôleur.
- */
-public class NotebookException extends RuntimeException {
-    public NotebookException(String message) {
-        super(message);
-    }
-
-    public NotebookException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

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

@@ -1,17 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-/**
- * Port de sortie : indexation RAG d'une source de notebook (déléguée au Brain).
- * Les vecteurs vivent côté Brain, keyés par {@code sourceId}.
- */
-public interface NotebookIndexer {
-
-    /** Récapitulatif d'indexation renvoyé par le Brain. */
-    record IndexResult(int chunks, int pageCount, int ocrPageCount) {}
-
-    /** Indexe une source (extraction + embeddings + stockage vectoriel). */
-    IndexResult index(String sourceId, byte[] pdfBytes, String filename);
-
-    /** Supprime les vecteurs d'une source (au DELETE d'une source/notebook). */
-    void delete(String sourceId);
-}

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

@@ -1,32 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-import com.loremind.domain.campaigncontext.Notebook;
-import com.loremind.domain.campaigncontext.NotebookMessage;
-import com.loremind.domain.campaigncontext.NotebookSource;
-
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Port de sortie pour la persistance des notebooks (atelier), de leurs sources
- * et de leur conversation. Port unique (3 agrégats liés) pour rester compact.
- */
-public interface NotebookRepository {
-
-    // --- Notebook ---
-    Notebook save(Notebook notebook);
-    Optional<Notebook> findById(String id);
-    List<Notebook> findByCampaignId(String campaignId);
-    void deleteById(String id);
-    boolean existsById(String id);
-
-    // --- Sources ---
-    NotebookSource saveSource(NotebookSource source);
-    Optional<NotebookSource> findSourceById(String id);
-    List<NotebookSource> findSourcesByNotebookId(String notebookId);
-    void deleteSourceById(String id);
-
-    // --- Messages (conversation) ---
-    NotebookMessage saveMessage(NotebookMessage message);
-    List<NotebookMessage> findMessagesByNotebookId(String notebookId);
-}

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

@@ -1,15 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-/**
- * Échec de génération/improvisation IA d'une table (Brain injoignable, erreur du
- * modèle, réponse inexploitable…). Mappée en HTTP 502 par le contrôleur.
- */
-public class RandomTableGenerationException extends RuntimeException {
-    public RandomTableGenerationException(String message) {
-        super(message);
-    }
-
-    public RandomTableGenerationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

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

@@ -1,26 +0,0 @@
-package com.loremind.domain.campaigncontext.ports;
-
-import com.loremind.domain.campaigncontext.RandomTableEntry;
-
-import java.util.List;
-
-/**
- * Port de sortie : génération IA d'une table aléatoire et improvisation narrative
- * sur un résultat tiré. Implémenté par un client du Brain (service IA Python).
- */
-public interface RandomTableGenerator {
-
-    /** Table proposée (non persistée) à partir d'une description + formule de dé. */
-    record GeneratedTable(String name, String description, List<RandomTableEntry> entries) {}
-
-    /**
-     * Génère une proposition de table couvrant la formule de dé, sur le sujet
-     * donné, en s'appuyant sur le contexte (campagne, système…) s'il est fourni.
-     */
-    GeneratedTable generate(String description, String diceFormula, String context);
-
-    /**
-     * Brode un court récit (2-3 phrases) sur un résultat tiré, pour lancer la scène.
-     */
-    String improvise(String tableName, String resultLabel, String resultDetail, String context);
-}

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

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

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

@@ -1,19 +0,0 @@
-package com.loremind.domain.gamesystemcontext;
-
-import java.util.List;
-
-/**
- * Évènement d'avancement émis pendant l'import streamé d'un PDF de règles.
- * <p>
- * {@code total} = nombre de morceaux à traiter (0 tant que l'extraction n'est
- * pas finie). {@code current} = morceaux déjà traités. {@code newSectionTitles}
- * = titres de sections nouvellement trouvés/complétés par le dernier morceau
- * (pour un affichage « au fil de l'eau »).
- */
-public record RulesImportProgress(
-        int current,
-        int total,
-        int pageCount,
-        int ocrPageCount,
-        List<String> newSectionTitles) {
-}

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

@@ -1,20 +0,0 @@
-package com.loremind.domain.gamesystemcontext;
-
-import java.util.Map;
-
-/**
- * Proposition de règles extraites d'un PDF, prête à être révisée par l'utilisateur.
- * <p>
- * {@code sections} associe un titre de section à son contenu markdown — aligné
- * sur le format {@link GameSystem#getRulesMarkdown()} (découpé par titres H2).
- * C'est une PROPOSITION : rien n'est persisté ; l'UI laisse l'utilisateur
- * réviser/éditer avant d'enregistrer le GameSystem.
- * <p>
- * {@code ocrPageCount} indique combien de pages ont nécessité l'OCR (scan) —
- * 0 = PDF born-digital (couche texte présente).
- */
-public record RulesImportResult(
-        Map<String, String> sections,
-        int pageCount,
-        int ocrPageCount) {
-}

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

@@ -1,17 +0,0 @@
-package com.loremind.domain.gamesystemcontext.ports;
-
-/**
- * Erreur de domaine : l'import d'un PDF de règles a échoué (PDF illisible,
- * Brain injoignable, LLM en erreur...). Les couches supérieures la traduisent
- * en réponse HTTP sans connaître l'adapter concret.
- */
-public class RulesImportException extends RuntimeException {
-
-    public RulesImportException(String message) {
-        super(message);
-    }
-
-    public RulesImportException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

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

@@ -1,39 +0,0 @@
-package com.loremind.domain.gamesystemcontext.ports;
-
-import com.loremind.domain.gamesystemcontext.RulesImportProgress;
-import com.loremind.domain.gamesystemcontext.RulesImportResult;
-
-import java.util.function.Consumer;
-
-/**
- * Port de sortie : extrait et structure les règles d'un PDF en sections.
- * <p>
- * L'implémentation (adapter) délègue au Brain Python (extraction texte + OCR +
- * structuration LLM). Le domaine ne connaît ni HTTP, ni le Brain, ni le LLM.
- */
-public interface RulesPdfImporter {
-
-    /**
-     * @param pdfBytes contenu binaire du PDF de règles.
-     * @param filename nom d'origine (diagnostic/logs ; peut être null).
-     * @return la proposition de sections (non persistée).
-     * @throws RulesImportException si l'extraction ou la structuration échoue.
-     */
-    RulesImportResult importRules(byte[] pdfBytes, String filename);
-
-    /**
-     * Variante streamée : l'import peut durer plusieurs minutes, on remonte
-     * l'avancement au fil de l'eau. Les callbacks sont invoqués depuis le thread
-     * d'exécution de l'adapter (synchrone jusqu'à {@code onDone}/{@code onError}).
-     *
-     * @param onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onDone     invoqué une fois avec le résultat final.
-     * @param onError    invoqué si l'extraction/structuration échoue.
-     */
-    void importRulesStreaming(
-            byte[] pdfBytes,
-            String filename,
-            Consumer<RulesImportProgress> onProgress,
-            Consumer<RulesImportResult> onDone,
-            Consumer<Throwable> onError);
-}

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

@@ -69,13 +69,12 @@ public record CampaignStructuralContext(
             List<SceneSummary> scenes) {
     }
 
-    /** Résumé d'une scène : nom + description courte + branches + pièces explorables. */
+    /** Résumé d'une scène : nom + description courte + branches narratives. */
     public record SceneSummary(
             String name,
             String description,
             int illustrationCount,
-            List<BranchHint> branches,
+            List<BranchHint> branches) {
-            List<RoomSummary> rooms) {
     }
 
     /**
@@ -87,27 +86,4 @@ public record CampaignStructuralContext(
      */
     public record BranchHint(String label, String targetSceneName, String condition) {
     }
-
-    /**
-     * Pièce d'un lieu explorable (donjon, crypte). Projection volontairement plate
-     * pour le prompt IA : pas de notes MJ (jamais leakées dans le contexte campagne),
-     * la narration et les ennemis suffisent à camper la pièce.
-     *
-     * @param name        Nom de la pièce.
-     * @param floor       Étage (nullable).
-     * @param description Narration courte.
-     * @param enemies     Ennemis (texte libre).
-     * @param branches    Sorties vers d'autres pièces (noms résolus).
-     */
-    public record RoomSummary(
-            String name,
-            Integer floor,
-            String description,
-            String enemies,
-            List<RoomBranchHint> branches) {
-    }
-
-    /** Indice d'une sortie entre pièces ; {@code targetRoomName} déjà résolu. */
-    public record RoomBranchHint(String label, String targetRoomName, String condition) {
-    }
 }

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

@@ -36,8 +36,7 @@ public record ChatRequest(
         PageContext pageContext,
         CampaignStructuralContext campaignContext,
         NarrativeEntityContext narrativeEntity,
-        GameSystemContext gameSystemContext,
+        GameSystemContext gameSystemContext) {
-        SessionContext sessionContext) {
 
     public static Builder builder() {
         return new Builder();
@@ -51,7 +50,6 @@ public record ChatRequest(
         private CampaignStructuralContext campaignContext;
         private NarrativeEntityContext narrativeEntity;
         private GameSystemContext gameSystemContext;
-        private SessionContext sessionContext;
 
         private Builder() {}
 
@@ -85,14 +83,9 @@ public record ChatRequest(
             return this;
         }
 
-        public Builder sessionContext(SessionContext sessionContext) {
-            this.sessionContext = sessionContext;
-            return this;
-        }
-
         public ChatRequest build() {
             return new ChatRequest(messages, loreContext, pageContext,
-                    campaignContext, narrativeEntity, gameSystemContext, sessionContext);
+                    campaignContext, narrativeEntity, gameSystemContext);
         }
     }
 }

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

@@ -1,58 +0,0 @@
-package com.loremind.domain.generationcontext;
-
-import java.time.LocalDateTime;
-import java.util.List;
-
-/**
- * Contexte structurel d'une Session de jeu — injecté dans le system prompt
- * de l'IA pour qu'elle ait conscience de la partie en cours et de son journal.
- *
- * <p>Pendant qu'une session se joue, l'IA reçoit en plus du Lore/Campagne/GameSystem :
- * le nom de la session, son statut, un résumé chronologique du journal,
- * et — depuis l'ajout du mode Hub — l'état des quêtes ouvertes de la campagne et
- * les flags actifs.</p>
- *
- * <p>Value Object du Generation Context — record Java immutable.</p>
- *
- * @param sessionName        Nom de la session courante telle qu'affichée au MJ.
- * @param active             True si la session est en cours, false si terminée.
- * @param startedAt          Horodatage de démarrage de la session courante.
- * @param entries            Entrées du journal de la session courante (cap côté builder).
- * @param previousEvents     Évènements marquants des sessions précédentes (continuité narrative).
- * @param availableQuests    Quêtes Hub actuellement débloquées et non démarrées.
- * @param inProgressQuests   Quêtes Hub en cours.
- * @param lockedQuestTitles  Titres des quêtes Hub verrouillées — uniquement le titre
- *                           pour signaler leur existence sans spoiler.
- * @param activeFlags        Noms des flags de campagne à true.
- */
-public record SessionContext(
-        String sessionName,
-        boolean active,
-        LocalDateTime startedAt,
-        List<JournalEntrySummary> entries,
-        List<JournalEntrySummary> previousEvents,
-        List<QuestSummary> availableQuests,
-        List<QuestSummary> inProgressQuests,
-        List<String> lockedQuestTitles,
-        List<String> activeFlags) {
-
-    /**
-     * Résumé d'une entrée de journal — type + contenu + horodatage + (optionnel) session source.
-     * {@code sourceSessionName} renseigné uniquement pour les évènements issus de sessions
-     * précédentes, pour aider l'IA à les ancrer temporellement.
-     */
-    public record JournalEntrySummary(
-            String type,
-            String content,
-            LocalDateTime occurredAt,
-            String sourceSessionName) {}
-
-    /**
-     * Résumé d'une quête (= Chapter dans un Arc HUB) telle qu'exposée à l'IA.
-     * On omet volontairement les notes MJ : pas de fuite côté prompt.
-     */
-    public record QuestSummary(
-            String name,
-            String arcName,
-            String description) {}
-}

core/src/main/java/com/loremind/domain/playcontext/EntryType.java

@@ -1,16 +0,0 @@
-package com.loremind.domain.playcontext;
-
-/**
- * Type d'entrée du journal de session.
- * Permet à l'UI de catégoriser visuellement la timeline (icône, couleur).
- */
-public enum EntryType {
-    /** Note libre du MJ (défaut). */
-    NOTE,
-    /** Moment marquant du scénario (combat gagné, décision majeure...). */
-    EVENT,
-    /** Jet de dés / test de caractéristique. */
-    DICE_ROLL,
-    /** Action déclarée par un joueur. */
-    PLAYER_ACTION
-}

core/src/main/java/com/loremind/domain/playcontext/Playthrough.java

@@ -1,36 +0,0 @@
-package com.loremind.domain.playcontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Instance jouée d'une Campagne par une table donnée.
- *
- * <p>Sépare clairement le SCÉNARIO (Campaign : arcs, chapitres, prérequis) de
- * l'ÉTAT DE JEU d'une table précise (progression des quêtes, flags narratifs,
- * sessions tenues, PJ). Permet à plusieurs tables de jouer la même campagne
- * indépendamment.</p>
- *
- * <p>Fait partie du Play Context. Référence la Campagne par weak reference
- * (campaignId) pour respecter les Bounded Contexts.</p>
- */
-@Data
-@Builder
-public class Playthrough {
-
-    private String id;
-
-    /** Weak reference vers la Campagne (le scénario joué). */
-    private String campaignId;
-
-    /** Nom donné par le MJ à cette partie (ex. : "Table du vendredi"). */
-    private String name;
-
-    /** Notes libres sur la partie / la table — facultatif. */
-    private String description;
-
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-}

core/src/main/java/com/loremind/domain/playcontext/QuestProgression.java

@@ -1,29 +0,0 @@
-package com.loremind.domain.playcontext;
-
-import com.loremind.domain.campaigncontext.ProgressionStatus;
-import lombok.Builder;
-import lombok.Data;
-
-/**
- * État de progression d'une quête (Chapter) pour un Playthrough donné.
- *
- * <p>Remplace l'ancien champ {@code Chapter.progressionStatus} qui mélangeait
- * le scénario et l'état de jeu : ici, la progression est exclusivement
- * propre à une instance jouée (Playthrough).</p>
- *
- * <p>Référence le Chapter par weak reference (chapterId) pour respecter les
- * Bounded Contexts. Le type {@link ProgressionStatus} reste défini dans
- * Campaign Context (c'est un Value Object générique, partageable).</p>
- *
- * <p>Sémantique : l'absence de ligne dans le repo équivaut à NOT_STARTED.
- * On ne persiste donc que les transitions explicites IN_PROGRESS / COMPLETED.</p>
- */
-@Data
-@Builder
-public class QuestProgression {
-
-    private String id;
-    private String playthroughId;
-    private String chapterId;
-    private ProgressionStatus status;
-}

core/src/main/java/com/loremind/domain/playcontext/Session.java

@@ -1,40 +0,0 @@
-package com.loremind.domain.playcontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Entité de domaine représentant une Session de jeu (une soirée).
- *
- * <p>Une Session appartient à un {@link Playthrough} (une instance jouée d'une
- * campagne par une table). Un Playthrough a typiquement plusieurs sessions
- * dans le temps ; la progression et les flags persistent entre elles via le
- * Playthrough parent.</p>
- *
- * <p>{@code endedAt == null} signifie que la session est en cours.
- * Une seule session peut être en cours dans l'application à la fois.</p>
- */
-@Data
-@Builder
-public class Session {
-
-    private String id;
-    private String name;
-
-    /** Weak reference vers le Playthrough parent. */
-    private String playthroughId;
-
-    private LocalDateTime startedAt;
-
-    /** Null = session en cours ; renseigné = session terminée. */
-    private LocalDateTime endedAt;
-
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-
-    public boolean isActive() {
-        return this.endedAt == null;
-    }
-}

core/src/main/java/com/loremind/domain/playcontext/SessionEntry.java

@@ -1,39 +0,0 @@
-package com.loremind.domain.playcontext;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/**
- * Entrée du journal d'une Session.
- * Représente un évènement horodaté capturé pendant ou après une partie :
- * note libre du MJ, évènement marquant, jet de dés, action de joueur.
- *
- * <p>Fait partie du Play Context. Référence la Session par weak reference
- * (sessionId) — l'orchestration en cascade est gérée par le service applicatif.</p>
- */
-@Data
-@Builder
-public class SessionEntry {
-
-    private String id;
-
-    /** Weak reference vers Session (intra-contexte mais reste découplée). */
-    private String sessionId;
-
-    private EntryType type;
-
-    /** Contenu texte brut saisi par le MJ. */
-    private String content;
-
-    /**
-     * Horodatage métier de l'évènement.
-     * Distinct de {@code createdAt} : utile si le MJ rédige a posteriori
-     * une note rétroactive sur quelque chose qui s'est passé plus tôt.
-     */
-    private LocalDateTime occurredAt;
-
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-}

core/src/main/java/com/loremind/domain/playcontext/ports/PlaythroughFlagRepository.java

@@ -1,20 +0,0 @@
-package com.loremind.domain.playcontext.ports;
-
-import java.util.Map;
-
-/**
- * Port de sortie pour les flags narratifs d'un Playthrough.
- *
- * <p>Anciennement {@code CampaignFlagRepository} : les flags suivent maintenant
- * une partie (Playthrough), pas un scénario (Campaign).</p>
- */
-public interface PlaythroughFlagRepository {
-
-    Map<String, Boolean> findByPlaythroughId(String playthroughId);
-
-    void setFlag(String playthroughId, String name, boolean value);
-
-    void deleteFlag(String playthroughId, String name);
-
-    void deleteAllByPlaythroughId(String playthroughId);
-}

core/src/main/java/com/loremind/domain/playcontext/ports/PlaythroughRepository.java

@@ -1,24 +0,0 @@
-package com.loremind.domain.playcontext.ports;
-
-import com.loremind.domain.playcontext.Playthrough;
-
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Port de sortie pour la persistance des Playthroughs (parties jouées).
- */
-public interface PlaythroughRepository {
-
-    Playthrough save(Playthrough playthrough);
-
-    Optional<Playthrough> findById(String id);
-
-    List<Playthrough> findByCampaignId(String campaignId);
-
-    List<Playthrough> findAll();
-
-    void deleteById(String id);
-
-    boolean existsById(String id);
-}

core/src/main/java/com/loremind/domain/playcontext/ports/QuestProgressionRepository.java

@@ -1,31 +0,0 @@
-package com.loremind.domain.playcontext.ports;
-
-import com.loremind.domain.campaigncontext.ProgressionStatus;
-import com.loremind.domain.playcontext.QuestProgression;
-
-import java.util.List;
-import java.util.Set;
-
-/**
- * Port de sortie pour la persistance des progressions de quêtes d'un Playthrough.
- *
- * <p>Modèle "absence = NOT_STARTED" : on ne stocke que les transitions
- * explicites IN_PROGRESS / COMPLETED.</p>
- */
-public interface QuestProgressionRepository {
-
-    /** Liste toutes les progressions explicites d'un Playthrough. */
-    List<QuestProgression> findByPlaythroughId(String playthroughId);
-
-    /** Set des IDs de chapitres en COMPLETED pour un Playthrough donné (fast path éval). */
-    Set<String> findCompletedChapterIdsByPlaythroughId(String playthroughId);
-
-    /**
-     * Crée ou met à jour le statut d'une quête pour un Playthrough.
-     * Si {@code status == NOT_STARTED}, la ligne est supprimée (sémantique "absence").
-     */
-    void setStatus(String playthroughId, String chapterId, ProgressionStatus status);
-
-    /** Supprime toutes les progressions d'un Playthrough (cascade applicative). */
-    void deleteAllByPlaythroughId(String playthroughId);
-}

core/src/main/java/com/loremind/domain/playcontext/ports/SessionEntryRepository.java

@@ -1,26 +0,0 @@
-package com.loremind.domain.playcontext.ports;
-
-import com.loremind.domain.playcontext.SessionEntry;
-
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Port de sortie pour la persistance des entrées de journal de session.
- */
-public interface SessionEntryRepository {
-
-    SessionEntry save(SessionEntry entry);
-
-    Optional<SessionEntry> findById(String id);
-
-    /** Renvoie les entrées d'une session, triées par occurredAt croissant (chronologique). */
-    List<SessionEntry> findBySessionId(String sessionId);
-
-    void deleteById(String id);
-
-    /** Supprime toutes les entrées d'une session — utilisé pour la cascade à la suppression. */
-    void deleteBySessionId(String sessionId);
-
-    boolean existsById(String id);
-}

core/src/main/java/com/loremind/domain/playcontext/ports/SessionRepository.java

@@ -1,30 +0,0 @@
-package com.loremind.domain.playcontext.ports;
-
-import com.loremind.domain.playcontext.Session;
-
-import java.util.List;
-import java.util.Optional;
-
-/**
- * Port de sortie pour la persistance des Sessions.
- */
-public interface SessionRepository {
-
-    Session save(Session session);
-
-    Optional<Session> findById(String id);
-
-    List<Session> findAll();
-
-    List<Session> findByPlaythroughId(String playthroughId);
-
-    /** Retourne UNE session active dans l'app (sémantique « legacy » — multi-actives possibles). */
-    Optional<Session> findActive();
-
-    /** Retourne la session active du Playthrough donné, s'il y en a une. */
-    Optional<Session> findActiveByPlaythroughId(String playthroughId);
-
-    void deleteById(String id);
-
-    boolean existsById(String id);
-}