changement de version

Correction de la configuration nginx pour ne pas bloquer un gros PDF
Ajout de 2 fonctionnalitées principales : import PDF que ce soit pour les règles ou les campagnes directement.
2026-06-04 14:14:19 +02:00 · 2026-06-04 14:13:41 +02:00 · 2026-06-04 13:55:27 +02:00 · 2026-06-03 15:56:26 +02:00 · 2026-06-03 15:44:48 +02:00 · 2026-05-20 14:59:26 +02:00
322 changed files with 11456 additions and 25962 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -108,4 +108,3 @@ docker-compose.override.yml
 # ============================================================================
 relay/
 scripts/bump-version.mjs
 brain/data/notebooks/5.json
--- a/brain/app/api/init.py
+++ b/brain/app/api/init.py
@@ -1,5 +0,0 @@
 """Adapter web (architecture hexagonale) : routers FastAPI, DTOs et factories DI.
 C'est la FRONTIÈRE HTTP du Brain : validation Pydantic, mapping DTO ↔ domaine,
 traduction des erreurs domaine → HTTP. Aucune logique métier ici.
 """
--- a/brain/app/api/chat_dto.py
+++ b/brain/app/api/chat_dto.py
@@ -1,215 +0,0 @@
 """DTOs Pydantic du chat contextuel — frontière HTTP avec le Core Java.
 C'est ici (et seulement ici, avec les autres modules de `app.api`) qu'on
 utilise Pydantic : le domaine ne voit que des dataclasses (voir chat_mapping).
 """
 from pydantic import BaseModel, Field
 class ChatMessageDTO(BaseModel):
    """Un message de la conversation. Rôles acceptés : user, assistant, system."""
    role: str = Field(pattern="^(user|assistant|system)$")
    content: str
 class PageSummaryDTO(BaseModel):
    """Résumé enrichi d'une page : identité + contenu + interconnexions.
    Depuis b9 : values/tags/related_page_titles sont optionnels côté JSON —
    le Core Java ne les sérialise que s'ils sont non-vides (payload léger
    pour un Lore avec beaucoup de pages vierges).
    """
    title: str
    template_name: str
    values: dict[str, str] = Field(default_factory=dict)
    tags: list[str] = Field(default_factory=list)
    related_page_titles: list[str] = Field(default_factory=list)
 class LoreContextDTO(BaseModel):
    """Carte structurelle du Lore avec contenu des pages (b9+)."""
    lore_name: str
    lore_description: str | None = None
    folders: dict[str, list[PageSummaryDTO]] = Field(default_factory=dict)
    tags: list[str] = Field(default_factory=list)
 class PageContextDTO(BaseModel):
    """Contexte d'une page spécifique pour focaliser le chat (optionnel)."""
    title: str
    template_name: str
    template_fields: list[str] = Field(default_factory=list)
    values: dict[str, str] = Field(default_factory=dict)
 class SceneBranchHintDTO(BaseModel):
    """Indice d'une branche narrative (le Core a deja resolu le nom cible)."""
    label: str
    target_scene_name: str
    condition: str | None = None
 class RoomBranchHintDTO(BaseModel):
    """Sortie d'une pièce vers une autre pièce du même lieu (donjon)."""
    label: str
    target_room_name: str
    condition: str | None = None
 class RoomSummaryDTO(BaseModel):
    """Pièce d'un lieu explorable. Omise par le Core si la scène est classique."""
    name: str
    floor: int | None = None
    description: str | None = None
    enemies: str | None = None
    branches: list[RoomBranchHintDTO] = Field(default_factory=list)
 class SceneSummaryDTO(BaseModel):
    """Résumé d'une scène : nom + description courte (synopsis)."""
    name: str
    description: str | None = None
    # Optionnel : le Core Java ne serialise illustration_count QUE si > 0
    # (payload plus leger). Defaut 0 = pas d'illustrations ou champ absent.
    illustration_count: int = 0
    # Branches narratives sortantes, omises cote Core si vides.
    branches: list[SceneBranchHintDTO] = Field(default_factory=list)
    # Pièces du lieu explorable, omises par Core si scène classique.
    rooms: list[RoomSummaryDTO] = Field(default_factory=list)
 class ChapterSummaryDTO(BaseModel):
    """Résumé d'un chapitre : nom + description courte + ses scènes."""
    name: str
    description: str | None = None
    scenes: list[SceneSummaryDTO] = Field(default_factory=list)
    illustration_count: int = 0
 class ArcSummaryDTO(BaseModel):
    """Résumé d'un arc narratif : nom + description courte + ses chapitres."""
    name: str
    description: str | None = None
    chapters: list[ChapterSummaryDTO] = Field(default_factory=list)
    illustration_count: int = 0
 class CharacterSummaryDTO(BaseModel):
    """Résumé d'un PJ : nom + snippet. Pas de fiche complète au niveau résumé."""
    name: str
    snippet: str = ""
 class NpcSummaryDTO(BaseModel):
    """Résumé d'un PNJ : symétrique à CharacterSummaryDTO."""
    name: str
    snippet: str = ""
 class CampaignContextDTO(BaseModel):
    """Carte narrative enrichie : arcs → chapitres → scènes avec synopsis."""
    campaign_name: str
    campaign_description: str | None = None
    arcs: list[ArcSummaryDTO] = Field(default_factory=list)
    characters: list[CharacterSummaryDTO] = Field(default_factory=list)
    npcs: list[NpcSummaryDTO] = Field(default_factory=list)
 class NarrativeEntityDTO(BaseModel):
    """Entité narrative (arc/chapter/scene/character) en cours d'édition — focus optionnel."""
    entity_type: str = Field(pattern="^(arc|chapter|scene|character|npc)$")
    title: str
    fields: dict[str, str] = Field(default_factory=dict)
 class GameSystemContextDTO(BaseModel):
    """Règles de JDR présélectionnées par le Core (filtrées par intent).
    Les sections sont un dict titre_H2 → contenu_markdown. Peuvent être
    vides si aucune section ne matchait l'intent de génération courant.
    """
    system_name: str
    system_description: str | None = None
    sections: dict[str, str] = Field(default_factory=dict)
 class JournalEntrySummaryDTO(BaseModel):
    """Une entrée du journal de session.
    `source_session_name` est présent uniquement pour les évènements issus
    des sessions précédentes — sert à ancrer temporellement dans le prompt.
    """
    type: str
    content: str
    occurred_at: str | None = None
    source_session_name: str | None = None
 class QuestSummaryDTO(BaseModel):
    """Résumé d'une quête (Chapter dans un Arc HUB). Voir QuestSummary côté domaine."""
    name: str
    arc_name: str
    description: str | None = None
 class SessionContextDTO(BaseModel):
    """Contexte d'une Session de jeu en cours (Play Context).
    Combine le journal complet (`entries`), les EVENTs des sessions précédentes
    (`previous_events`), et — depuis l'ajout du mode Hub — l'état des quêtes
    Hub de la campagne (disponibles / en cours / verrouillées) plus les flags
    narratifs actuellement actifs.
    """
    session_name: str
    active: bool
    started_at: str | None = None
    entries: list[JournalEntrySummaryDTO] = Field(default_factory=list)
    previous_events: list[JournalEntrySummaryDTO] = Field(default_factory=list)
    available_quests: list[QuestSummaryDTO] = Field(default_factory=list)
    in_progress_quests: list[QuestSummaryDTO] = Field(default_factory=list)
    locked_quest_titles: list[str] = Field(default_factory=list)
    active_flags: list[str] = Field(default_factory=list)
 class ChatStreamRequestDTO(BaseModel):
    """Requête de chat streamé : historique + contextes structurels.
    Les contextes (lore, page, campaign, narrative_entity, session) sont
    optionnels, mais au moins l'un des contextes "racines" (lore_context,
    campaign_context ou session_context) doit être fourni. Le validateur
    `check_scope` applique cette règle à la frontière HTTP.
    """
    messages: list[ChatMessageDTO] = Field(min_length=1)
    lore_context: LoreContextDTO | None = None
    page_context: PageContextDTO | None = None
    campaign_context: CampaignContextDTO | None = None
    narrative_entity: NarrativeEntityDTO | None = None
    game_system_context: GameSystemContextDTO | None = None
    session_context: SessionContextDTO | None = None
    def has_scope(self) -> bool:
        """Vrai si au moins un contexte racine (Lore, Campagne ou Session) est fourni."""
        return (
            self.lore_context is not None
            or self.campaign_context is not None
            or self.session_context is not None
        )
--- a/brain/app/api/chat_mapping.py
+++ b/brain/app/api/chat_mapping.py
@@ -1,192 +0,0 @@
 """Mapping DTO → domaine (couche anti-corruption de la frontière HTTP).
 Traduit les DTOs Pydantic du chat contextuel en dataclasses du domaine :
 le cœur métier ne dépend ainsi jamais de Pydantic ni du format JSON du Core.
 """
 from app.api.chat_dto import (
    CampaignContextDTO,
    GameSystemContextDTO,
    JournalEntrySummaryDTO,
    LoreContextDTO,
    NarrativeEntityDTO,
    PageContextDTO,
    PageSummaryDTO,
    QuestSummaryDTO,
    SessionContextDTO,
 )
 from app.domain.models import (
    ArcSummary,
    CampaignStructuralContext,
    ChapterSummary,
    CharacterSummary,
    GameSystemContext,
    JournalEntrySummary,
    LoreStructuralContext,
    NarrativeEntityContext,
    NpcSummary,
    PageContext,
    PageSummary,
    QuestSummary,
    RoomBranchHint,
    RoomSummary,
    SceneBranchHint,
    SceneSummary,
    SessionContext,
 )
 def to_lore_context(dto: LoreContextDTO | None) -> LoreStructuralContext | None:
    if dto is None:
        return None
    return LoreStructuralContext(
        lore_name=dto.lore_name,
        lore_description=dto.lore_description,
        folders={
            folder: [_to_page_summary(p) for p in pages]
            for folder, pages in dto.folders.items()
        },
        tags=dto.tags,
    )
 def _to_page_summary(dto: PageSummaryDTO) -> PageSummary:
    return PageSummary(
        title=dto.title,
        template_name=dto.template_name,
        values=dict(dto.values),
        tags=list(dto.tags),
        related_page_titles=list(dto.related_page_titles),
    )
 def to_page_context(dto: PageContextDTO | None) -> PageContext | None:
    if dto is None:
        return None
    return PageContext(
        title=dto.title,
        template_name=dto.template_name,
        template_fields=dto.template_fields,
        values=dto.values,
    )
 def to_campaign_context(dto: CampaignContextDTO | None) -> CampaignStructuralContext | None:
    if dto is None:
        return None
    arcs = [
        ArcSummary(
            name=arc.name,
            description=arc.description,
            illustration_count=arc.illustration_count,
            chapters=[
                ChapterSummary(
                    name=ch.name,
                    description=ch.description,
                    illustration_count=ch.illustration_count,
                    scenes=[
                        SceneSummary(
                            name=sc.name,
                            description=sc.description,
                            illustration_count=sc.illustration_count,
                            branches=[
                                SceneBranchHint(
                                    label=br.label,
                                    target_scene_name=br.target_scene_name,
                                    condition=br.condition,
                                )
                                for br in sc.branches
                            ],
                            rooms=[
                                RoomSummary(
                                    name=room.name,
                                    floor=room.floor,
                                    description=room.description,
                                    enemies=room.enemies,
                                    branches=[
                                        RoomBranchHint(
                                            label=rb.label,
                                            target_room_name=rb.target_room_name,
                                            condition=rb.condition,
                                        )
                                        for rb in room.branches
                                    ],
                                )
                                for room in sc.rooms
                            ],
                        )
                        for sc in ch.scenes
                    ],
                )
                for ch in arc.chapters
            ],
        )
        for arc in dto.arcs
    ]
    characters = [
        CharacterSummary(name=c.name, snippet=c.snippet)
        for c in dto.characters
    ]
    npcs = [
        NpcSummary(name=n.name, snippet=n.snippet)
        for n in dto.npcs
    ]
    return CampaignStructuralContext(
        campaign_name=dto.campaign_name,
        campaign_description=dto.campaign_description,
        arcs=arcs,
        characters=characters,
        npcs=npcs,
    )
 def to_narrative_entity(dto: NarrativeEntityDTO | None) -> NarrativeEntityContext | None:
    if dto is None:
        return None
    return NarrativeEntityContext(
        entity_type=dto.entity_type,
        title=dto.title,
        fields=dict(dto.fields),
    )
 def to_game_system_context(dto: GameSystemContextDTO | None) -> GameSystemContext | None:
    if dto is None:
        return None
    return GameSystemContext(
        system_name=dto.system_name,
        system_description=dto.system_description,
        sections=dict(dto.sections),
    )
 def to_session_context(dto: SessionContextDTO | None) -> SessionContext | None:
    if dto is None:
        return None
    return SessionContext(
        session_name=dto.session_name,
        active=dto.active,
        started_at=dto.started_at,
        entries=[_to_journal_entry(e) for e in dto.entries],
        previous_events=[_to_journal_entry(e) for e in dto.previous_events],
        available_quests=[_to_quest_summary(q) for q in dto.available_quests],
        in_progress_quests=[_to_quest_summary(q) for q in dto.in_progress_quests],
        locked_quest_titles=list(dto.locked_quest_titles),
        active_flags=list(dto.active_flags),
    )
 def _to_quest_summary(dto: QuestSummaryDTO) -> QuestSummary:
    return QuestSummary(
        name=dto.name,
        arc_name=dto.arc_name,
        description=dto.description,
    )
 def _to_journal_entry(dto: JournalEntrySummaryDTO) -> JournalEntrySummary:
    return JournalEntrySummary(
        type=dto.type,
        content=dto.content,
        occurred_at=dto.occurred_at,
        source_session_name=dto.source_session_name,
    )
--- a/brain/app/api/common.py
+++ b/brain/app/api/common.py
@@ -1,26 +0,0 @@
 """Utilitaires partagés des routers : encodage SSE + garde-fous d'upload PDF."""
 from __future__ import annotations
 import json
 # Garde-fou taille : un livre de règles dépasse rarement quelques dizaines de Mo.
 # Au-delà, on refuse (probable erreur d'upload) plutôt que d'OOM le conteneur.
 MAX_PDF_BYTES = 60 * 1024 * 1024  # 60 Mo
 def sse_event(event: str, data: dict) -> str:
    """Encode un évènement Server-Sent Events (accents préservés)."""
    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
 def pdf_upload_error(content: bytes) -> str | None:
    """Message d'erreur si l'upload PDF est invalide (vide / trop gros), sinon None.
    Utilisé par les flux SSE, où l'erreur doit partir en évènement `error`
    plutôt qu'en HTTPException (le flux est déjà ouvert en 200).
    """
    if not content:
        return "Fichier PDF vide."
    if len(content) > MAX_PDF_BYTES:
        return f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo)."
    return None
--- a/brain/app/api/deps.py
+++ b/brain/app/api/deps.py
@@ -1,191 +0,0 @@
 """Factories d'injection de dépendance — le point d'inversion de l'hexagone.
 C'est ICI (et seulement ici) qu'on choisit QUEL adapter concret incarne chaque
 port (LLM, embeddings, extracteur PDF), en fonction des Settings — modifiables
 à chaud depuis l'écran Paramètres de l'UI. Les routers ne connaissent que les
 ports et les use cases, jamais Ollama/Mistral/etc.
 """
 import logging
 from typing import Annotated
 from fastapi import Depends, HTTPException
 from app.application.adapt_campaign import AdaptCampaignUseCase
 from app.application.chat import ChatUseCase
 from app.application.embeddings import EmbeddingError
 from app.application.generate_page import GeneratePageUseCase
 from app.application.import_campaign import ImportCampaignUseCase
 from app.application.import_rules import ImportRulesUseCase
 from app.application.notebook_chat import NotebookChatUseCase
 from app.application.notebook_deep import NotebookDeepUseCase
 from app.application.notebook_rag import NotebookRagUseCase
 from app.core.config import Settings, get_settings
 from app.domain.ports import LLMProvider, LLMProviderError
 from app.infrastructure.gemini_adapter import GeminiLLMProvider
 from app.infrastructure.mistral_adapter import MistralLLMProvider
 from app.infrastructure.mistral_embedding_adapter import MistralEmbeddingProvider
 from app.infrastructure.ollama_adapter import OllamaLLMProvider
 from app.infrastructure.ollama_embedding_adapter import OllamaEmbeddingProvider
 from app.infrastructure.onemin_adapter import OneMinAiLLMProvider
 from app.infrastructure.openrouter_adapter import OpenRouterLLMProvider
 from app.infrastructure.pdf_extractor import PyMuPdfTextExtractor
 logger = logging.getLogger(__name__)
 # Extracteur PDF partagé : la détection OCR (version Tesseract) a un coût
 # (subprocess) qu'on ne veut pas payer à chaque requête → singleton module.
 _PDF_EXTRACTOR = PyMuPdfTextExtractor()
 def _effective_import_chunk_tokens(settings: Settings) -> int:
    """Taille de morceau réellement utilisable pour l'import.
    Avec Ollama, le morceau (entrée) ET sa réécriture en sections (sortie ≈ même
    taille) doivent tenir ensemble dans `num_ctx` — sinon Ollama remplit la fenêtre
    avec le prompt et la génération s'arrête après quelques tokens (JSON coupé net,
    morceau perdu). Budget : entrée×~1.3 (les morceaux sont mesurés en tokens
    cl100k, plus compacts que les tokenizers locaux) + consignes + sortie×~1.4
    ≤ num_ctx  →  morceau ≤ (num_ctx − 800) / 2.7. On plafonne, avec un log pour
    rester transparent. Les providers cloud (gros contexte) ne sont pas plafonnés.
    """
    requested = settings.import_chunk_tokens
    if settings.llm_provider != "ollama":
        return requested
    cap = max(1000, int((settings.llm_num_ctx - 800) / 2.7))
    if requested > cap:
        logger.warning(
            "Taille de morceau d'import réduite de %s à %s tokens : avec num_ctx=%s, "
            "un morceau plus gros ne laisserait pas la place à la sortie du modèle "
            "(génération coupée). Augmentez num_ctx pour utiliser de plus gros morceaux.",
            requested, cap, settings.llm_num_ctx,
        )
        return cap
    return requested
 def get_llm_provider(
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> LLMProvider:
    """Factory d'adapter — point d'inversion de dépendance.
    C'est ici (et uniquement ici) qu'on choisit QUEL adapter concret
    incarne le port, en fonction du champ `llm_provider` des Settings
    (modifiable a chaud depuis l'ecran Parametres de l'UI).
    """
    try:
        if settings.llm_provider == "onemin":
            return OneMinAiLLMProvider(settings)
        if settings.llm_provider == "openrouter":
            return OpenRouterLLMProvider(settings)
        if settings.llm_provider == "mistral":
            return MistralLLMProvider(settings)
        if settings.llm_provider == "gemini":
            return GeminiLLMProvider(settings)
        return OllamaLLMProvider(settings)
    except LLMProviderError as exc:
        # Ex : cle 1min.ai manquante. On renvoie du 400 plutot que du 500
        # pour que le frontend puisse afficher un message actionnable.
        raise HTTPException(status_code=400, detail=str(exc)) from exc
 def get_generate_page_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> GeneratePageUseCase:
    """Factory du use case — injecte le port LLMProvider sans connaître l'adapter."""
    return GeneratePageUseCase(llm=llm)
 def get_chat_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> ChatUseCase:
    """Factory du use case chat.
    L'adapter OllamaLLMProvider satisfait les deux protocoles (LLMProvider
    et LLMChatProvider) par duck typing ; on lui passe la même instance.
    """
    return ChatUseCase(llm=llm)  # type: ignore[arg-type]
 def get_import_rules_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> ImportRulesUseCase:
    """Factory du use case d'import de règles PDF (extraction + structuration)."""
    # Modèle LOCAL → mode segmentation : le LLM ne renvoie que les frontières des
    # sections (~200 tokens) et le texte original est découpé localement. Réécrire
    # tout le contenu à ~100 tokens/s prendrait des dizaines de minutes par livre.
    # Les providers cloud (rapides, grand contexte) gardent la réécriture nettoyée.
    return ImportRulesUseCase(
        llm=llm, extractor=_PDF_EXTRACTOR,
        chunk_target_tokens=_effective_import_chunk_tokens(settings),
        segment_only=settings.llm_provider == "ollama")
 def get_import_campaign_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> ImportCampaignUseCase:
    """Factory du use case d'import de campagne PDF (extraction + arborescence)."""
    return ImportCampaignUseCase(
        llm=llm,
        extractor=_PDF_EXTRACTOR,
        chunk_target_tokens=_effective_import_chunk_tokens(settings),
        map_concurrency=settings.llm_map_concurrency,
    )
 def get_adapt_campaign_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> AdaptCampaignUseCase:
    """Factory du use case d'adaptation d'un PDF à une campagne (conseils streamés)."""
    # L'adapter satisfait aussi LLMChatProvider (stream_chat) par duck typing.
    # Budget d'entrée = taille de morceau configurée (qui passe déjà côté provider).
    return AdaptCampaignUseCase(  # type: ignore[arg-type]
        llm=llm, extractor=_PDF_EXTRACTOR, max_input_tokens=settings.import_chunk_tokens)
 def get_embedding_provider(
    settings: Annotated[Settings, Depends(get_settings)],
 ):
    """Factory de l'adapter d'embeddings (RAG) selon `embedding_provider`."""
    try:
        if settings.embedding_provider == "mistral":
            return MistralEmbeddingProvider(settings)
        return OllamaEmbeddingProvider(settings)
    except EmbeddingError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
 def get_notebook_rag_use_case(
    embedder: Annotated[object, Depends(get_embedding_provider)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> NotebookRagUseCase:
    return NotebookRagUseCase(
        extractor=_PDF_EXTRACTOR,
        embedder=embedder,  # type: ignore[arg-type]
        min_score=settings.rag_min_score,
    )
 def get_notebook_chat_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    rag: Annotated[NotebookRagUseCase, Depends(get_notebook_rag_use_case)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> NotebookChatUseCase:
    return NotebookChatUseCase(
        rag=rag, llm=llm, rerank_enabled=settings.rag_rerank)  # type: ignore[arg-type]
 def get_notebook_deep_use_case(
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
    embedder: Annotated[object, Depends(get_embedding_provider)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> NotebookDeepUseCase:
    return NotebookDeepUseCase(
        llm=llm,
        batch_tokens=settings.import_chunk_tokens,
        map_concurrency=settings.llm_map_concurrency,
        embedder=embedder,
        summary_filter=settings.deep_summary_filter,
    )
--- a/brain/app/api/routers/init.py
+++ b/brain/app/api/routers/init.py
@@ -1,5 +0,0 @@
 """Routers FastAPI du Brain, un par responsabilité métier.
 Chemins inchangés par rapport à l'ancien main.py monolithique : le Core Java
 et le frontend ne voient AUCUNE différence.
 """
--- a/brain/app/api/routers/chat.py
+++ b/brain/app/api/routers/chat.py
@@ -1,119 +0,0 @@
 """Endpoint du chat contextuel (/chat/stream) : Structural Context + jauge tokens."""
 import json
 from typing import Annotated, AsyncIterator
 import tiktoken
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import StreamingResponse
 from app.api.chat_dto import ChatStreamRequestDTO
 from app.api.chat_mapping import (
    to_campaign_context,
    to_game_system_context,
    to_lore_context,
    to_narrative_entity,
    to_page_context,
    to_session_context,
 )
 from app.api.deps import get_chat_use_case
 from app.application.chat import ChatUseCase
 from app.core.config import get_settings
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError
 router = APIRouter()
 # Encodeur tiktoken partagé — chargé une fois pour éviter le coût de lookup
 # à chaque requête. On utilise cl100k_base (GPT-3.5/4) comme tokenizer
 # universel approximatif : ±10% d'écart avec Llama/Gemma mais largement
 # suffisant pour une jauge visuelle à l'utilisateur.
 _TOKEN_ENCODER: tiktoken.Encoding | None = None
 def _count_tokens(text: str | None) -> int:
    """Compte les tokens d'un texte via tiktoken. Null/empty → 0."""
    if not text:
        return 0
    global _TOKEN_ENCODER
    if _TOKEN_ENCODER is None:
        _TOKEN_ENCODER = tiktoken.get_encoding("cl100k_base")
    return len(_TOKEN_ENCODER.encode(text))
@router.post("/chat/stream")
 async def chat_stream(
    body: ChatStreamRequestDTO,
    use_case: Annotated[ChatUseCase, Depends(get_chat_use_case)],
 ) -> StreamingResponse:
    """Chat streamé (Server-Sent Events) avec Structural Context.
    Accepte jusqu'à 4 contextes optionnels (Lore, Page focalisée, Campagne,
    entité narrative focalisée). Au moins un contexte racine (Lore ou
    Campagne) est requis pour que la requête ait du sens.
    Format de flux :
      - Chaque token : `data: {"token": "..."}\\n\\n`
      - Fin normale  : `event: done\\ndata: {}\\n\\n`
      - Erreur LLM   : `event: error\\ndata: {"message": "..."}\\n\\n`
    """
    if not body.has_scope():
        raise HTTPException(
            status_code=422,
            detail="Au moins un des deux contextes racines (lore_context ou campaign_context) est requis.",
        )
    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
    lore_context = to_lore_context(body.lore_context)
    page_context = to_page_context(body.page_context)
    campaign_context = to_campaign_context(body.campaign_context)
    narrative_entity = to_narrative_entity(body.narrative_entity)
    game_system_context = to_game_system_context(body.game_system_context)
    session_context = to_session_context(body.session_context)
    # --- Comptage tokens pour la jauge de contexte frontend ---
    # On construit le system prompt une fois ici pour le compter — le use case
    # le reconstruira à l'identique en interne (coût négligeable : concat de str).
    # Cette duplication évite de complexifier le contrat stream() avec un
    # paramètre optionnel system_prompt précalculé.
    system_prompt_preview = use_case.build_system_prompt(
        lore_context=lore_context,
        page_context=page_context,
        campaign_context=campaign_context,
        narrative_entity=narrative_entity,
        game_system_context=game_system_context,
        session_context=session_context,
    )
    # Dernier message = "current" (souvent user), le reste = historique accumulé.
    current_msg = messages[-1] if messages else None
    history_msgs = messages[:-1] if messages else []
    settings = get_settings()
    usage_payload = {
        "system": _count_tokens(system_prompt_preview),
        "history": sum(_count_tokens(m.content) for m in history_msgs),
        "current": _count_tokens(current_msg.content) if current_msg else 0,
        # Plafond connu seulement pour Ollama (num_ctx). Pour le cloud (1min/OpenRouter)
        # on ne connaît pas la fenêtre réelle → 0 = "pas de max" (jauge sans dénominateur).
        "max": settings.llm_num_ctx if settings.llm_provider == "ollama" else 0,
    }
    async def event_stream() -> AsyncIterator[str]:
        # Event 'usage' émis en tout premier : le frontend peut afficher la
        # jauge avant même le premier token de réponse.
        yield f"event: usage\ndata: {json.dumps(usage_payload, ensure_ascii=False)}\n\n"
        try:
            async for token in use_case.stream(
                messages,
                lore_context=lore_context,
                page_context=page_context,
                campaign_context=campaign_context,
                narrative_entity=narrative_entity,
                game_system_context=game_system_context,
                session_context=session_context,
            ):
                # json.dumps avec ensure_ascii=False pour préserver les accents
                yield f"data: {json.dumps({'token': token}, ensure_ascii=False)}\n\n"
            yield "event: done\ndata: {}\n\n"
        except LLMProviderError as exc:
            yield f"event: error\ndata: {json.dumps({'message': str(exc)})}\n\n"
    return StreamingResponse(event_stream(), media_type="text/event-stream")
--- a/brain/app/api/routers/generation.py
+++ b/brain/app/api/routers/generation.py
@@ -1,137 +0,0 @@
 """Endpoints de génération « simple » : prompt libre, page de Lore, auto-titre."""
 from typing import Annotated, Literal
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
 from app.api.deps import get_generate_page_use_case, get_llm_provider
 from app.application.generate_page import GeneratePageUseCase
 from app.core.config import Settings, get_settings
 from app.domain.models import PageGenerationContext
 from app.domain.ports import LLMProvider, LLMProviderError
 router = APIRouter()
 class GenerateRequest(BaseModel):
    prompt: str
 class GenerateResponse(BaseModel):
    model: str
    response: str
@router.post("/generate", response_model=GenerateResponse)
 async def generate(
    body: GenerateRequest,
    settings: Annotated[Settings, Depends(get_settings)],
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> GenerateResponse:
    """Endpoint libre : prompt → texte brut. Utile pour debug et exploration."""
    try:
        text = await llm.generate(body.prompt)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return GenerateResponse(model=settings.llm_model, response=text)
 class GeneratePageRequestDTO(BaseModel):
    """Contexte envoyé par le Core Java pour remplir une page via le LLM."""
    lore_name: str
    folder_name: str
    template_name: str
    template_fields: list[str] = Field(min_length=1)
    page_title: str
    lore_description: str | None = None
 class GeneratePageResponseDTO(BaseModel):
    """Retour : une valeur textuelle par champ du template (clé = field name)."""
    values: dict[str, str]
@router.post("/generate-page", response_model=GeneratePageResponseDTO)
 async def generate_page(
    body: GeneratePageRequestDTO,
    use_case: Annotated[
        GeneratePageUseCase, Depends(get_generate_page_use_case)
    ],
 ) -> GeneratePageResponseDTO:
    """Endpoint métier : contexte LoreMind → valeurs structurées par champ.
    Branche tout le use case `GeneratePageUseCase`. Ce controller ne fait
    que le mapping DTO ↔ dataclass et la traduction d'erreur domaine → HTTP.
    """
    context = PageGenerationContext(
        lore_name=body.lore_name,
        lore_description=body.lore_description,
        folder_name=body.folder_name,
        template_name=body.template_name,
        template_fields=body.template_fields,
        page_title=body.page_title,
    )
    try:
        result = await use_case.execute(context)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return GeneratePageResponseDTO(values=result.values)
 # --- Auto-titre d'une conversation persistee --------------------------------
 class SummarizeTitleMessageDTO(BaseModel):
    role: Literal["user", "assistant", "system"]
    content: str
 class SummarizeTitleRequestDTO(BaseModel):
    """Premiers messages d'une conversation pour auto-generer un titre court."""
    messages: list[SummarizeTitleMessageDTO] = Field(default_factory=list)
 class SummarizeTitleResponseDTO(BaseModel):
    title: str
 _TITLE_SYSTEM_PROMPT = (
    "Tu generes un titre court (4 a 7 mots max) qui resume le sujet de la "
    "conversation ci-dessous. Reponds UNIQUEMENT par le titre, sans guillemets, "
    "sans ponctuation finale, sans prefixe type 'Titre :'. Le titre doit etre "
    "en francais et capturer le sujet metier (pas 'Conversation IA')."
 )
@router.post("/summarize/conversation-title", response_model=SummarizeTitleResponseDTO)
 async def summarize_conversation_title(
    body: SummarizeTitleRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> SummarizeTitleResponseDTO:
    """Genere un titre court a partir des premiers echanges de la conversation.
    Appele par le core apres le 1er couple user/assistant, pour remplacer le
    titre provisoire "Nouvelle conversation" par quelque chose de parlant.
    """
    if not body.messages:
        raise HTTPException(status_code=422, detail="Au moins un message requis")
    transcript = "\n".join(f"{m.role.upper()}: {m.content}" for m in body.messages[:6])
    prompt = f"{_TITLE_SYSTEM_PROMPT}\n\nConversation :\n{transcript}\n\nTitre :"
    try:
        raw = await llm.generate(prompt)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    title = raw.strip().splitlines()[0].strip().strip('"').strip("'").rstrip(".")
    if len(title) > 80:
        title = title[:80].rstrip()
    if not title:
        title = "Nouvelle conversation"
    return SummarizeTitleResponseDTO(title=title)
--- a/brain/app/api/routers/imports.py
+++ b/brain/app/api/routers/imports.py
@@ -1,184 +0,0 @@
 """Endpoints d'import/adaptation de PDF (règles, campagne) — REST + flux SSE."""
 import json
 import logging
 from typing import Annotated, AsyncIterator
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from app.api.common import MAX_PDF_BYTES, pdf_upload_error, sse_event
 from app.api.deps import (
    get_adapt_campaign_use_case,
    get_import_campaign_use_case,
    get_import_rules_use_case,
 )
 from app.application.adapt_campaign import AdaptCampaignUseCase
 from app.application.import_campaign import ImportCampaignUseCase
 from app.application.import_rules import ImportRulesUseCase
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError, PdfExtractionError
 logger = logging.getLogger(__name__)
 router = APIRouter()
 class RulesImportResponseDTO(BaseModel):
    """Proposition de sections de règles extraites d'un PDF.
    `sections` = {titre → contenu markdown}. C'est une PROPOSITION : le Core
    et l'UI laissent l'utilisateur réviser/éditer avant toute persistance.
    `ocr_page_count` permet d'indiquer si le PDF était un scan (OCR utilisé).
    """
    sections: dict[str, str]
    page_count: int
    ocr_page_count: int
@router.post("/import/rules", response_model=RulesImportResponseDTO)
 async def import_rules(
    use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
    file: UploadFile = File(...),
 ) -> RulesImportResponseDTO:
    """Import d'un PDF de règles → sections markdown structurées (proposition).
    Extrait le texte (couche texte + repli OCR par page pour les scans), découpe,
    et demande au LLM de répartir les règles en sections thématiques. Ne persiste
    rien : renvoie la proposition au Core, qui la présente pour révision.
    """
    content = await file.read()
    if not content:
        raise HTTPException(status_code=422, detail="Fichier PDF vide.")
    if len(content) > MAX_PDF_BYTES:
        raise HTTPException(
            status_code=413,
            detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).",
        )
    try:
        result = await use_case.execute(content)
    except PdfExtractionError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return RulesImportResponseDTO(
        sections=result.sections,
        page_count=result.page_count,
        ocr_page_count=result.ocr_page_count,
    )
@router.post("/import/rules/stream")
 async def import_rules_stream(
    use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
    file: UploadFile = File(...),
 ) -> StreamingResponse:
    """Import streamé : émet l'avancement (SSE) puis le résultat final.
    Évènements SSE :
      - `event: extracting`  → data: {}                    (extraction en cours)
      - `event: start`       → data: {page_count, ocr_page_count, total}
      - `event: progress`    → data: {current, total, new_sections:[...]}
      - `event: done`        → data: {sections, page_count, ocr_page_count}
      - `event: error`       → data: {message}
    """
    content = await file.read()
    async def event_stream() -> AsyncIterator[str]:
        upload_error = pdf_upload_error(content)
        if upload_error:
            yield sse_event("error", {"message": upload_error})
            return
        try:
            async for ev in use_case.stream(content):
                event_type = ev.pop("type")
                yield sse_event(event_type, ev)
        except PdfExtractionError as exc:
            yield sse_event("error", {"message": str(exc)})
        except LLMProviderError as exc:
            yield sse_event("error", {"message": str(exc)})
        except Exception as exc:  # noqa: BLE001 — filet : une erreur inattendue ne doit
            # PAS casser le flux SSE brutalement (sinon le Core n'a qu'un message générique
            # sans détail). On la transforme en évènement `error` propre + log avec trace.
            logger.exception("Import règles : erreur inattendue dans le flux.")
            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
    return StreamingResponse(event_stream(), media_type="text/event-stream")
@router.post("/import/campaign/stream")
 async def import_campaign_stream(
    use_case: Annotated[ImportCampaignUseCase, Depends(get_import_campaign_use_case)],
    file: UploadFile = File(...),
 ) -> StreamingResponse:
    """Import streamé d'un PDF de campagne → arbre arc→chapitre→scène (SSE).
    Évènements : `extracting`, `start` {page_count, ocr_page_count, total},
    `progress` {current, total, arc_count, chapter_count, scene_count},
    `done` {arcs:[...], page_count, ocr_page_count}, `error` {message}.
    """
    content = await file.read()
    async def event_stream() -> AsyncIterator[str]:
        upload_error = pdf_upload_error(content)
        if upload_error:
            yield sse_event("error", {"message": upload_error})
            return
        try:
            async for ev in use_case.stream(content):
                event_type = ev.pop("type")
                yield sse_event(event_type, ev)
        except PdfExtractionError as exc:
            yield sse_event("error", {"message": str(exc)})
        except LLMProviderError as exc:
            yield sse_event("error", {"message": str(exc)})
        except Exception as exc:  # noqa: BLE001 — voir import règles : on ne laisse pas
            # une erreur inattendue casser le flux sans détail.
            logger.exception("Import campagne : erreur inattendue dans le flux.")
            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
    return StreamingResponse(event_stream(), media_type="text/event-stream")
@router.post("/adapt/campaign/stream")
 async def adapt_campaign_stream(
    use_case: Annotated[AdaptCampaignUseCase, Depends(get_adapt_campaign_use_case)],
    file: UploadFile = File(...),
    brief: str = Form(""),
    messages: str = Form("[]"),
 ) -> StreamingResponse:
    """Adaptation CONVERSATIONNELLE d'un PDF à une campagne (SSE markdown).
    `brief` = description de la campagne (Core). `messages` = JSON de l'échange
    ([{role, content}, …]) ; vide au 1er tour. Évènements : `token`, `done`, `error`.
    """
    content = await file.read()
    try:
        raw_messages = json.loads(messages) if messages else []
    except json.JSONDecodeError:
        raw_messages = []
    convo = [
        ChatMessage(role=str(m.get("role", "user")), content=str(m.get("content", "")))
        for m in raw_messages
        if isinstance(m, dict) and str(m.get("content", "")).strip()
    ]
    async def event_stream() -> AsyncIterator[str]:
        upload_error = pdf_upload_error(content)
        if upload_error:
            yield sse_event("error", {"message": upload_error})
            return
        try:
            async for token in use_case.stream(content, brief, convo):
                yield sse_event("token", {"token": token})
            yield sse_event("done", {})
        except PdfExtractionError as exc:
            yield sse_event("error", {"message": str(exc)})
        except LLMProviderError as exc:
            yield sse_event("error", {"message": str(exc)})
    return StreamingResponse(event_stream(), media_type="text/event-stream")
--- a/brain/app/api/routers/models.py
+++ b/brain/app/api/routers/models.py
@@ -1,365 +0,0 @@
 """Endpoints de catalogue de modèles (Ollama, OpenRouter, Mistral, Gemini, 1min.ai).
 Proxifie les APIs des providers pour que l'UI propose des listes de modèles ;
 repli statique quand l'API est injoignable ou la clé absente (pas de 500 à l'UI).
 """
 import json
 from typing import Annotated, AsyncIterator
 import httpx
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from app.core.config import Settings, get_settings
 router = APIRouter()
@router.get("/models/ollama")
 async def list_ollama_models(
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> dict[str, list[str]]:
    """Liste les modeles disponibles sur le serveur Ollama configure.
    Retourne une liste vide si Ollama est injoignable — l'UI affichera un
    message plutot qu'une 500.
    """
    url = f"{settings.ollama_base_url}/api/tags"
    try:
        async with httpx.AsyncClient(timeout=5) as client:
            response = await client.get(url)
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError:
        return {"models": []}
    models = [m.get("name", "") for m in data.get("models", []) if m.get("name")]
    return {"models": sorted(models)}
 class OllamaModelInfoDTO(BaseModel):
    """Info utile extraite de /api/show pour un modele Ollama donne.
    `context_length` = fenetre de contexte max supportee par le modele
    (extraite des metadonnees GGUF). 0 si inconnue. Le frontend s'en sert
    pour borner le slider de num_ctx dans les Parametres.
    """
    context_length: int = 0
@router.post("/models/ollama/info", response_model=OllamaModelInfoDTO)
 async def get_ollama_model_info(
    body: dict[str, str],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> OllamaModelInfoDTO:
    """Retourne les metadonnees d'un modele Ollama via /api/show.
    On passe par POST (et pas GET /models/ollama/{name}) parce que les noms
    Ollama contiennent souvent un `:` (ex: `gemma3:e2b`) qui se segmente
    mal dans une URL — le body JSON evite le probleme d'escaping.
    Le champ qui nous interesse est `model_info["<arch>.context_length"]`
    (ex: `gemma3.context_length: 131072`). L'arch varie selon le modele, on
    scanne donc tous les champs finissant par `.context_length`.
    """
    name = (body.get("name") or "").strip()
    if not name:
        raise HTTPException(status_code=400, detail="name requis")
    url = f"{settings.ollama_base_url}/api/show"
    try:
        async with httpx.AsyncClient(timeout=5) as client:
            response = await client.post(url, json={"model": name})
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError:
        return OllamaModelInfoDTO(context_length=0)
    model_info = data.get("model_info") or {}
    for key, value in model_info.items():
        if key.endswith(".context_length") and isinstance(value, int):
            return OllamaModelInfoDTO(context_length=value)
    return OllamaModelInfoDTO(context_length=0)
@router.post("/models/ollama/pull")
 async def pull_ollama_model(
    body: dict[str, str],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> StreamingResponse:
    """Telecharge un modele depuis Ollama et streame la progression.
    Proxifie l'endpoint `/api/pull` d'Ollama qui renvoie du JSON ligne par
    ligne (NDJSON) avec le statut de chaque etape : manifest, layers,
    digest, success. On reemet ce flux tel quel au client (le front
    parsera les lignes et affichera une barre de progression).
    Le timeout est intentionnellement tres long (60 min) car certains
    modeles font 30+ Go.
    """
    name = (body.get("name") or "").strip()
    if not name:
        raise HTTPException(status_code=400, detail="name requis")
    url = f"{settings.ollama_base_url}/api/pull"
    async def stream() -> AsyncIterator[bytes]:
        # On utilise un timeout long pour la lecture (60 min) mais court pour
        # la connexion (10s) — si Ollama n'est pas joignable, on echoue vite.
        timeout = httpx.Timeout(connect=10, read=3600, write=10, pool=10)
        try:
            async with httpx.AsyncClient(timeout=timeout) as client:
                async with client.stream("POST", url, json={"model": name, "stream": True}) as r:
                    if r.status_code != 200:
                        # Ollama renvoie un message JSON d'erreur. On le passe
                        # tel quel au client en preservant le code HTTP.
                        body_text = await r.aread()
                        yield body_text
                        return
                    async for chunk in r.aiter_bytes():
                        yield chunk
        except httpx.HTTPError as e:
            # Erreur reseau : on emet une ligne JSON d'erreur compatible
            # avec le format NDJSON d'Ollama.
            err = json.dumps({"error": f"Connexion a Ollama impossible : {e}"}) + "\n"
            yield err.encode("utf-8")
    # application/x-ndjson : un objet JSON par ligne, pas de wrapping SSE.
    # C'est le format natif d'Ollama, le front le parsera ligne par ligne.
    return StreamingResponse(stream(), media_type="application/x-ndjson")
@router.delete("/models/ollama/{name:path}")
 async def delete_ollama_model(
    name: str,
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> dict[str, str]:
    """Supprime un modele du serveur Ollama.
    Le `:path` dans le pattern autorise les `:` du nom (ex: `gemma4:e4b`)
    sans avoir besoin de URL-encoder cote client.
    """
    if not name.strip():
        raise HTTPException(status_code=400, detail="name requis")
    url = f"{settings.ollama_base_url}/api/delete"
    try:
        async with httpx.AsyncClient(timeout=10) as client:
            response = await client.request("DELETE", url, json={"model": name})
            if response.status_code == 404:
                raise HTTPException(status_code=404, detail=f"Modele '{name}' introuvable")
            response.raise_for_status()
    except httpx.HTTPError as e:
        raise HTTPException(status_code=502, detail=f"Ollama injoignable : {e}")
    return {"status": "deleted", "name": name}
@router.get("/models/openrouter")
 async def list_openrouter_models() -> dict[str, list[dict[str, object]]]:
    """Catalogue DYNAMIQUE des modeles OpenRouter (API publique, sans cle).
    Renvoie {models: [{id, name, context_length, free}]}, trie gratuits d'abord
    puis contexte decroissant. `free` = id finissant par ':free' OU prix nul.
    """
    try:
        async with httpx.AsyncClient(timeout=20) as client:
            response = await client.get("https://openrouter.ai/api/v1/models")
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError as exc:
        raise HTTPException(status_code=502, detail=f"OpenRouter injoignable : {exc}")
    def _is_zero(value: object) -> bool:
        try:
            return float(value) == 0.0  # type: ignore[arg-type]
        except (TypeError, ValueError):
            return False
    models: list[dict[str, object]] = []
    for m in data.get("data", []) or []:
        mid = str(m.get("id") or "")
        if not mid:
            continue
        pricing = m.get("pricing") or {}
        is_free = mid.endswith(":free") or (
            _is_zero(pricing.get("prompt")) and _is_zero(pricing.get("completion"))
        )
        try:
            ctx = int(m.get("context_length") or 0)
        except (TypeError, ValueError):
            ctx = 0
        models.append({
            "id": mid,
            "name": str(m.get("name") or mid),
            "context_length": ctx,
            "free": is_free,
        })
    models.sort(key=lambda x: (not x["free"], -int(x["context_length"])))  # type: ignore[index]
    return {"models": models}
 # Repli statique si la cle Mistral n'est pas (encore) configuree ou si l'API est
 # injoignable — l'utilisateur peut quand meme choisir un modele. Liste curee
 # (juin 2026) ; pour l'extraction de PDF, prefere `large` (fidele, 128k) ou `small`.
 _MISTRAL_FALLBACK_MODELS = [
    "mistral-large-latest",
    "mistral-medium-latest",
    "mistral-small-latest",
    "open-mistral-nemo",
    "ministral-8b-latest",
    "ministral-3b-latest",
    "magistral-medium-latest",
    "magistral-small-latest",
    "pixtral-large-latest",
    "codestral-latest",
 ]
@router.get("/models/mistral")
 async def list_mistral_models(
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> dict[str, list[dict[str, object]]]:
    """Catalogue des modeles Mistral. Dynamique si une cle est configuree
    (GET /v1/models, qui requiert l'auth), sinon repli statique.
    Renvoie {models: [{id}]} (tous accessibles sur le tier gratuit Experiment)."""
    key = settings.mistral_api_key
    if not key:
        return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
    try:
        async with httpx.AsyncClient(timeout=20) as client:
            response = await client.get(
                "https://api.mistral.ai/v1/models",
                headers={"Authorization": f"Bearer {key}"},
            )
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError:
        # Cle invalide / API down : on ne casse pas l'UI, on propose le repli.
        return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
    ids = sorted({str(m.get("id")) for m in data.get("data", []) or [] if m.get("id")})
    if not ids:
        ids = _MISTRAL_FALLBACK_MODELS
    return {"models": [{"id": i} for i in ids]}
 # Repli statique Gemini (juin 2026). Pour l'extraction, prefere un Flash a grand
 # contexte ; `gemini-2.0-flash` a le quota gratuit le plus genereux.
 _GEMINI_FALLBACK_MODELS = [
    "gemini-2.0-flash",
    "gemini-2.0-flash-lite",
    "gemini-2.5-flash",
    "gemini-2.5-flash-lite",
    "gemini-2.5-pro",
    "gemini-1.5-flash",
    "gemini-1.5-pro",
 ]
@router.get("/models/gemini")
 async def list_gemini_models(
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> dict[str, list[dict[str, object]]]:
    """Catalogue des modeles Gemini. Dynamique si une cle est configuree (endpoint
    OpenAI-compatible /openai/models), sinon repli statique. Renvoie {models:[{id}]}."""
    key = settings.gemini_api_key
    if not key:
        return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
    try:
        async with httpx.AsyncClient(timeout=20) as client:
            response = await client.get(
                "https://generativelanguage.googleapis.com/v1beta/openai/models",
                headers={"Authorization": f"Bearer {key}"},
            )
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError:
        return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
    # Les ids peuvent arriver prefixes "models/" → on nettoie pour que la valeur
    # selectionnee soit directement utilisable dans l'appel chat. On garde les
    # modeles "gemini-*" (hors embeddings/aqa) pour ne pas noyer la liste.
    ids: set[str] = set()
    for m in data.get("data", []) or []:
        mid = str(m.get("id") or "")
        if mid.startswith("models/"):
            mid = mid[len("models/"):]
        if mid.startswith("gemini-"):
            ids.add(mid)
    clean = sorted(ids) if ids else _GEMINI_FALLBACK_MODELS
    return {"models": [{"id": i} for i in clean]}
@router.get("/models/onemin")
 def list_onemin_models() -> dict[str, list[dict[str, object]]]:
    """Catalogue statique des modeles 1min.ai, groupes par fournisseur.
    Liste construite par probing direct de l'endpoint chat-with-ai avec
    une vraie cle API (avril 2026) : chaque ID renvoie 200, les IDs
    absents renvoient 400 UNSUPPORTED_MODEL.
    Nota : les IDs Anthropic utilisent la nomenclature propre a 1min.ai
    (`claude-<family>-<version>`), pas la convention officielle Anthropic.
    """
    return {
        "groups": [
            {
                "provider": "Anthropic",
                "models": ["claude-opus-4-6", "claude-sonnet-4-6"],
            },
            {
                "provider": "OpenAI",
                "models": [
                    "gpt-5",
                    "gpt-5-mini",
                    "gpt-5-nano",
                    "gpt-4.1",
                    "gpt-4.1-mini",
                    "gpt-4.1-nano",
                    "gpt-4o",
                    "gpt-4o-mini",
                    "gpt-4-turbo",
                    "gpt-3.5-turbo",
                    "o3",
                    "o3-pro",
                    "o3-mini",
                    "o4-mini",
                ],
            },
            {
                "provider": "Google",
                "models": ["gemini-2.5-pro", "gemini-2.5-flash"],
            },
            {
                "provider": "Mistral",
                "models": [
                    "mistral-large-latest",
                    "mistral-medium-latest",
                    "mistral-small-latest",
                    "open-mistral-nemo",
                ],
            },
            {
                "provider": "DeepSeek",
                "models": ["deepseek-chat", "deepseek-reasoner"],
            },
            {
                "provider": "xAI",
                "models": ["grok-3", "grok-3-mini"],
            },
            {
                "provider": "Meta",
                "models": [
                    "meta/meta-llama-3.1-405b-instruct",
                    "meta/meta-llama-3-70b-instruct",
                ],
            },
            {
                "provider": "Alibaba",
                "models": ["qwen-plus", "qwen3-max"],
            },
            {
                "provider": "Perplexity",
                "models": ["sonar", "sonar-pro"],
            },
        ]
    }
--- a/brain/app/api/routers/notebooks.py
+++ b/brain/app/api/routers/notebooks.py
@@ -1,130 +0,0 @@
 """Endpoints des notebooks (atelier RAG) : indexation des sources + chats ancrés."""
 import logging
 from typing import Annotated, AsyncIterator
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 from app.api.common import MAX_PDF_BYTES, sse_event
 from app.api.deps import (
    get_notebook_chat_use_case,
    get_notebook_deep_use_case,
    get_notebook_rag_use_case,
 )
 from app.application.embeddings import EmbeddingError
 from app.application.notebook_chat import NotebookChatUseCase
 from app.application.notebook_deep import NotebookDeepUseCase
 from app.application.notebook_rag import NotebookRagUseCase
 from app.core.config import Settings, get_settings
 from app.domain.models import ChatMessage
 from app.domain.ports import LLMProviderError, PdfExtractionError
 from app.infrastructure import vector_store
 logger = logging.getLogger(__name__)
 router = APIRouter()
 class IndexSourceResponseDTO(BaseModel):
    chunks: int
    page_count: int
    ocr_page_count: int
@router.post("/index/notebook-source", response_model=IndexSourceResponseDTO)
 async def index_notebook_source(
    rag: Annotated[NotebookRagUseCase, Depends(get_notebook_rag_use_case)],
    source_id: str = Form(...),
    file: UploadFile = File(...),
 ) -> IndexSourceResponseDTO:
    """Indexe une source PDF (extraction + embeddings + stockage vectoriel)."""
    content = await file.read()
    if not content:
        raise HTTPException(status_code=422, detail="Fichier PDF vide.")
    if len(content) > MAX_PDF_BYTES:
        raise HTTPException(
            status_code=413, detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).")
    try:
        recap = await rag.index_source(source_id, content)
    except PdfExtractionError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    except EmbeddingError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return IndexSourceResponseDTO(**recap)
@router.delete("/index/notebook-source/{source_id}")
 def delete_notebook_source(source_id: str) -> dict[str, str]:
    """Supprime les vecteurs d'une source (au DELETE d'une source/notebook)."""
    vector_store.delete(source_id)
    return {"status": "deleted", "source_id": source_id}
 class NotebookChatMessageDTO(BaseModel):
    role: str
    content: str
 class NotebookChatRequestDTO(BaseModel):
    source_ids: list[str] = Field(default_factory=list)
    messages: list[NotebookChatMessageDTO] = Field(default_factory=list)
    context: str = Field(default="")
@router.post("/chat/notebook/stream")
 async def chat_notebook_stream(
    body: NotebookChatRequestDTO,
    use_case: Annotated[NotebookChatUseCase, Depends(get_notebook_chat_use_case)],
    settings: Annotated[Settings, Depends(get_settings)],
 ) -> StreamingResponse:
    """Chat ANCRÉ sur les sources (RAG) : récupère les passages pertinents puis
    streame la réponse. Évènements SSE : `token` {token}, `done` {}, `error` {message}."""
    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
    top_k = max(1, min(settings.rag_top_k, 200))
    async def event_stream() -> AsyncIterator[str]:
        try:
            async for ev in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k):
                if ev["type"] == "token":
                    if ev.get("token"):
                        yield sse_event("token", {"token": ev["token"]})
                else:
                    # 'sources' (et tout futur évènement typé) : relayé tel quel.
                    ev_type = ev.pop("type")
                    yield sse_event(ev_type, ev)
            yield sse_event("done", {})
        except (LLMProviderError, EmbeddingError) as exc:
            yield sse_event("error", {"message": str(exc)})
        except Exception as exc:  # noqa: BLE001 — filet : pas de coupure brutale du flux.
            logger.exception("Chat notebook : erreur inattendue.")
            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
    return StreamingResponse(event_stream(), media_type="text/event-stream")
@router.post("/chat/notebook/deep/stream")
 async def chat_notebook_deep_stream(
    body: NotebookChatRequestDTO,
    use_case: Annotated[NotebookDeepUseCase, Depends(get_notebook_deep_use_case)],
 ) -> StreamingResponse:
    """Analyse APPROFONDIE (map-reduce sur tout le document). Évènements SSE :
    `progress` {current,total} pendant la lecture, puis `token` {token}, puis `done`."""
    messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
    question = next((m.content for m in reversed(messages) if m.role == "user"), "")
    async def event_stream() -> AsyncIterator[str]:
        if not question.strip():
            yield sse_event("error", {"message": "Question vide."})
            return
        try:
            async for ev in use_case.stream(body.source_ids, messages, context=body.context):
                ev_type = ev.pop("type")
                yield sse_event(ev_type, ev)
        except (LLMProviderError, EmbeddingError) as exc:
            yield sse_event("error", {"message": str(exc)})
        except Exception as exc:  # noqa: BLE001 — filet : pas de coupure brutale.
            logger.exception("Analyse approfondie : erreur inattendue.")
            yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
    return StreamingResponse(event_stream(), media_type="text/event-stream")
--- a/brain/app/api/routers/settings.py
+++ b/brain/app/api/routers/settings.py
@@ -1,115 +0,0 @@
 """Endpoints de paramétrage runtime (écran Paramètres de l'UI)."""
 from typing import Annotated, Literal
 from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 from app.core.config import Settings, get_settings
 from app.core.settings_store import save_overrides
 router = APIRouter()
 class SettingsDTO(BaseModel):
    """Vue serialisable des settings modifiables depuis l'UI.
    Expose uniquement les champs que l'utilisateur peut changer a chaud.
    Les secrets (onemin_api_key) sont masques en lecture.
    """
    llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"]
    ollama_base_url: str
    llm_model: str
    onemin_model: str
    # True si une cle 1min.ai est deja configuree — pas de leak de la cle elle-meme.
    onemin_api_key_set: bool
    openrouter_model: str
    # True si une cle OpenRouter est deja configuree (cle elle-meme jamais renvoyee).
    openrouter_api_key_set: bool
    mistral_model: str
    # True si une cle Mistral est deja configuree (cle elle-meme jamais renvoyee).
    mistral_api_key_set: bool
    gemini_model: str
    # True si une cle Gemini est deja configuree (cle elle-meme jamais renvoyee).
    gemini_api_key_set: bool
    # Embeddings (RAG des ateliers) : provider + modeles + auto-pull Ollama.
    embedding_provider: Literal["ollama", "mistral"]
    ollama_embedding_model: str
    mistral_embedding_model: str
    auto_pull_embedding_model: bool
    rag_top_k: int
    # Fenetre de contexte effective passee au modele (num_ctx Ollama) — sert
    # aussi de plafond a la jauge de contexte UI.
    llm_num_ctx: int
    # Taille cible d'un morceau (tokens) pour l'import de PDF (regles/campagne).
    import_chunk_tokens: int
    # Timeout HTTP des appels LLM (s). A monter si les imports lourds expirent.
    llm_timeout_seconds: int
 class SettingsUpdateDTO(BaseModel):
    """Patch partiel des settings. Tous les champs sont optionnels."""
    llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"] | None = None
    ollama_base_url: str | None = None
    llm_model: str | None = None
    onemin_model: str | None = None
    # Chaine vide => on efface la cle. None => pas de changement.
    onemin_api_key: str | None = None
    openrouter_model: str | None = None
    openrouter_api_key: str | None = None
    mistral_model: str | None = None
    mistral_api_key: str | None = None
    gemini_model: str | None = None
    gemini_api_key: str | None = None
    embedding_provider: Literal["ollama", "mistral"] | None = None
    ollama_embedding_model: str | None = None
    mistral_embedding_model: str | None = None
    auto_pull_embedding_model: bool | None = None
    rag_top_k: int | None = None
    llm_num_ctx: int | None = None
    import_chunk_tokens: int | None = None
    llm_timeout_seconds: int | None = None
 def _to_settings_dto(s: Settings) -> SettingsDTO:
    return SettingsDTO(
        llm_provider=s.llm_provider,
        ollama_base_url=s.ollama_base_url,
        llm_model=s.llm_model,
        onemin_model=s.onemin_model,
        onemin_api_key_set=bool(s.onemin_api_key),
        openrouter_model=s.openrouter_model,
        openrouter_api_key_set=bool(s.openrouter_api_key),
        mistral_model=s.mistral_model,
        mistral_api_key_set=bool(s.mistral_api_key),
        gemini_model=s.gemini_model,
        gemini_api_key_set=bool(s.gemini_api_key),
        embedding_provider=s.embedding_provider,
        ollama_embedding_model=s.ollama_embedding_model,
        mistral_embedding_model=s.mistral_embedding_model,
        auto_pull_embedding_model=s.auto_pull_embedding_model,
        rag_top_k=s.rag_top_k,
        llm_num_ctx=s.llm_num_ctx,
        import_chunk_tokens=s.import_chunk_tokens,
        llm_timeout_seconds=s.llm_timeout_seconds,
    )
@router.get("/settings", response_model=SettingsDTO)
 def read_settings(settings: Annotated[Settings, Depends(get_settings)]) -> SettingsDTO:
    """Retourne la config courante (secrets masques)."""
    return _to_settings_dto(settings)
@router.put("/settings", response_model=SettingsDTO)
 def update_settings(patch: SettingsUpdateDTO) -> SettingsDTO:
    """Applique un patch partiel aux settings et persiste les overrides.
    Toute requete HTTP suivante verra les nouvelles valeurs (pas de cache).
    """
    overrides = {k: v for k, v in patch.model_dump().items() if v is not None}
    if overrides:
        save_overrides(overrides)
    # Relit .env + overrides fusionnes pour confirmation.
    return _to_settings_dto(get_settings())
--- a/brain/app/api/routers/tables.py
+++ b/brain/app/api/routers/tables.py
@@ -1,216 +0,0 @@
 """Endpoints « outils de table » : tables aléatoires, improvisation, catalogues d'objets."""
 import re
 from typing import Annotated
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
 from app.api.deps import get_llm_provider
 from app.application.llm_json import load_json_object
 from app.application.llm_retry import generate_with_retry
 from app.domain.ports import LLMProvider, LLMProviderError
 router = APIRouter()
 _DICE_FORMULA_RE = re.compile(r"^\s*(\d*)\s*[dD]\s*(\d+)\s*$")
 def _dice_total_range(formula: str) -> tuple[int, int] | None:
    """(min, max) des totaux possibles d'une formule NdM, ou None si invalide."""
    match = _DICE_FORMULA_RE.match(formula or "")
    if not match:
        return None
    count = int(match.group(1)) if match.group(1) else 1
    faces = int(match.group(2))
    if count < 1 or count > 100 or faces < 2 or faces > 10000:
        return None
    return count, count * faces
 class GenerateTableRequestDTO(BaseModel):
    description: str
    dice_formula: str = Field(default="1d20")
    # Contexte libre assemblé par le Core (nom de campagne, système, ambiance…).
    context: str = Field(default="")
 class GeneratedTableEntryDTO(BaseModel):
    min_roll: int
    max_roll: int
    label: str
    detail: str = ""
 class GenerateTableResponseDTO(BaseModel):
    name: str
    description: str = ""
    entries: list[GeneratedTableEntryDTO]
@router.post("/generate/random-table", response_model=GenerateTableResponseDTO)
 async def generate_random_table(
    body: GenerateTableRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> GenerateTableResponseDTO:
    """Génère une table aléatoire (entrées par plage) couvrant la formule de dé."""
    rng = _dice_total_range(body.dice_formula)
    if rng is None:
        raise HTTPException(status_code=422, detail="Formule de dé invalide (ex. 1d20, 2d6, d100).")
    lo, hi = rng
    context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
    prompt = (
        "Tu es un assistant de jeu de rôle. Génère une TABLE ALÉATOIRE évocatrice.\n"
        f"Dé : {body.dice_formula} (résultats possibles de {lo} à {hi}).\n"
        f"Sujet : {body.description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "entries": '
        '[{"min_roll": N, "max_roll": M, "label": "résultat court", "detail": "1-2 phrases"}]}\n'
        f"- Les plages (min_roll..max_roll) doivent COUVRIR EXACTEMENT {lo}..{hi}, "
        "sans trou ni chevauchement, dans l'ordre croissant.\n"
        "- Des résultats variés, cohérents avec le sujet (et le contexte s'il est fourni).\n"
        "- En français. 'label' = résultat bref ; 'detail' = description/effet concret.\n"
        "Renvoie maintenant le JSON."
    )
    try:
        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    parsed, _ = load_json_object(raw)
    if not isinstance(parsed, dict):
        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de table exploitable.")
    entries: list[GeneratedTableEntryDTO] = []
    for e in parsed.get("entries", []) or []:
        if not isinstance(e, dict):
            continue
        try:
            mn = int(e["min_roll"])
            mx = int(e["max_roll"])
        except (KeyError, TypeError, ValueError):
            continue
        label = str(e.get("label") or "").strip()
        if not label:
            continue
        entries.append(GeneratedTableEntryDTO(
            min_roll=mn, max_roll=max(mn, mx), label=label[:200],
            detail=str(e.get("detail") or "").strip(),
        ))
    if not entries:
        raise HTTPException(status_code=502, detail="Aucune entrée générée — réessaie ou reformule.")
    name = str(parsed.get("name") or body.description).strip()[:120] or "Table générée"
    return GenerateTableResponseDTO(
        name=name,
        description=str(parsed.get("description") or "").strip(),
        entries=entries,
    )
 class ImproviseRollRequestDTO(BaseModel):
    table_name: str
    result_label: str
    result_detail: str = Field(default="")
    context: str = Field(default="")
 class ImproviseRollResponseDTO(BaseModel):
    narration: str
@router.post("/improvise/table-roll", response_model=ImproviseRollResponseDTO)
 async def improvise_table_roll(
    body: ImproviseRollRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> ImproviseRollResponseDTO:
    """Brode un court récit (2-3 phrases) sur un résultat tiré, pour lancer la scène."""
    detail = f" ({body.result_detail.strip()})" if body.result_detail.strip() else ""
    context_block = f"\nContexte : {body.context.strip()}" if body.context.strip() else ""
    prompt = (
        "Tu es le Maître du Jeu. Les joueurs viennent de tirer sur la table "
        f"« {body.table_name.strip()} » et ont obtenu : « {body.result_label.strip()} »{detail}."
        f"{context_block}\n\n"
        "Décris en 2-3 phrases vivantes et immédiates ce qui se passe, pour lancer la scène. "
        "Pas de méta, pas d'options : juste la narration, en français."
    )
    try:
        raw = await llm.generate(prompt, temperature=0.8)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return ImproviseRollResponseDTO(narration=raw.strip())
 # --- Catalogues d'objets (boutiques) : génération IA -------------------------
 class GenerateCatalogRequestDTO(BaseModel):
    description: str
    context: str = Field(default="")
 class GeneratedCatalogItemDTO(BaseModel):
    name: str
    price: str = ""
    category: str = ""
    description: str = ""
 class GenerateCatalogResponseDTO(BaseModel):
    name: str
    description: str = ""
    items: list[GeneratedCatalogItemDTO]
@router.post("/generate/item-catalog", response_model=GenerateCatalogResponseDTO)
 async def generate_item_catalog(
    body: GenerateCatalogRequestDTO,
    llm: Annotated[LLMProvider, Depends(get_llm_provider)],
 ) -> GenerateCatalogResponseDTO:
    """Génère un catalogue d'objets (boutique, butin…) — nom, prix, catégorie, description."""
    context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
    prompt = (
        "Tu es un assistant de jeu de rôle. Génère un CATALOGUE D'OBJETS (boutique, butin, trésor…).\n"
        f"Sujet : {body.description.strip()}\n"
        f"{context_block}\n"
        "Règles IMPÉRATIVES :\n"
        "- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
        '- Format : {"name": "...", "description": "...", "items": '
        '[{"name": "Objet", "price": "ex. 50 po", "category": "ex. Armes", "description": "effet/détails"}]}\n'
        "- Des objets variés et cohérents avec le sujet (et le contexte s'il est fourni).\n"
        "- 'price' = prix court dans la monnaie du jeu ; 'category' = regroupement (Armes, Potions…) ; "
        "'description' = effet/détails en une phrase. En français.\n"
        "Renvoie maintenant le JSON."
    )
    try:
        raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
    except LLMProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    parsed, _ = load_json_object(raw)
    if not isinstance(parsed, dict):
        raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de catalogue exploitable.")
    items: list[GeneratedCatalogItemDTO] = []
    for it in parsed.get("items", []) or []:
        if not isinstance(it, dict):
            continue
        name = str(it.get("name") or "").strip()
        if not name:
            continue
        items.append(GeneratedCatalogItemDTO(
            name=name[:200],
            price=str(it.get("price") or "").strip(),
            category=str(it.get("category") or "").strip(),
            description=str(it.get("description") or "").strip(),
        ))
    if not items:
        raise HTTPException(status_code=502, detail="Aucun objet généré — réessaie ou reformule.")
    name = str(parsed.get("name") or body.description).strip()[:120] or "Catalogue généré"
    return GenerateCatalogResponseDTO(
        name=name,
        description=str(parsed.get("description") or "").strip(),
        items=items,
    )
--- a/brain/app/application/chunking.py
+++ b/brain/app/application/chunking.py
@@ -13,19 +13,8 @@ from __future__ import annotations
 CHUNK_TARGET_TOKENS = 6000
-def chunk_text(
+def chunk_text(full_text: str, target_tokens: int = CHUNK_TARGET_TOKENS) -> list[str]:
-    full_text: str,
+    """Découpe `full_text` en morceaux ~`target_tokens` tokens (frontières de §)."""
    target_tokens: int = CHUNK_TARGET_TOKENS,
    overlap_tokens: int = 0,
 ) -> list[str]:
    """Découpe `full_text` en morceaux ~`target_tokens` tokens (frontières de §).
    `overlap_tokens` > 0 : chaque morceau reprend la fin du précédent (les derniers
    paragraphes, jusqu'à ~`overlap_tokens` tokens). Utile pour le RAG : une phrase-clé
    à cheval sur deux morceaux reste retrouvable dans au moins l'un des deux. À
    laisser à 0 pour les imports (recopie) : un overlap y DUPLIQUERAIT du texte.
    Un morceau peut légèrement dépasser la cible (jusqu'à target + overlap).
    """
    if not full_text.strip():
        return []
@@ -37,87 +26,30 @@ def chunk_text(
    chunks: list[str] = []
    current: list[str] = []
    current_tokens = 0
    fresh = False  # `current` contient-il du contenu pas encore émis ? (évite de
    # ré-émettre un morceau composé uniquement de l'overlap en fin de texte)
    for para in paragraphs:
        para_tokens = len(enc.encode(para))
        # Un paragraphe seul plus gros que la cible : on le coupe en sous-blocs.
        if para_tokens > target_tokens:
-            if current and fresh:
+            if current:
                chunks.append("\n\n".join(current))
-            current, current_tokens, fresh = [], 0, False
+                current, current_tokens = [], 0
-            chunks.extend(_split_oversized(para, enc, target_tokens, overlap_tokens))
+            chunks.extend(_split_oversized(para, enc, target_tokens))
            continue
        if current_tokens + para_tokens > target_tokens and current:
-            if fresh:
+            chunks.append("\n\n".join(current))
-                chunks.append("\n\n".join(current))
+            current, current_tokens = [], 0
            current, current_tokens = _overlap_tail(current, enc, overlap_tokens)
            fresh = False
        current.append(para)
        current_tokens += para_tokens
        fresh = True
-    if current and fresh:
+    if current:
        chunks.append("\n\n".join(current))
    return chunks
-def _overlap_tail(parts: list[str], enc, overlap_tokens: int) -> tuple[list[str], int]:
+def _split_oversized(paragraph: str, enc, target_tokens: int) -> list[str]:
-    """Derniers paragraphes de `parts` totalisant au plus `overlap_tokens` tokens —
+    """Coupe un paragraphe géant en sous-blocs ~`target_tokens` tokens."""
    le « rappel » recopié en tête du morceau suivant."""
    if overlap_tokens <= 0 or not parts:
        return [], 0
    tail: list[str] = []
    total = 0
    for para in reversed(parts):
        para_tokens = len(enc.encode(para))
        if total + para_tokens > overlap_tokens:
            break
        tail.insert(0, para)
        total += para_tokens
    if not tail:
        # Aucun paragraphe entier ne tient dans le budget (paragraphes longs) :
        # on reprend la FIN du dernier paragraphe pour garantir le recouvrement.
        tokens = enc.encode(parts[-1])
        tail = [enc.decode(tokens[-overlap_tokens:])]
        total = min(overlap_tokens, len(tokens))
    return tail, total
 def _split_oversized(paragraph: str, enc, target_tokens: int, overlap_tokens: int = 0) -> list[str]:
    """Coupe un paragraphe géant en sous-blocs ~`target_tokens` tokens (fenêtre
    glissante avec recouvrement si `overlap_tokens` > 0)."""
    tokens = enc.encode(paragraph)
    step = max(1, target_tokens - overlap_tokens)
    out: list[str] = []
-    i = 0
+    for i in range(0, len(tokens), target_tokens):
    while i < len(tokens):
        out.append(enc.decode(tokens[i : i + target_tokens]))
        if i + target_tokens >= len(tokens):
            break
        i += step
    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
--- a/brain/app/application/embeddings.py
+++ b/brain/app/application/embeddings.py
@@ -1,26 +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é).
    `kind` distingue les DOCUMENTS indexés ("document") de la QUESTION posée
    ("query") : certains modèles (nomic-embed-text) sont entraînés avec des
    préfixes de tâche distincts et perdent en pertinence sans eux. Les adapters
    qui n'en ont pas besoin (mistral-embed) ignorent simplement le paramètre.
    """
    async def embed(self, texts: list[str], kind: str = "document") -> list[list[float]]:
        ...
--- a/brain/app/application/import_campaign.py
+++ b/brain/app/application/import_campaign.py
@@ -10,42 +10,23 @@ PROPOSITION non persistée : le Core crée les entités seulement après revue.
 """
 from __future__ import annotations
 import asyncio
 import logging
-from app.application.chunking import chunk_text, split_in_half
+from app.application.chunking import chunk_text
-from app.application.import_status import (
+from app.application.llm_json import load_json_object
    notify_status,
    reset_status_queue,
    set_status_queue,
 )
 from app.application.llm_json import load_json_object, looks_like_truncated_json
 from app.application.llm_retry import generate_with_retry
 from app.application.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,
    NpcImportProposal,
    RoomProposal,
    SceneProposal,
 )
-from app.domain.ports import (
+from app.domain.ports import LLMProvider, PdfTextExtractor
    LLMGenerationTimeout,
    LLMProvider,
    LLMProviderError,
    PdfTextExtractor,
 )
 logger = logging.getLogger(__name__)
-# Très basse : structuration = recopie/réorganisation fidèle, pas de créativité.
+_TEMPERATURE = 0.2
 # 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"
@@ -94,14 +75,6 @@ PIÈCES (rooms) — uniquement pour les scènes qui sont des lieux explorables :
 - `enemies` = créatures/boss de la salle (vide si aucune). `loot` = trésor/récompense (vide si aucun).
 - Pour une scène narrative classique (pas un donjon), "rooms" est un tableau vide [].
 PNJ ET CRÉATURES NOTABLES ("npcs", tableau au niveau racine) :
 - Recense les PNJ NOMMÉS (alliés, marchands, antagonistes) et les créatures UNIQUES
  (boss, monstre récurrent) présents dans l'extrait.
 - `description` = courte fiche utile au MJ : rôle dans l'histoire, apparence,
  motivations, où on le rencontre. 2 à 4 phrases, fidèles au livre.
 - N'inclus PAS les monstres génériques sans nom (« 3 gobelins », « un loup »).
 - Aucun PNJ nommé dans l'extrait → "npcs": [].
 Format de réponse :
 - Tu réponds UNIQUEMENT par un objet JSON valide, sans markdown ni commentaire autour.
 - Schéma EXACT :
@@ -110,139 +83,12 @@ Format de réponse :
        {{"name": "...", "description": "...", "player_narration": "...", "gm_notes": "...",
          "rooms": [{{"name": "...", "description": "...", "enemies": "...", "loot": "..."}}]}}
     ]}}]}}
-  ],
+  ]}}
   "npcs": [{{"name": "...", "description": "..."}}]}}
 - Utilise les VRAIS titres du livre pour les noms (pas de paraphrase).
 - Si le livre n'est PAS découpé en actes/parties, regroupe tout sous un seul arc nommé "{default_arc}".
 - N'invente pas de contenu : tu réorganises et recopies ce qui est présent dans l'extrait.
 - Si l'extrait ne contient aucune matière narrative, renvoie {{"arcs": []}}."""
 # Schéma de l'arbre attendu, passé aux providers à sorties structurées (Ollama
 # contraint la grammaire : un modèle local ne PEUT plus produire de clés
 # inventées, d'objets bavards type "thought" ni de texte hors JSON). Les
 # adapters cloud le traduisent en mode JSON natif. Seuls les "name" sont
 # requis : le _TreeMerger tolère déjà tous les champs absents.
 _TREE_SCHEMA: dict = {
    "type": "object",
    "properties": {
        "arcs": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "description": {"type": "string"},
                    "type": {"type": "string", "enum": ["LINEAR", "HUB"]},
                    "chapters": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "description": {"type": "string"},
                                "scenes": {
                                    "type": "array",
                                    "items": {
                                        "type": "object",
                                        "properties": {
                                            "name": {"type": "string"},
                                            "description": {"type": "string"},
                                            "player_narration": {"type": "string"},
                                            "gm_notes": {"type": "string"},
                                            "rooms": {
                                                "type": "array",
                                                "items": {
                                                    "type": "object",
                                                    "properties": {
                                                        "name": {"type": "string"},
                                                        "description": {"type": "string"},
                                                        "enemies": {"type": "string"},
                                                        "loot": {"type": "string"},
                                                    },
                                                    "required": ["name"],
                                                    "additionalProperties": False,
                                                },
                                            },
                                        },
                                        "required": ["name"],
                                        "additionalProperties": False,
                                    },
                                },
                            },
                            "required": ["name"],
                            "additionalProperties": False,
                        },
                    },
                },
                "required": ["name"],
                "additionalProperties": False,
            },
        },
        "npcs": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "description": {"type": "string"},
                },
                "required": ["name"],
                "additionalProperties": False,
            },
        },
    },
    "required": ["arcs"],
    "additionalProperties": False,
 }
 # Bloc TOC injecté quand le PDF a des bookmarks : les morceaux étant traités
 # séparément, c'est CE référentiel commun qui garantit que tous nomment les
 # mêmes chapitres à l'identique → la fusion par nom du _TreeMerger recolle
 # les chapitres coupés au lieu de créer des doublons.
 _TOC_BLOCK = """
 --- STRUCTURE OFFICIELLE DU LIVRE (table des matières du PDF) ---
 {toc}
 --- FIN DE LA STRUCTURE ---
 IMPORTANT : pour nommer les arcs et chapitres, reprends EXACTEMENT les titres
 de cette structure (caractère pour caractère). Rattache le contenu de l'extrait
 au bon chapitre de la structure, même si son titre n'apparaît pas dans l'extrait."""
 # Garde-fou prompt : une TOC de gros livre peut compter des centaines d'entrées
 # (sous-sous-sections). On la limite aux niveaux hauts et à un nombre raisonnable.
 _TOC_MAX_LEVEL = 2
 _TOC_MAX_ENTRIES = 80
 # Consolidation finale : le squelette (noms seuls) est minuscule, donc l'appel
 # est quasi gratuit comparé aux MAP. Température 0 et consigne CONSERVATRICE :
 # ne fusionner que les doublons évidents, jamais des entités distinctes.
 _CONSOLIDATE_PROMPT = """Voici le squelette d'une arborescence arc → chapitre → scène issue d'une
 fusion AUTOMATIQUE de morceaux d'un livre de campagne de jeu de rôle. La fusion par nom exact
 peut avoir laissé des QUASI-DOUBLONS : le même chapitre ou la même scène sous deux libellés
 légèrement différents (ex: "La Crypte" et "Crypte de Karrak", "3. Salle des gardes" et
 "Salle des gardes").
 {skeleton}
 Identifie UNIQUEMENT les fusions ÉVIDENTES (même entité du livre sous deux noms). Sois
 CONSERVATEUR : dans le doute, ne fusionne PAS. Deux lieux/évènements distincts ne doivent
 JAMAIS être fusionnés.
 Réponds UNIQUEMENT par un objet JSON valide :
 {{"chapter_merges": [{{"into": "nom du chapitre à garder", "merge": ["nom à fusionner", ...]}}],
  "scene_merges": [{{"chapter": "nom du chapitre", "into": "nom de la scène à garder",
                     "merge": ["nom à fusionner", ...]}}]}}
 S'il n'y a RIEN à fusionner (cas le plus fréquent) : {{"chapter_merges": [], "scene_merges": []}}"""
 def _format_toc(toc) -> str:
    """Formate la TOC du PDF en liste indentée, bornée (niveaux hauts d'abord)."""
    entries = [e for e in toc if e.level <= _TOC_MAX_LEVEL][:_TOC_MAX_ENTRIES]
    if not entries:
        return ""
    return "\n".join(f"{'  ' * (e.level - 1)}- {e.title} (p. {e.page})" for e in entries)
 class _TreeMerger:
    """Fusionne les sous-arbres des morceaux en un seul arbre, ordre préservé.
@@ -255,8 +101,6 @@ class _TreeMerger:
    def __init__(self) -> None:
        # arc_key -> {"name", "description", "chapters": {chap_key -> {...}}}
        self._arcs: dict[str, dict] = {}
        # npc_key (nom en minuscules) -> {"name", "description"}
        self._npcs: dict[str, dict] = {}
    def add(self, arcs_json: list[dict]) -> None:
        for arc in arcs_json or []:
@@ -285,12 +129,8 @@ class _TreeMerger:
                        {"name": sname, "description": "", "player_narration": "",
                         "gm_notes": "", "rooms": {}})
                    self._fill_desc(s, sc)
-                    # Narration/notes : CONCATÉNATION (pas premier-gagne) — une
+                    self._fill_field(s, sc, "player_narration")
-                    # scène coupée entre deux morceaux apporte la suite de son
+                    self._fill_field(s, sc, "gm_notes")
                    # contenu dans le morceau suivant ; la jeter perdrait la
                    # moitié du donjon. Le doublon exact (overlap) est filtré.
                    self._append_field(s, sc, "player_narration")
                    self._append_field(s, sc, "gm_notes")
                    for rm in sc.get("rooms", []) or []:
                        rname = str(rm.get("name", "")).strip()
                        if not rname:
@@ -302,22 +142,6 @@ class _TreeMerger:
                        self._fill_field(r, rm, "enemies")
                        self._fill_field(r, rm, "loot")
    def add_npcs(self, npcs_json: list[dict]) -> None:
        """Accumule les PNJ détectés. Un PNJ revu dans un autre morceau garde la
        description la plus COMPLÈTE (la plus longue) — un PNJ récurrent est
        souvent décrit en détail une seule fois."""
        for npc in npcs_json or []:
            name = str(npc.get("name", "")).strip()
            if not name:
                continue
            desc = str(npc.get("description") or "").strip()
            entry = self._npcs.setdefault(name.lower(), {"name": name, "description": ""})
            if len(desc) > len(entry["description"]):
                entry["description"] = desc
    def npcs(self) -> list[NpcImportProposal]:
        return [NpcImportProposal(n["name"], n["description"]) for n in self._npcs.values()]
    @staticmethod
    def _fill_desc(node: dict, src: dict) -> None:
        if not node["description"]:
@@ -328,23 +152,6 @@ class _TreeMerger:
        if not node[field_name]:
            node[field_name] = str(src.get(field_name) or "").strip()
    @staticmethod
    def _append_field(node: dict, src: dict, field_name: str) -> None:
        """Accumule la valeur de `src` à la suite de l'existante (scène coupée
        entre deux morceaux). Ignore le vide et le contenu déjà présent (un
        morceau redondant — relecture d'overlap — ne duplique rien)."""
        new = str(src.get(field_name) or "").strip()
        if not new:
            return
        current = node[field_name]
        if not current:
            node[field_name] = new
        elif new not in current and current not in new:
            node[field_name] = current + "\n\n" + new
        elif current in new:
            # Le nouveau contenu ENGLOBE l'ancien (version plus complète) → on le prend.
            node[field_name] = new
    def result(self) -> list[ArcProposal]:
        arcs: list[ArcProposal] = []
        for a in self._arcs.values():
@@ -368,79 +175,6 @@ class _TreeMerger:
        scenes = sum(len(c["scenes"]) for a in self._arcs.values() for c in a["chapters"].values())
        return arcs, chapters, scenes
    # --- Consolidation : fusion des quasi-doublons détectés par le LLM ---------
    def skeleton_text(self) -> str:
        """Squelette de l'arbre (noms seuls) — entrée compacte de la consolidation."""
        lines: list[str] = []
        for a in self._arcs.values():
            lines.append(f"ARC: {a['name']}")
            for c in a["chapters"].values():
                lines.append(f"  CHAPITRE: {c['name']}")
                for s in c["scenes"].values():
                    lines.append(f"    SCENE: {s['name']}")
        return "\n".join(lines)
    def merge_chapters(self, into_name: str, merge_names: list[str]) -> bool:
        """Fusionne les chapitres `merge_names` dans `into_name` (tous arcs).
        Best-effort : les noms inconnus sont ignorés. Renvoie True si modifié.
        """
        target = self._find_chapter(into_name)
        if target is None:
            return False
        changed = False
        for mname in merge_names:
            key = str(mname).strip().lower()
            if not key or key == str(into_name).strip().lower():
                continue
            for a in self._arcs.values():
                src = a["chapters"].pop(key, None)
                if src is None or src is target:
                    continue
                self._fill_desc(target, src)
                for skey, sdict in src["scenes"].items():
                    if skey in target["scenes"]:
                        self._merge_scene_into(target["scenes"][skey], sdict)
                    else:
                        target["scenes"][skey] = sdict
                changed = True
        return changed
    def merge_scenes(self, chapter_name: str, into_name: str, merge_names: list[str]) -> bool:
        """Fusionne les scènes `merge_names` dans `into_name` au sein du chapitre."""
        chapter = self._find_chapter(chapter_name)
        if chapter is None:
            return False
        target = chapter["scenes"].get(str(into_name).strip().lower())
        if target is None:
            return False
        changed = False
        for mname in merge_names:
            key = str(mname).strip().lower()
            if not key or key == str(into_name).strip().lower():
                continue
            src = chapter["scenes"].pop(key, None)
            if src is None or src is target:
                continue
            self._merge_scene_into(target, src)
            changed = True
        return changed
    def _find_chapter(self, name: str) -> dict | None:
        key = str(name).strip().lower()
        for a in self._arcs.values():
            if key in a["chapters"]:
                return a["chapters"][key]
        return None
    def _merge_scene_into(self, target: dict, src: dict) -> None:
        self._fill_desc(target, src)
        self._append_field(target, src, "player_narration")
        self._append_field(target, src, "gm_notes")
        for rkey, rdict in src.get("rooms", {}).items():
            target["rooms"].setdefault(rkey, rdict)
 class ImportCampaignUseCase:
    """Transforme un PDF de campagne en proposition d'arbre arc→chapitre→scène."""
@@ -450,39 +184,22 @@ class ImportCampaignUseCase:
        llm: LLMProvider,
        extractor: PdfTextExtractor,
        chunk_target_tokens: int = _CHUNK_TARGET_TOKENS,
        map_concurrency: int = 1,
    ) -> None:
        self._llm = llm
        self._extractor = extractor
        self._chunk_target_tokens = chunk_target_tokens
        # Appels MAP par VAGUES de cette taille : l'ordre narratif est préservé
        # (fusion vague par vague, dans l'ordre du livre) mais le mur d'attente
        # des appels LLM est divisé d'autant. 1 = comportement séquentiel.
        self._map_concurrency = max(1, map_concurrency)
    async def execute(self, pdf_bytes: bytes) -> CampaignImportResult:
        """Variante non-streamée : traite tout puis renvoie l'arbre complet."""
        doc = self._extractor.extract(pdf_bytes)
        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
        toc_block = _format_toc(doc.toc)
        merger = _TreeMerger()
-        total = len(chunks)
+        for i, chunk in enumerate(chunks):
-        for start in range(0, total, self._map_concurrency):
+            merger.add(await self._map_chunk(chunk, index=i, total=len(chunks)))
            wave = list(enumerate(chunks))[start:start + self._map_concurrency]
            results = await asyncio.gather(*(
                self._map_chunk(c, index=i, total=total, toc_block=toc_block)
                for i, c in wave
            ))
            for res in results:
                merger.add(res["arcs"])
                merger.add_npcs(res["npcs"])
        if total > 1:
            await self._consolidate(merger)
        return CampaignImportResult(
            arcs=merger.result(),
            page_count=doc.page_count,
            ocr_page_count=doc.ocr_page_count,
            npcs=merger.npcs(),
        )
    async def stream(self, pdf_bytes: bytes):
@@ -497,12 +214,10 @@ class ImportCampaignUseCase:
        doc = self._extractor.extract(pdf_bytes)
        chunks = chunk_text(doc.full_text, self._chunk_target_tokens)
        toc_block = _format_toc(doc.toc)
        total = len(chunks)
        logger.info(
-            "Import campagne (stream) : %s page(s) (%s via OCR), %s morceau(x), TOC %s.",
+            "Import campagne (stream) : %s page(s) (%s via OCR), %s morceau(x).",
            doc.page_count, doc.ocr_page_count, total,
            "présente" if toc_block else "absente",
        )
        yield {
            "type": "start",
@@ -512,230 +227,52 @@ class ImportCampaignUseCase:
        }
        merger = _TreeMerger()
-        skipped = 0
+        for i, chunk in enumerate(chunks):
-        last_error: str | None = None
+            merger.add(await self._map_chunk(chunk, index=i, total=total))
-        done_count = 0
+            arcs, chapters, scenes = merger.counts()
        # Canal de statut : les couches profondes (retry LLM, re-découpage) y
        # publient des messages destinés à l'UI — cf. import_status.notify_status.
        status_queue: asyncio.Queue = asyncio.Queue()
        status_token = set_status_queue(status_queue)
        try:
            # PARALLÉLISME : les morceaux sont traités par VAGUES de `map_concurrency`
            # appels simultanés. L'ordre narratif est préservé : la fusion se fait
            # vague par vague, dans l'ordre du livre.
            # RÉSILIENCE : un morceau qui échoue (provider saturé, quota, etc.) est
            # SAUTÉ — on ne perd pas tout l'import pour autant. On n'abandonne que
            # si AUCUN morceau ne passe (cf. après la boucle).
            # HEARTBEAT : keep-alive pendant la vague d'appels LLM pour ne jamais
            # laisser le flux SSE silencieux (sinon le Core coupe sur inactivité).
            for start in range(0, total, self._map_concurrency):
                wave = list(enumerate(chunks))[start:start + self._map_concurrency]
                gathered = asyncio.gather(
                    *(self._map_chunk(c, index=i, total=total, toc_block=toc_block)
                      for i, c in wave),
                    return_exceptions=True,
                )
                results: list | None = None
                async for kind, payload in with_heartbeat(gathered, status_queue=status_queue):
                    if kind == "heartbeat":
                        yield {"type": "heartbeat", "current": done_count + 1, "total": total}
                    elif kind == "status":
                        yield {"type": "status", "message": payload,
                               "current": done_count + 1, "total": total}
                    else:
                        results = payload
                for (i, _), res in zip(wave, results or []):
                    done_count += 1
                    if isinstance(res, LLMProviderError):
                        skipped += 1
                        last_error = str(res)
                        logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, res)
                        yield {"type": "chunk_failed", "current": i + 1, "total": total,
                               "message": str(res)[:300]}
                    elif isinstance(res, BaseException):
                        raise res  # bug inattendu : ne pas l'avaler en silence
                    else:
                        merger.add((res or {}).get("arcs") or [])
                        merger.add_npcs((res or {}).get("npcs") or [])
                    arcs, chapters, scenes = merger.counts()
                    yield {
                        "type": "progress",
                        "current": done_count,
                        "total": total,
                        "arc_count": arcs,
                        "chapter_count": chapters,
                        "scene_count": scenes,
                        "npc_count": len(merger.npcs()),
                        "skipped": skipped,
                    }
            if total > 0 and skipped == total:
                # Tout a échoué : "done" vide serait trompeur → erreur explicite.
                yield {"type": "error",
                       "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
                                  f"Dernier message : {last_error or 'inconnu'}"}
                return
            if total > 0 and merger.counts()[0] == 0 and not merger.npcs():
                # Le texte a été extrait mais le modèle n'a produit AUCUNE structure
                # exploitable : sans ce signal, l'UI reçoit un `done` vide et
                # l'utilisateur conclut à tort que le PDF est illisible.
                yield {"type": "error",
                       "message": "Le texte du PDF a été extrait, mais le modèle n'a produit "
                                  "aucune structure exploitable (réponses JSON vides ou coupées). "
                                  "Réduisez la taille des morceaux d'import, augmentez la fenêtre "
                                  "de contexte (num_ctx) ou essayez un autre modèle."}
                return
            # Consolidation finale : fusion des quasi-doublons inter-morceaux
            # (best-effort, voir _consolidate). Inutile sur un import mono-morceau.
            if total > 1:
                yield {"type": "consolidating", "total": total}
                async for kind, payload in with_heartbeat(
                    self._consolidate(merger), status_queue=status_queue
                ):
                    if kind == "heartbeat":
                        yield {"type": "heartbeat", "current": total, "total": total}
                    elif kind == "status":
                        yield {"type": "status", "message": payload,
                               "current": total, "total": total}
            yield {
-                "type": "done",
+                "type": "progress",
-                "arcs": _serialize_arcs(merger.result()),
+                "current": i + 1,
-                "npcs": [{"name": n.name, "description": n.description} for n in merger.npcs()],
+                "total": total,
-                "page_count": doc.page_count,
+                "arc_count": arcs,
-                "ocr_page_count": doc.ocr_page_count,
+                "chapter_count": chapters,
-                "skipped": skipped,
+                "scene_count": scenes,
            }
        finally:
            reset_status_queue(status_token)
-    # --- Consolidation finale (fusion des quasi-doublons) ---------------------
+        yield {
-
+            "type": "done",
-    async def _consolidate(self, merger: _TreeMerger) -> None:
+            "arcs": _serialize_arcs(merger.result()),
-        """Une passe LLM sur le squelette pour fusionner les quasi-doublons.
+            "page_count": doc.page_count,
-
+            "ocr_page_count": doc.ocr_page_count,
-        BEST-EFFORT : toute erreur (LLM indisponible, JSON invalide, noms
+        }
        inconnus) laisse l'arbre tel quel — la consolidation ne peut qu'améliorer,
        jamais bloquer un import.
        """
        _, chapters, scenes = merger.counts()
        if chapters + scenes < 3:
            return  # rien à dédoublonner sur un arbre minuscule
        skeleton = merger.skeleton_text()
        try:
            raw = await generate_with_retry(
                self._llm, _CONSOLIDATE_PROMPT.format(skeleton=skeleton),
                output_format="json", temperature=0.0)
        except Exception as exc:  # noqa: BLE001 — best-effort STRICT : une erreur ici
            # (LLM, réseau, bug) ne doit JAMAIS faire perdre un import terminé.
            logger.warning("Consolidation ignorée (échec) : %s", exc)
            return
        parsed, _ = load_json_object(raw)
        if not isinstance(parsed, dict):
            logger.warning("Consolidation ignorée (réponse non-JSON).")
            return
        merged = 0
        for cm in parsed.get("chapter_merges") or []:
            if isinstance(cm, dict) and merger.merge_chapters(
                    str(cm.get("into") or ""), list(cm.get("merge") or [])):
                merged += 1
        for sm in parsed.get("scene_merges") or []:
            if isinstance(sm, dict) and merger.merge_scenes(
                    str(sm.get("chapter") or ""), str(sm.get("into") or ""),
                    list(sm.get("merge") or [])):
                merged += 1
        if merged:
            logger.info("Consolidation : %s fusion(s) de quasi-doublons appliquée(s).", merged)
    # --- MAP : un morceau → sous-arbre ---------------------------------------
-    async def _map_chunk(
+    async def _map_chunk(self, chunk: str, *, index: int, total: int) -> list[dict]:
        self, chunk: str, *, index: int, total: int, toc_block: str = ""
    ) -> dict:
        """Phase MAP d'un morceau → {"arcs": [...], "npcs": [...]}."""
        return await self._extract_payload(
            chunk, index=index, total=total, depth=0, toc_block=toc_block)
    async def _extract_payload(
        self, text: str, *, index: int, total: int, depth: int, toc_block: str = ""
    ) -> dict:
        """Extrait l'arborescence + les PNJ d'un texte. Si la SORTIE est tronquée,
        retraite le texte en DEUX moitiés et concatène — le `_TreeMerger` final
        dédoublonne par nom (un arc/chapitre coupé entre les moitiés est recollé)."""
        toc_section = _TOC_BLOCK.format(toc=toc_block) if toc_block else ""
        prompt = (
            _MAP_SYSTEM.format(default_arc=_DEFAULT_ARC_NAME)
-            + toc_section
+            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{chunk}\n\n"
            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
            "Renvoie maintenant le JSON de l'arborescence."
        )
-        try:
+        raw = await generate_with_retry(
-            raw = await generate_with_retry(
+            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-                self._llm, prompt, output_format=_TREE_SCHEMA, temperature=_TEMPERATURE)
+        return self._parse_arcs(raw, index=index)
        except LLMGenerationTimeout:
            # Génération trop lente pour la taille demandée (fréquent en local /
            # tier gratuit) : même remède que la troncature, deux moitiés →
            # sortie 2× plus courte. Re-lever si plus découpable.
            if depth >= _MAX_SPLIT_DEPTH:
                raise
            left, right = split_in_half(text)
            if not left or not right:
                raise
            logger.info(
                "Morceau %s : timeout de génération → re-découpage en 2 moitiés (niveau %s).",
                index, depth + 1)
            notify_status(
                f"Le modèle est trop lent sur le morceau {index + 1} : "
                "re-découpage en 2 moitiés plus digestes…")
            a = await self._extract_payload(
                left, index=index, total=total, depth=depth + 1, toc_block=toc_block)
            b = await self._extract_payload(
                right, index=index, total=total, depth=depth + 1, toc_block=toc_block)
            return {"arcs": a["arcs"] + b["arcs"], "npcs": a["npcs"] + b["npcs"]}
        payload, truncated = self._parse_payload(raw, index=index)
        if truncated and depth < _MAX_SPLIT_DEPTH:
            left, right = split_in_half(text)
            if left and right:
                logger.info(
                    "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
                    index, depth + 1)
                notify_status(
                    f"Réponse du modèle coupée sur le morceau {index + 1} : "
                    "re-découpage en 2 moitiés plus digestes…")
                a = await self._extract_payload(
                    left, index=index, total=total, depth=depth + 1, toc_block=toc_block)
                b = await self._extract_payload(
                    right, index=index, total=total, depth=depth + 1, toc_block=toc_block)
                return {"arcs": a["arcs"] + b["arcs"], "npcs": a["npcs"] + b["npcs"]}
        if truncated:
            logger.warning(
                "Morceau %s : sortie tronquée, profondeur max atteinte — partiel conservé.", index)
        return payload
    @staticmethod
-    def _parse_payload(raw: str, *, index: int) -> tuple[dict, bool]:
+    def _parse_arcs(raw: str, *, index: int) -> list[dict]:
-        """Parse robuste → ({"arcs", "npcs"}, tronqué). `tronqué`=True si partiel."""
+        """Parse robuste : objet JSON équilibré, ou récupération partielle si tronqué."""
        empty = {"arcs": [], "npcs": []}
        parsed, recovered = load_json_object(raw)
        if parsed is None:
-            truncated = looks_like_truncated_json(raw)
+            logger.warning("Morceau %s : aucun objet JSON exploitable, ignoré.", index)
-            if not truncated:
+            return []
-                logger.warning(
+        if recovered:
-                    "Morceau %s : aucun objet JSON exploitable, ignoré. "
+            logger.warning(
-                    "Début de la réponse du modèle : %r",
+                "Morceau %s : sortie tronquée — récupération des éléments complets "
-                    index, (raw or "").strip()[:300] or "(réponse VIDE)")
+                "(envisagez des morceaux plus petits).", index)
            return empty, truncated
        if isinstance(parsed, dict):
            arcs = parsed.get("arcs", [])
-            npcs = parsed.get("npcs", [])
+            return arcs if isinstance(arcs, list) else []
-            return {
+        return []
                "arcs": arcs if isinstance(arcs, list) else [],
                "npcs": npcs if isinstance(npcs, list) else [],
            }, recovered
        return empty, recovered
 def _serialize_arcs(arcs: list[ArcProposal]) -> list[dict]:
--- a/brain/app/application/import_rules.py
+++ b/brain/app/application/import_rules.py
@@ -13,49 +13,17 @@ Ne dépend que des abstractions du domaine (ports LLMProvider + PdfTextExtractor
 from __future__ import annotations
 import logging
 import re
-import asyncio
+from app.application.chunking import CHUNK_TARGET_TOKENS, chunk_text
-
+from app.application.llm_json import load_json_object
 from app.application.chunking import CHUNK_TARGET_TOKENS, chunk_text, split_in_half
 from app.application.import_status import (
    notify_status,
    reset_status_queue,
    set_status_queue,
 )
 from app.application.llm_json import load_json_object, looks_like_truncated_json
 from app.application.llm_retry import generate_with_retry
 from app.application.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 (
+from app.domain.ports import LLMProvider, LLMProviderError, PdfTextExtractor
    LLMGenerationTimeout,
    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é.
+_TEMPERATURE = 0.2
 # Plus la valeur est haute, plus le modèle "brode" (invente du contenu absent).
 _TEMPERATURE = 0.1
 # Schéma de la sortie attendue : objet PLAT {titre: markdown}. Passé tel quel à
 # Ollama (structured outputs : la grammaire interdit physiquement les objets
 # imbriqués, les clés "thought" à valeur non-string, le bavardage hors JSON…
 # indispensable pour les petits modèles locaux qui ne suivent pas les consignes).
 # Les adapters cloud le traduisent en mode JSON natif (json_object).
 _SECTIONS_SCHEMA: dict = {
    "type": "object",
    "additionalProperties": {"type": "string"},
 }
 # 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).
@@ -79,13 +47,9 @@ On te donne un EXTRAIT brut d'un PDF de règles (texte parfois mal coupé par la
 Ta tâche : répartir le contenu de cet extrait dans des SECTIONS THÉMATIQUES.
 Format EXACT attendu — un objet JSON plat {{titre de section: contenu markdown}} :
 {{"Combat": "## Initiative\\n\\nChaque participant lance 1d20...", "Magie et sorts": "## Sorts\\n\\n..."}}
 Règles impératives :
- Tu réponds UNIQUEMENT par cet objet JSON, sans texte avant ni après.
+- 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 (chaîne de caractères, jamais un objet ou une liste).
+- Les CLÉS sont des titres de section (texte court). Les VALEURS sont le contenu de la règle en markdown.
 - INTERDIT : des clés génériques comme "title", "content", "sections", "thought" ou "notes" ; des objets imbriqués ; tout commentaire sur ta démarche ou ton raisonnement.
 - Utilise EN PRIORITÉ ces titres canoniques quand le contenu y correspond :
 {canonical}
 - Si un contenu ne rentre dans aucun, crée un titre clair et concis (en français).
@@ -94,55 +58,6 @@ Règles impératives :
 - N'INVENTE AUCUNE règle, ne résume pas abusivement : tu réorganises, tu ne réécris pas le fond.
 - Ignore les pages de garde, sommaires, crédits, pages vides (renvoie {{}} si l'extrait n'a aucune règle)."""
 # --- Mode SEGMENTATION (modèles locaux) --------------------------------------
 # Réécrire tout le texte en JSON impose une SORTIE ≈ taille de l'ENTRÉE : à
 # ~100 tokens/s en local, un livre = des dizaines de minutes et des troncatures
 # en cascade. Ici le modèle ne renvoie que les FRONTIÈRES des sections (titre +
 # premiers mots exacts) — ~200 tokens quel que soit le morceau — et c'est NOUS
 # qui découpons le texte original. ~50× plus rapide, fidélité parfaite du
 # contenu (texte source intact), plus de troncature possible.
 _SEGMENT_SYSTEM = """Tu analyses un EXTRAIT brut d'un livre de règles de jeu de rôle.
 Ta tâche : repérer où COMMENCENT les sections thématiques. Tu ne réécris RIEN.
 Format EXACT attendu :
 {{"sections": [{{"titre": "Combat", "debut": "Le combat se déroule en tours de"}}, ...]}}
 Règles impératives :
 - "debut" = les 5 à 10 PREMIERS MOTS du passage où la section commence, COPIÉS À L'IDENTIQUE
  depuis l'extrait (même orthographe, même ponctuation, même langue). JAMAIS un résumé.
 - La PREMIÈRE entrée commence aux tout premiers mots de l'extrait (même si le contenu
  poursuit une section entamée avant cet extrait).
 - Les entrées suivent l'ordre du texte. Vise des sections LARGES (un thème), pas un titre
  par paragraphe : un extrait contient typiquement 1 à 6 sections.
 - Titres : EN PRIORITÉ parmi :
 {canonical}
  sinon un titre court et clair en français.
 - Pages de garde, sommaires, crédits : n'en fais pas des sections. Si l'extrait n'est que ça,
  renvoie {{"sections": []}}."""
 # Schéma passé à Ollama (structured outputs) : un objet {"sections": [...]}.
 # Racine objet (pas tableau) car l'extraction côté Brain repère le premier {…}.
 _ANCHORS_SCHEMA: dict = {
    "type": "object",
    "properties": {
        "sections": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "titre": {"type": "string"},
                    "debut": {"type": "string"},
                },
                "required": ["titre", "debut"],
                "additionalProperties": False,
            },
        },
    },
    "required": ["sections"],
    "additionalProperties": False,
 }
 class _SectionMerger:
    """Fusionne les sections issues des différents morceaux, ordre préservé.
@@ -178,102 +93,6 @@ class _SectionMerger:
        return {title: "\n\n".join(parts) for title, parts in self._merged.items()}
 # Clés "méta" que certains modèles glissent dans le JSON (fuite de raisonnement,
 # schéma title/content inventé…) : jamais des titres de section voulus.
 _META_KEYS = frozenset({
    "thought", "thoughts", "thinking", "reasoning", "raisonnement",
    "comment", "commentaire", "commentaires", "note", "notes", "explanation",
 })
 def _normalize_sections(parsed: dict) -> dict:
    """Ramène les formes déviantes courantes au format attendu {titre: contenu}.
    Observé sur les petits modèles locaux (gemma 12b) malgré les consignes :
      - enveloppe {"sections": {...}} ou {"règles": {...}} autour du vrai contenu ;
      - schéma inventé {"title": "...", "content": "...", "thought": "..."} →
        une seule section dont le titre est la valeur de "title" ;
      - clés méta ("thought", "notes"…) mêlées aux vraies sections → retirées.
    """
    by_lower = {str(k).strip().lower(): k for k in parsed}
    # Enveloppe : un unique conteneur connu dont la valeur est l'objet attendu.
    if len(parsed) == 1:
        only_key, only_val = next(iter(parsed.items()))
        if (isinstance(only_val, dict)
                and str(only_key).strip().lower() in {"sections", "règles", "regles", "rules"}):
            return _normalize_sections(only_val)
    # Schéma {"title": ..., "content": ...} : le titre est une VALEUR, pas une clé.
    if "title" in by_lower and "content" in by_lower:
        title = str(parsed[by_lower["title"]]).strip()
        content = parsed[by_lower["content"]]
        if title and not isinstance(content, dict):
            return {title: content}
    return {k: v for k, v in parsed.items()
            if str(k).strip().lower() not in _META_KEYS}
 def _coerce_markdown(value: object) -> str:
    """Convertit une valeur de section renvoyée par le LLM en markdown plat.
    Malgré la consigne « valeurs = markdown », certains modèles nichent des
    sous-sections ({titre: {sous-titre: contenu}}) ou des listes. Un `str(v)`
    naïf produirait du repr Python ({'k': 'v'}) ; on aplatit récursivement à la
    place pour ne perdre aucun contenu.
    """
    if isinstance(value, str):
        return value
    if isinstance(value, dict):
        parts = []
        for k, v in value.items():
            content = _coerce_markdown(v)
            # Clé = sous-titre (cas normal) ; si la "valeur" est vide, la clé
            # elle-même porte le contenu (dérive observée sur certains modèles).
            parts.append(f"{k}\n\n{content}".strip() if content else str(k))
        return "\n\n".join(parts)
    if isinstance(value, list):
        return "\n\n".join(_coerce_markdown(v) for v in value)
    return "" if value is None else str(value)
 def _find_anchor(text: str, anchor: str, start: int) -> int | None:
    """Position de `anchor` dans `text` à partir de `start`, ou None.
    Le modèle recopie les premiers mots d'un passage, mais le texte extrait du
    PDF contient des sauts de ligne/espaces multiples au même endroit, et le
    modèle normalise parfois la casse. Trois passes, de la plus stricte à la
    plus tolérante : exacte → espaces≈\\s+ → idem insensible à la casse."""
    pos = text.find(anchor, start)
    if pos != -1:
        return pos
    words = anchor.split()
    if not words:
        return None
    pattern = r"\s+".join(re.escape(w) for w in words)
    match = re.compile(pattern).search(text, start)
    if match:
        return match.start()
    match = re.compile(pattern, re.IGNORECASE).search(text, start)
    return match.start() if match else None
 def _combine_sections(a: dict[str, str], b: dict[str, str]) -> dict[str, str]:
    """Fusionne deux dicts de sections (issus des 2 moitiés d'un morceau re-découpé).
    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."""
@@ -282,16 +101,10 @@ class ImportRulesUseCase:
        llm: LLMProvider,
        extractor: PdfTextExtractor,
        chunk_target_tokens: int = CHUNK_TARGET_TOKENS,
        segment_only: bool = False,
    ) -> None:
        """`segment_only=True` (modèles locaux) : le LLM ne renvoie que les
        frontières des sections (titre + premiers mots) et le texte original est
        découpé localement — sortie minuscule, pas de réécriture. False (cloud) :
        le LLM réécrit le contenu en sections markdown nettoyées."""
        self._llm = llm
        self._extractor = extractor
        self._chunk_target_tokens = chunk_target_tokens
        self._segment_only = segment_only
    async def execute(self, pdf_bytes: bytes) -> RulesImportResult:
        """Variante non-streamée : traite tout puis renvoie le résultat complet."""
@@ -337,216 +150,48 @@ class ImportRulesUseCase:
        }
        merger = _SectionMerger()
-        skipped = 0
+        for i, chunk in enumerate(chunks):
-        last_error: str | None = None
+            new_titles = merger.add(await self._map_chunk(chunk, index=i, total=total))
-        # Canal de statut : les couches profondes (retry LLM, re-découpage) y
+            yield {
-        # publient des messages destinés à l'UI — cf. import_status.notify_status.
+                "type": "progress",
-        status_queue: asyncio.Queue = asyncio.Queue()
+                "current": i + 1,
-        status_token = set_status_queue(status_queue)
+                "total": total,
-        try:
+                "new_sections": new_titles,
-            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),
                        status_queue=status_queue,
                    ):
                        if kind == "heartbeat":
                            yield {"type": "heartbeat", "current": i + 1, "total": total}
                        elif kind == "status":
                            yield {"type": "status", "message": payload,
                                   "current": i + 1, "total": total}
                        else:
                            sections = payload
                    new_titles = merger.add(sections or {})
                except LLMProviderError as exc:
                    skipped += 1
                    last_error = str(exc)
                    logger.warning("Morceau %s/%s ignoré (échec LLM) : %s", i + 1, total, exc)
                    yield {"type": "chunk_failed", "current": i + 1, "total": total,
                           "message": str(exc)[:300]}
                yield {
                    "type": "progress",
                    "current": i + 1,
                    "total": total,
                    "new_sections": new_titles,
                    "skipped": skipped,
                }
        finally:
            reset_status_queue(status_token)
        if total > 0 and skipped == total:
            yield {"type": "error",
                   "message": "Tous les morceaux ont échoué auprès du fournisseur IA. "
                              f"Dernier message : {last_error or 'inconnu'}"}
            return
        sections = merger.result()
        if total > 0 and not sections:
            # Le texte a bien été extrait mais AUCUN morceau n'a produit de JSON
            # exploitable (sorties coupées/illisibles). Sans ce signal, l'UI reçoit
            # un `done` vide et l'utilisateur conclut à tort que le PDF est illisible.
            yield {"type": "error",
                   "message": "Le texte du PDF a été extrait, mais le modèle n'a produit "
                              "aucune section exploitable (réponses JSON vides ou coupées). "
                              "Réduisez la taille des morceaux d'import, augmentez la fenêtre "
                              "de contexte (num_ctx) ou essayez un autre modèle."}
            return
        yield {
            "type": "done",
-            "sections": sections,
+            "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."""
        system = _SEGMENT_SYSTEM if self._segment_only else _MAP_SYSTEM
        schema = _ANCHORS_SCHEMA if self._segment_only else _SECTIONS_SCHEMA
        prompt = (
-            system.format(
+            _MAP_SYSTEM.format(
                canonical="\n".join(f"  - {s}" for s in _CANONICAL_SECTIONS)
            )
-            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{text}\n\n"
+            + f"\n\n--- EXTRAIT {index + 1}/{total} ---\n{chunk}\n\n"
            "Renvoie maintenant le JSON des sections."
        )
-        try:
+        raw = await generate_with_retry(
-            raw = await generate_with_retry(
+            self._llm, prompt, output_format="json", temperature=_TEMPERATURE)
-                self._llm, prompt, output_format=schema, temperature=_TEMPERATURE)
+        return self._parse_sections(raw, index=index)
        except LLMGenerationTimeout:
            # Le modèle générait mais trop lentement pour réécrire tout le morceau
            # dans le temps imparti (fréquent sur tier gratuit + gros morceaux).
            # Même remède que la troncature : deux moitiés → sortie 2× plus courte.
            if depth >= _MAX_SPLIT_DEPTH:
                raise
            left, right = split_in_half(text)
            if not left or not right:
                raise
            logger.info(
                "Morceau %s : timeout de génération → re-découpage en 2 moitiés (niveau %s).",
                index, depth + 1)
            notify_status(
                f"Le modèle est trop lent sur le morceau {index + 1} : "
                "re-découpage en 2 moitiés plus digestes…")
            a = await self._extract_sections(left, index=index, total=total, depth=depth + 1)
            b = await self._extract_sections(right, index=index, total=total, depth=depth + 1)
            return _combine_sections(a, b)
        if self._segment_only:
            sections, truncated = self._parse_anchors(raw, text, index=index)
        else:
            sections, truncated = self._parse_sections(raw, index=index)
-        if truncated and depth < _MAX_SPLIT_DEPTH:
+    @staticmethod
-            left, right = split_in_half(text)
+    def _parse_sections(raw: str, *, index: int) -> dict[str, str]:
-            if left and right:
+        """Parse robuste : objet JSON équilibré, ou récupération partielle si tronqué."""
-                logger.info(
+        parsed, recovered = load_json_object(raw)
-                    "Morceau %s : sortie tronquée → re-découpage en 2 moitiés (niveau %s).",
+        if parsed is None:
-                    index, depth + 1)
+            logger.warning("Morceau %s : aucun objet JSON exploitable, ignoré.", index)
-                notify_status(
+            return {}
-                    f"Réponse du modèle coupée sur le morceau {index + 1} : "
+        if recovered:
                    "re-découpage en 2 moitiés plus digestes…")
                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)
+                "Morceau %s : sortie tronquée — récupération des sections complètes "
-        return sections
+                "(envisagez des morceaux plus petits).", index)
    @staticmethod
    def _parse_anchors(raw: str, text: str, *, index: int) -> tuple[dict[str, str], bool]:
        """Mode segmentation : réponse {"sections": [{titre, debut}, …]} → on localise
        chaque `debut` dans le texte ORIGINAL et on découpe entre les ancres.
        Une ancre introuvable est abandonnée (son contenu reste dans la section
        précédente — aucun texte n'est perdu). Le texte avant la première ancre
        trouvée est rattaché à la première section (le prompt demande au modèle de
        faire démarrer la première entrée aux premiers mots de l'extrait)."""
        parsed, recovered = load_json_object(raw)
        if parsed is None:
            truncated = looks_like_truncated_json(raw)
            if not truncated:
                logger.warning(
                    "Morceau %s : aucun objet JSON exploitable (segmentation), ignoré. "
                    "Début de la réponse du modèle : %r",
                    index, (raw or "").strip()[:300] or "(réponse VIDE)")
            return {}, truncated
        entries = parsed.get("sections") if isinstance(parsed, dict) else None
        if not isinstance(entries, list):
            logger.warning("Morceau %s : pas de liste 'sections' exploitable, ignoré.", index)
            return {}, False
        # Localisation séquentielle : chaque ancre est cherchée APRÈS la précédente
        # (préserve l'ordre du texte, évite qu'une phrase répétée matche trop tôt).
        located: list[tuple[str, int]] = []
        cursor = 0
        dropped = 0
        for entry in entries:
            if not isinstance(entry, dict):
                continue
            title = str(entry.get("titre") or "").strip()
            anchor = str(entry.get("debut") or "").strip()
            if not title or not anchor:
                continue
            pos = _find_anchor(text, anchor, cursor)
            if pos is None:
                dropped += 1
                continue
            located.append((title, pos))
            cursor = pos + 1
        if dropped:
            logger.info(
                "Morceau %s : %s ancre(s) de section introuvable(s) — contenu rattaché "
                "à la section précédente.", index, dropped)
        if not located:
            return {}, False
        # Découpe entre ancres ; le préambule éventuel rejoint la première section.
        located[0] = (located[0][0], 0)
        sections: dict[str, str] = {}
        for i, (title, start) in enumerate(located):
            end = located[i + 1][1] if i + 1 < len(located) else len(text)
            content = text[start:end].strip()
            if not content:
                continue
            if title in sections:
                sections[title] = f"{sections[title]}\n\n{content}"
            else:
                sections[title] = content
        return sections, recovered
    @staticmethod
    def _parse_sections(raw: str, *, index: int) -> tuple[dict[str, str], bool]:
        """Parse robuste → (sections, tronqué). `tronqué`=True si récupération partielle."""
        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 {}
-        normalized = _normalize_sections(parsed)
+        return {str(k): str(v) for k, v in parsed.items()}
        return {str(k): _coerce_markdown(v) for k, v in normalized.items()}, recovered
--- a/brain/app/application/import_status.py
+++ b/brain/app/application/import_status.py
@@ -1,39 +0,0 @@
 """Canal de statut des imports : remonte à l'UI ce qui n'existait qu'en logs.
 Problème résolu : pendant un import, les événements internes (retry parce que
 le fournisseur IA est saturé, re-découpage d'un morceau trop gros…) n'étaient
 visibles que dans les logs Docker. L'utilisateur voyait une barre de
 progression figée sans explication.
 Mécanisme : le flux d'import (use case `stream()`) installe une Queue dans une
 ContextVar ; les couches profondes (retry LLM, re-découpage) y publient des
 messages via `notify_status()` sans connaître le flux SSE. La ContextVar est
 propagée automatiquement aux tâches asyncio enfants → chaque import concurrent
 a SA queue, sans couplage ni paramètre à faire transiter partout.
 """
 from __future__ import annotations
 import asyncio
 from contextvars import ContextVar, Token
 _QUEUE: ContextVar[asyncio.Queue | None] = ContextVar("import_status_queue", default=None)
 def set_status_queue(queue: asyncio.Queue | None) -> Token:
    """Installe la queue de statut pour le contexte courant (et ses tâches filles).
    Renvoie le token à passer à `reset_status_queue` en fin d'import.
    """
    return _QUEUE.set(queue)
 def reset_status_queue(token: Token) -> None:
    _QUEUE.reset(token)
 def notify_status(message: str) -> None:
    """Publie un message de statut si un import écoute. No-op sinon (appels
    LLM hors import : chat, génération de page…)."""
    queue = _QUEUE.get()
    if queue is not None:
        queue.put_nowait(message)
--- a/brain/app/application/llm_json.py
+++ b/brain/app/application/llm_json.py
@@ -13,16 +13,6 @@ et tout ce qui suit. Renvoie None si aucun objet complet n'est trouvé
 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]:
@@ -34,45 +24,21 @@ def load_json_object(raw: str) -> tuple[object | None, bool]:
        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:
-            # strict=False : tolère les caractères de contrôle BRUTS (retours à la
+            return json.loads(obj), False
            # ligne non échappés…) dans les chaînes — erreur fréquente des LLM hors
            # mode JSON natif, qui invalidait toute la réponse.
            return json.loads(obj, strict=False), False
        except json.JSONDecodeError:
            pass
    repaired = repair_truncated_json(raw)
    if repaired is not None:
        try:
-            return json.loads(repaired, strict=False), True
+            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).
    Une réponse qui COMMENCE par `{` est jugée sur le seul équilibre des accolades,
    même très courte : en mode JSON un `{"` de 2 caractères est une génération
    interrompue net (contexte plein, plafond de sortie), pas de la prose — c'est le
    signal de re-découpage. Pour le reste (prose contenant des accolades), on exige
    un contenu substantiel pour éviter les faux positifs."""
    s = _strip_reasoning(raw or "").strip()
    if "{" not in s:
        return False
    unbalanced = s.count("{") > s.count("}") or s.count("[") > s.count("]")
    if s.startswith("{"):
        return unbalanced
    return len(s) >= 100 and unbalanced
 def extract_json_object(raw: str) -> str | None:
    if not raw:
        return None
--- a/brain/app/application/llm_retry.py
+++ b/brain/app/application/llm_retry.py
@@ -12,106 +12,36 @@ from __future__ import annotations
 import asyncio
 import logging
 import re
-from app.application.import_status import notify_status
+from app.domain.ports import LLMProvider, LLMProviderError
 from app.domain.ports import LLMGenerationTimeout, 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
+_BASE_DELAY_SECONDS = 2.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 | dict | None = None,
+    output_format: str | None = None,
    temperature: float | None = None,
 ) -> str:
-    """Comme `llm.generate`, mais réessaie les erreurs transitoires (backoff).
+    """Comme `llm.generate`, mais réessaie les erreurs transitoires (backoff x2)."""
    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 LLMGenerationTimeout:
            # Timeout de DÉBIT (génération trop lente pour la sortie demandée) :
            # rejouer le même prompt re-timeoutera à l'identique — on a déjà perdu
            # `timeout` secondes. On remonte tout de suite : l'appelant (import)
            # sait re-découper le morceau en deux pour réduire la sortie.
            raise
        except LLMProviderError as exc:
            last_error = exc
            # Quota JOURNALIER épuisé : inutile d'insister, on remonte tout de suite
            # (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.",
+                    "Appel LLM échoué (tentative %s/%s) : %s — nouvelle tentative dans %ss.",
-                    attempt + 1, _ATTEMPTS, " [rate limit]" if _is_rate_limit(exc) else "",
+                    attempt + 1, _ATTEMPTS, exc, delay,
                    exc, wait,
                )
-                # Remonte aussi l'info à l'UI (flux d'import) : sans ça l'utilisateur
+                await asyncio.sleep(delay)
-                # voit une barre figée sans savoir que le fournisseur est saturé.
+                delay *= 2
                notify_status(
                    ("Fournisseur IA saturé (rate limit)" if _is_rate_limit(exc)
                     else "Appel IA échoué")
                    + f" — tentative {attempt + 1}/{_ATTEMPTS}, nouvel essai dans {int(wait)}s. "
                    + str(exc)[:160]
                )
                await asyncio.sleep(wait)
    assert last_error is not None
    raise last_error
--- a/brain/app/application/notebook_chat.py
+++ b/brain/app/application/notebook_chat.py
@@ -1,119 +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.application.query_rewrite import standalone_question
 from app.application.rerank import pool_size, rerank
 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, rerank_enabled: bool = False
    ) -> None:
        self._rag = rag
        self._llm = llm
        # Reranking LLM d'un pool élargi avant injection (voir app.application.rerank).
        self._rerank_enabled = rerank_enabled
    async def stream(
        self,
        source_ids: list[str],
        messages: list[ChatMessage],
        context: str = "",
        top_k: int = 6,
    ) -> AsyncIterator[dict]:
        """Yield des évènements : {type:'sources', sources:[…]} (une fois, avant la
        réponse — transparence sur les passages utilisés), puis {type:'token', token}."""
        # Question AUTONOME pour la recherche : sur une relance (« et ses
        # faiblesses ? »), l'embedding du dernier message seul ne contient pas
        # le sujet → on le résout depuis l'historique (best-effort, 1 appel léger,
        # uniquement à partir du 2e tour). La réponse, elle, voit tout l'historique.
        search_query = await standalone_question(self._llm, messages)
        if self._rerank_enabled:
            # Pool élargi → notation LLM → top_k final (meilleure précision sur
            # les questions ambiguës, au prix d'un appel avant le premier token).
            pool = await self._rag.retrieve(
                source_ids, search_query, top_k=pool_size(top_k))
            passages = await rerank(self._llm, search_query, pool, top_k)
        else:
            passages = await self._rag.retrieve(source_ids, search_query, top_k=top_k)
        # Évènement 'sources' AVANT le premier token : l'UI peut afficher les
        # pages utilisées (« 📖 p. 12, 47 ») dès le début de la réponse.
        yield {"type": "sources", "sources": [
            {
                "source_id": p.get("source_id"),
                "page": p.get("page"),
                "score": round(float(p.get("score") or 0.0), 3),
            }
            for p in passages
        ]}
        sources_block = (
            "\n\n".join(self._format_passage(p) for p in passages)
            if passages else "(aucun passage pertinent trouvé dans les sources)"
        )
        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 {"type": "token", "token": 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()}"
--- a/brain/app/application/notebook_deep.py
+++ b/brain/app/application/notebook_deep.py
@@ -1,285 +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 asyncio
 import logging
 from typing import AsyncIterator
 import tiktoken
 from app.application.llm_retry import generate_with_retry
 from app.application.query_rewrite import standalone_question
 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
 # --- Index de résumés (pré-filtrage des lots) --------------------------------
 # Sans index : CHAQUE question relit TOUT le document (1 appel LLM par lot).
 # Avec : les résumés de lots (construits UNE fois, cache disque) sont comparés
 # à la question par embedding, et seuls les lots plausiblement pertinents sont
 # relus. Sélection volontairement CONSERVATRICE (on préfère relire un lot de
 # trop que rater une mention) ; désactivable via deep_summary_filter=False.
 _SUMMARY_PROMPT = """Résume l'EXTRAIT ci-dessous en 4 à 8 puces factuelles : lieux, PNJ et
 créatures nommés, objets notables, évènements, règles particulières. Pas d'analyse, pas
 d'introduction — uniquement les puces, pour servir d'index de recherche.
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Résumé :"""
 # Un lot est gardé si son score est proche du meilleur (marge) OU bon dans
 # l'absolu ; et on garde toujours au moins _MIN_KEPT lots.
 _SELECT_MARGIN = 0.10
 _SELECT_FLOOR = 0.5
 _MIN_KEPT = 3
 _MAP_PROMPT = """Voici un EXTRAIT d'un document. Extrais UNIQUEMENT les informations
 pertinentes pour répondre à la question ci-dessous. Conserve les détails utiles et
 indique les numéros de page (format « p. X »). Si l'extrait ne contient RIEN de
 pertinent, réponds EXACTEMENT « {no_match} » et rien d'autre.
 QUESTION : {question}
 --- EXTRAIT ---
 {excerpt}
 --- FIN EXTRAIT ---
 Informations pertinentes (ou « {no_match} ») :"""
 _REDUCE_SYSTEM = """Tu es l'assistant-MJ d'un jeu de rôle. Tu réponds à la demande du MJ en
 t'appuyant sur TROIS sources : (1) des NOTES extraites de l'ENSEMBLE du document source (vue
 complète — mais POSSIBLEMENT VIDE si rien d'utile n'y figure), (2) le contexte de sa CAMPAGNE,
 (3) la conversation ci-dessous.
 - Si les notes contiennent des éléments utiles : exploite-les et CITE les pages (« p. X »).
 - Si les notes sont VIDES ou pauvres (cas fréquent d'une demande CRÉATIVE portant sur des
  éléments INVENTÉS par le MJ) : ne te bloque surtout PAS. Aide-le quand même en t'appuyant
  sur sa CAMPAGNE, la CONVERSATION et ta connaissance du genre — propose des adaptations
  concrètes (arcs, chapitres, scènes, PNJ), structurées et jouables.
 - Sois concret et utile. N'affirme rien de FAUX sur le contenu du document.
 {context_block}
 --- NOTES EXTRAITES DE TOUT LE DOCUMENT ---
 {notes_block}
 --- FIN DES NOTES ---
 Réponds en français."""
 class NotebookDeepUseCase:
    def __init__(
        self,
        llm: LLMProvider,
        batch_tokens: int = 10000,
        map_concurrency: int = 1,
        embedder=None,
        summary_filter: bool = True,
    ) -> None:
        self._llm = llm
        self._batch_tokens = max(2000, batch_tokens)
        # Lots MAP traités par vagues de cette taille (parallélisme LLM).
        self._map_concurrency = max(1, map_concurrency)
        # EmbeddingProvider (duck typing) pour l'index de résumés ; None = pas
        # de pré-filtrage (plein scan, comportement historique).
        self._embedder = embedder
        self._summary_filter = summary_filter
    async def stream(
        self,
        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 autonome : la phase MAP lit chaque lot avec LA question — sur
        # une relance conversationnelle, il faut y résoudre les références
        # implicites, sinon les lots sont filtrés sur un texte sans sujet.
        question = await standalone_question(self._llm, messages)
        # Lots PAR SOURCE (l'index de résumés est caché par source).
        per_source: list[tuple[str, list[dict]]] = []
        for sid in source_ids:
            chunks = vector_store.all_chunks(sid)
            for batch in self._group(chunks):
                per_source.append((sid, batch))
        if not per_source:
            yield {"type": "token", "token": "Aucune source indexée à analyser."}
            yield {"type": "done"}
            return
        # Pré-filtrage par index de résumés (best-effort : tout échec → plein scan).
        selected: set[int] | None = None
        if self._summary_filter and self._embedder is not None:
            try:
                async for ev_or_result in self._select_batches(per_source, question):
                    if isinstance(ev_or_result, dict):
                        yield ev_or_result  # progress de construction de l'index
                    else:
                        selected = ev_or_result
            except Exception as exc:  # noqa: BLE001 — le filtre ne doit jamais bloquer
                logger.warning("Index de résumés ignoré (échec) : %s", exc)
                selected = None
        if selected is not None:
            logger.info(
                "Analyse approfondie : %s/%s lot(s) retenus via l'index de résumés.",
                len(selected), len(per_source))
        indices = sorted(selected) if selected is not None else list(range(len(per_source)))
        total = len(indices)
        notes: list[str] = []
        # Lots traités par VAGUES parallèles ; les notes restent dans l'ordre du
        # document (gather préserve l'ordre des tâches de la vague).
        for start in range(0, total, self._map_concurrency):
            yield {"type": "progress", "current": start, "total": total}
            wave = indices[start:start + self._map_concurrency]
            results = await asyncio.gather(
                *(self._map_batch(question, per_source[i][1]) for i in wave),
                return_exceptions=True)
            for j, res in enumerate(results):
                if isinstance(res, LLMProviderError):
                    logger.warning(
                        "Analyse approfondie : lot %s/%s ignoré : %s", start + j + 1, total, res)
                elif isinstance(res, BaseException):
                    raise res  # bug inattendu : ne pas l'avaler
                elif res:
                    notes.append(res)
        yield {"type": "progress", "current": total, "total": total}
        notes_block = "\n\n".join(notes) if notes else "(aucune information pertinente trouvée dans le document)"
        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]
        produced = False
        async for token in llm_chat.stream_chat(reduce_messages, system_prompt=system_prompt):
            if token:
                produced = True
                yield {"type": "token", "token": token}
        if not produced:
            # Jamais de bulle vide : message de repli + orientation vers le mode rapide,
            # mieux adapté aux demandes créatives (et qui propose des cartes d'action).
            yield {"type": "token", "token": (
                "Je n'ai pas trouvé d'éléments pertinents dans le document pour cette demande "
                "(elle porte sans doute sur des éléments que tu as inventés). Pour une "
                "**adaptation créative** — proposer des arcs, chapitres, scènes ou PNJ — "
                "utilise plutôt le bouton **« Envoyer »** (mode rapide) : il est conversationnel, "
                "voit ta campagne, et te propose des cartes « Créer dans la campagne »."
            )}
        yield {"type": "done"}
    # --- Index de résumés ------------------------------------------------------
    async def _select_batches(self, per_source: list[tuple[str, list[dict]]], question: str):
        """Générateur : yield des évènements `progress` pendant la construction de
        l'index (1ère analyse d'une source), puis le set des indices retenus —
        ou None si le filtre n'apporte rien (tous retenus)."""
        # 1. Charge/construit les résumés par source (cache disque).
        by_sid: dict[str, list[int]] = {}
        for i, (sid, _) in enumerate(per_source):
            by_sid.setdefault(sid, []).append(i)
        vectors: list[list[float] | None] = [None] * len(per_source)
        to_build = []
        for sid, idxs in by_sid.items():
            cached = vector_store.load_summaries(sid, self._batch_tokens)
            if cached is not None and len(cached) == len(idxs):
                for i, entry in zip(idxs, cached):
                    vectors[i] = entry.get("vector")
            else:
                to_build.append((sid, idxs))
        total_build = sum(len(idxs) for _, idxs in to_build)
        done_build = 0
        for sid, idxs in to_build:
            summaries: list[str] = []
            for start in range(0, len(idxs), self._map_concurrency):
                yield {"type": "progress", "current": done_build, "total": total_build}
                wave = idxs[start:start + self._map_concurrency]
                results = await asyncio.gather(
                    *(self._summarize_batch(per_source[i][1]) for i in wave))
                summaries.extend(results)
                done_build += len(wave)
            vecs = await self._embedder.embed(summaries, kind="document")
            entries = [{"summary": s, "vector": v} for s, v in zip(summaries, vecs)]
            vector_store.save_summaries(sid, self._batch_tokens, entries)
            for i, entry in zip(idxs, entries):
                vectors[i] = entry["vector"]
        # 2. Score de chaque lot face à la question, sélection conservatrice.
        qv = (await self._embedder.embed([question], kind="query"))[0]
        scores = [
            vector_store.cosine_similarity(qv, v) if v else 0.0
            for v in vectors
        ]
        best = max(scores)
        keep = {i for i, s in enumerate(scores) if s >= best - _SELECT_MARGIN or s >= _SELECT_FLOOR}
        floor = min(_MIN_KEPT, len(scores))
        if len(keep) < floor:
            keep = set(sorted(range(len(scores)), key=lambda i: -scores[i])[:floor])
        yield keep if len(keep) < len(scores) else None
    async def _summarize_batch(self, batch: list[dict]) -> str:
        excerpt = "\n\n".join(c.get("text", "").strip() for c in batch)
        raw = await generate_with_retry(
            self._llm, _SUMMARY_PROMPT.format(excerpt=excerpt), temperature=_MAP_TEMPERATURE)
        return (raw or "").strip()
    async def _map_batch(self, question: str, batch: list[dict]) -> str:
        """Phase MAP d'un lot : extrait les infos pertinentes ('' si RAS)."""
        excerpt = "\n\n".join(
            f"(p. {c['page']}) {c['text'].strip()}" if c.get("page") else c["text"].strip()
            for c in batch
        )
        prompt = _MAP_PROMPT.format(no_match=_NO_MATCH, question=question, excerpt=excerpt)
        raw = await generate_with_retry(self._llm, prompt, temperature=_MAP_TEMPERATURE)
        answer = raw.strip()
        if answer and answer.upper().rstrip(".") != _NO_MATCH:
            return answer
        return ""
    def _group(self, chunks: list[dict]) -> list[list[dict]]:
        """Regroupe les extraits en lots ~`batch_tokens` (compte tiktoken)."""
        enc = tiktoken.get_encoding("cl100k_base")
        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
--- a/brain/app/application/notebook_rag.py
+++ b/brain/app/application/notebook_rag.py
@@ -1,94 +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
 # Recouvrement entre extraits consécutifs (~13% de la cible) : une phrase-clé à
 # cheval sur deux extraits reste retrouvable dans au moins l'un des deux.
 _RAG_OVERLAP_TOKENS = 80
 # Un extrait avec quasi aucun texte réel (en-tête/pied de page, fragment de numéro
 # de page isolé « 249 250 ») ne sert à rien en RAG → on l'écarte. Seuil bas et
 # conservateur : on ne coupe QUE les fragments quasi-vides, jamais une vraie phrase.
 _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,
        min_score: float = 0.0,
    ) -> None:
        self._extractor = extractor
        self._embedder = embedder
        self._chunk_target_tokens = chunk_target_tokens
        # Cosinus minimal pour qu'un extrait soit injecté dans le prompt : sous ce
        # seuil, l'extrait n'a aucun rapport avec la question → bruit. 0 = désactivé.
        self._min_score = min_score
    async def index_source(self, source_id: str, pdf_bytes: bytes) -> dict:
        """Extrait, découpe PAR PAGE (pour garder le n° de page → citations), embed
        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, overlap_tokens=_RAG_OVERLAP_TOKENS
            ):
                if not _has_enough_text(piece):
                    continue  # fragment quasi-vide (en-tête/pied/numéro) → ignoré
                chunks.append(piece)
                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`.
        Recherche hybride (cosinus + bonus lexical sur les mots de la question) ;
        peut renvoyer moins de `top_k` passages si le seuil de pertinence écarte
        les extraits hors-sujet."""
        ids = [s for s in source_ids if vector_store.exists(s)]
        if not ids or not query.strip():
            return []
        query_vectors = await self._embedder.embed([query], kind="query")
        if not query_vectors:
            return []
        return vector_store.search(
            ids, query_vectors[0], top_k, query_text=query, min_score=self._min_score
        )
--- a/brain/app/application/query_rewrite.py
+++ b/brain/app/application/query_rewrite.py
@@ -1,66 +0,0 @@
 """Réécriture de la question courante en question AUTONOME (chat des ateliers).
 Problème : le retrieval (embedding) et la phase MAP de l'analyse approfondie ne
 voient que le DERNIER message. Une relance comme « et ses faiblesses ? » ne
 contient pas le sujet (Strahd) → recherche aveugle. La parade standard
 (conversational query rewriting) : un appel LLM léger condense la conversation
 en une question autonome, utilisée UNIQUEMENT pour la recherche — la réponse
 finale, elle, voit toujours l'historique complet.
 """
 from __future__ import annotations
 import logging
 from app.domain.models import ChatMessage
 logger = logging.getLogger(__name__)
 # Nombre de messages récents fournis au réécrivain (assez pour résoudre les
 # pronoms, pas plus — la latence de cet appel doit rester négligeable).
 _MAX_HISTORY = 6
 # Garde-fou : une « question » réécrite anormalement longue est suspecte (le
 # modèle a divagué) → on retombe sur la question brute.
 _MAX_REWRITE_CHARS = 400
 _REWRITE_PROMPT = """Voici la fin d'une conversation entre un Maître de Jeu et son assistant.
 Réécris le DERNIER message de l'utilisateur en une question AUTONOME et complète :
 remplace les pronoms et références implicites (« il », « ses », « ce lieu », « et pour
 les autres ? ») par ce qu'ils désignent dans la conversation.
 Règles :
 - Réponds UNIQUEMENT par la question réécrite, sans guillemets ni préfixe.
 - Conserve la langue et l'intention d'origine. N'ajoute RIEN qui n'est pas demandé.
 - Si le dernier message est déjà autonome, recopie-le tel quel.
 --- CONVERSATION ---
 {conversation}
 --- FIN ---
 Question autonome :"""
 async def standalone_question(llm, messages: list[ChatMessage]) -> str:
    """Condense `messages` en une question autonome pour la RECHERCHE.
    Best-effort : premier message de la conversation, échec LLM ou réponse
    suspecte → on renvoie simplement la dernière question brute (comportement
    historique). `llm` doit exposer `generate()` (duck typing des adapters).
    """
    last_user = next((m.content for m in reversed(messages) if m.role == "user"), "")
    user_turns = sum(1 for m in messages if m.role == "user" and m.content.strip())
    if user_turns <= 1 or not last_user.strip():
        return last_user  # pas d'historique à résoudre → appel LLM inutile
    recent = [m for m in messages if m.content.strip()][-_MAX_HISTORY:]
    conversation = "\n".join(f"{m.role.upper()}: {m.content.strip()}" for m in recent)
    try:
        raw = await llm.generate(
            _REWRITE_PROMPT.format(conversation=conversation), temperature=0.0)
    except Exception as exc:  # noqa: BLE001 — la recherche dégradée vaut mieux que pas de réponse
        logger.warning("Réécriture de question ignorée (échec LLM) : %s", exc)
        return last_user
    rewritten = (raw or "").strip().strip('"').strip()
    if not rewritten or len(rewritten) > _MAX_REWRITE_CHARS:
        return last_user
    return rewritten
--- a/brain/app/application/rerank.py
+++ b/brain/app/application/rerank.py
@@ -1,73 +0,0 @@
 """Reranking LLM des passages RAG (chat des ateliers).
 Le cosinus classe par similarité de SURFACE ; sur les questions ambiguës, des
 passages proches lexicalement mais inutiles passent devant l'extrait qui répond
 vraiment. Le reranking récupère un POOL élargi (ex. 3× top_k), fait noter la
 pertinence de chaque extrait par le LLM en UN appel, et garde les top_k mieux
 notés. Coût : ~1 appel LLM avant le premier token — opt-in via RAG_RERANK.
 """
 from __future__ import annotations
 import logging
 from app.application.llm_json import load_json_object
 logger = logging.getLogger(__name__)
 # Taille du pool élargi : multiple du top_k demandé, plafonné (le prompt de
 # notation doit rester raisonnable même avec rag_top_k élevé).
 POOL_FACTOR = 3
 POOL_MAX = 24
 # Un extrait long n'a pas besoin d'être noté en entier : tronquer borne le
 # prompt sans changer le jugement de pertinence.
 _EXCERPT_CHARS = 600
 _RERANK_PROMPT = """Tu évalues la PERTINENCE d'extraits d'un document pour répondre à une question.
 Note chaque extrait de 0 (sans rapport) à 10 (répond directement), indépendamment des autres.
 QUESTION : {question}
 {passages}
 Réponds UNIQUEMENT par un objet JSON : {{"scores": [note_extrait_1, note_extrait_2, ...]}}
 Le tableau doit contenir EXACTEMENT {count} notes, dans l'ordre des extraits."""
 def pool_size(top_k: int) -> int:
    """Taille du pool à récupérer avant reranking."""
    return min(max(top_k * POOL_FACTOR, top_k), POOL_MAX)
 async def rerank(llm, question: str, passages: list[dict], top_k: int) -> list[dict]:
    """Renvoie les `top_k` passages les mieux notés par le LLM (tri stable :
    à note égale, l'ordre cosinus d'origine est préservé).
    BEST-EFFORT : échec LLM, JSON invalide ou nombre de notes incohérent →
    on renvoie simplement les `top_k` premiers du classement cosinus.
    """
    if len(passages) <= top_k:
        return passages
    numbered = "\n\n".join(
        f"--- EXTRAIT {i + 1} ---\n{(p.get('text') or '')[:_EXCERPT_CHARS]}"
        for i, p in enumerate(passages)
    )
    prompt = _RERANK_PROMPT.format(
        question=question, passages=numbered, count=len(passages))
    try:
        raw = await llm.generate(prompt, temperature=0.0)
    except Exception as exc:  # noqa: BLE001 — un chat dégradé vaut mieux que pas de chat
        logger.warning("Reranking ignoré (échec LLM) : %s", exc)
        return passages[:top_k]
    parsed, _ = load_json_object(raw)
    scores = parsed.get("scores") if isinstance(parsed, dict) else None
    if not isinstance(scores, list) or len(scores) != len(passages):
        logger.warning("Reranking ignoré (notes inexploitables).")
        return passages[:top_k]
    try:
        scored = [(float(s), i) for i, s in enumerate(scores)]
    except (TypeError, ValueError):
        logger.warning("Reranking ignoré (notes non numériques).")
        return passages[:top_k]
    order = sorted(range(len(passages)), key=lambda i: (-scored[i][0], i))
    return [passages[i] for i in order[:top_k]]
--- a/brain/app/application/streaming.py
+++ b/brain/app/application/streaming.py
@@ -1,67 +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,
    status_queue: "asyncio.Queue | None" = None,
 ) -> AsyncIterator[tuple[str, Any]]:
    """Exécute `coro` en émettant ('heartbeat', None) toutes les `interval`s tant
    qu'elle n'est pas terminée, puis ('result', valeur).
    Si `status_queue` est fournie, les messages qui y sont publiés pendant
    l'exécution (cf. import_status.notify_status : retry LLM, re-découpage…)
    sont émis AU FIL DE L'EAU sous forme ('status', message) — c'est ce qui
    permet à l'UI d'expliquer une attente au lieu d'une barre figée.
    L'exception éventuelle de `coro` est propagée (re-levée par `task.result()`),
    donc l'appelant peut l'attraper normalement. Si l'itération est abandonnée
    (client déconnecté), la tâche sous-jacente est annulée.
    """
    task: asyncio.Task = asyncio.ensure_future(coro)
    getter: asyncio.Task | None = None
    try:
        while not task.done():
            waiters: set[asyncio.Task] = {task}
            if status_queue is not None and getter is None:
                getter = asyncio.ensure_future(status_queue.get())
            if getter is not None:
                waiters.add(getter)
            done, _ = await asyncio.wait(
                waiters, timeout=interval, return_when=asyncio.FIRST_COMPLETED)
            if getter is not None and getter in done:
                yield ("status", getter.result())
                getter = None  # un nouveau get() sera créé au tour suivant
            if not done:
                yield ("heartbeat", None)
        # Vide les statuts restés en file (publiés juste avant la fin de la tâche).
        if status_queue is not None:
            while not status_queue.empty():
                yield ("status", status_queue.get_nowait())
        yield ("result", task.result())
    finally:
        if getter is not None and not getter.done():
            getter.cancel()
        if not task.done():
            task.cancel()
--- a/brain/app/core/config.py
+++ b/brain/app/core/config.py
@@ -25,9 +25,8 @@ 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"
@@ -48,67 +47,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
    # Analyse approfondie : pré-filtrage des lots via un index de résumés
    # (construit une fois par source, cache disque). Les questions ciblées ne
    # relisent que les lots plausiblement pertinents (3-5x moins d'appels) ;
    # False = relire TOUT le document à chaque question (exhaustivité maximale).
    deep_summary_filter: bool = True
    # Reranking LLM du chat atelier : recupere un pool elargi (3x top_k, max 24)
    # puis fait NOTER la pertinence de chaque extrait par le LLM avant d'injecter
    # les top_k meilleurs. Meilleure precision sur les questions ambigues, MAIS
    # +1 appel LLM avant le premier token (quelques secondes sur un petit modele
    # local). Desactive par defaut ; recommande avec un provider cloud rapide.
    rag_rerank: bool = False
    # Cosinus minimal pour qu'un extrait soit injecté dans le prompt du chat
    # atelier : en dessous, l'extrait n'a aucun rapport avec la question → mieux
    # vaut moins d'extraits que du bruit. Défaut conservateur (0.30) : les paires
    # pertinentes scorent typiquement 0.6+ avec nomic-embed-text/mistral-embed,
    # les hors-sujet 0.2-0.4. Montable à ~0.4 si trop de bruit, 0 = désactivé.
    rag_min_score: float = 0.30
    # Nombre d'appels LLM MAP menes EN PARALLELE (import de campagne, analyse
    # approfondie). 3 = bon defaut cloud (divise le temps d'un gros livre par ~3).
    # Ollama local sequence les requetes de toute facon (pas de gain, pas de mal).
    # Baisser a 1 si un provider gratuit rate-limite agressivement.
    llm_map_concurrency: int = 3
    # Taille cible d'un morceau (en tokens) pour l'import de PDF (regles/campagne).
    # Plus c'est gros, moins il y a de morceaux => moins de fragmentation et un
    # import plus rapide, MAIS il faut que ca tienne dans la fenetre du modele.
--- a/brain/app/core/settings_store.py
+++ b/brain/app/core/settings_store.py
@@ -29,17 +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",
 })
--- a/brain/app/domain/models.py
+++ b/brain/app/domain/models.py
@@ -320,26 +320,11 @@ class ExtractedPage:
    used_ocr: bool
@dataclass(frozen=True)
 class TocEntry:
    """Une entrée de la table des matières (bookmarks/outline) du PDF.
    `level` : profondeur 1-based (1 = chapitre, 2 = section…). `page` : 1-based.
    """
    level: int
    title: str
    page: int
@dataclass(frozen=True)
 class ExtractedDocument:
    """Résultat brut de l'extraction d'un PDF : une entrée par page."""
    pages: list[ExtractedPage]
    # Table des matières (bookmarks PDF). Vide si le PDF n'en a pas — fréquent
    # pour les scans ; les livres born-digital en ont presque toujours une.
    toc: list[TocEntry] = field(default_factory=list)
    @property
    def page_count(self) -> int:
@@ -424,18 +409,6 @@ class ArcProposal:
    chapters: list[ChapterProposal] = field(default_factory=list)
@dataclass(frozen=True)
 class NpcImportProposal:
    """PNJ/créature notable détecté à l'import d'un PDF de campagne.
    PNJ NOMMÉS et créatures uniques (boss) — pas les monstres génériques.
    `description` = courte fiche (rôle, apparence, motivations, où on le croise).
    """
    name: str
    description: str = ""
@dataclass(frozen=True)
 class CampaignImportResult:
    """Proposition d'arborescence narrative extraite d'un PDF de campagne.
@@ -447,9 +420,6 @@ class CampaignImportResult:
    arcs: list[ArcProposal]
    page_count: int
    ocr_page_count: int
    # PNJ/créatures notables détectés au fil des morceaux (proposition, à cocher
    # dans l'écran de revue avant création).
    npcs: list[NpcImportProposal] = field(default_factory=list)
    def counts(self) -> tuple[int, int, int]:
        """(nb arcs, nb chapitres, nb scènes) — pour le diagnostic / la progression."""
--- a/brain/app/domain/ports.py
+++ b/brain/app/domain/ports.py
@@ -24,20 +24,17 @@ class LLMProvider(Protocol):
        self,
        prompt: str,
        *,
-        output_format: str | dict | None = None,
+        output_format: str | None = None,
        temperature: float | None = None,
    ) -> str:
        """Génère une réponse textuelle à partir d'un prompt donné.
        Args:
            prompt: le texte envoyé au modèle.
-            output_format: contrainte de format optionnelle. "json" pour forcer
+            output_format: contrainte de format optionnelle. Exemple : "json"
-                un JSON valide ; un dict = SCHÉMA JSON décrivant la structure
+                pour forcer le modèle à renvoyer du JSON valide. Les
-                attendue (les fournisseurs qui supportent les sorties
+                fournisseurs qui ne supportent pas une valeur donnée doivent
-                structurées — ex. Ollama — contraignent la génération au schéma,
+                l'ignorer silencieusement ou la traduire au mieux.
                les autres retombent sur leur mode JSON natif). Les fournisseurs
                qui ne supportent pas une valeur donnée doivent l'ignorer
                silencieusement ou la traduire au mieux.
            temperature: créativité du modèle, 0.0 (déterministe/factuel) à
                1.0+ (très créatif, hallucine plus facilement). None =
                valeur par défaut de l'adapter. Recommandation LoreMind :
@@ -116,14 +113,3 @@ class LLMProviderError(Exception):
    Définie dans le domaine (pas dans l'infra) pour que les couches
    supérieures puissent l'attraper sans connaître l'adapter concret.
    """
 class LLMGenerationTimeout(LLMProviderError):
    """La génération a démarré mais n'a pas FINI dans le temps imparti.
    Cas distinct d'un échec transitoire (file d'attente, 503) : le modèle
    produisait des tokens mais trop lentement pour la taille de sortie demandée.
    Réessayer à l'identique est inutile (même entrée → même lenteur) ; la bonne
    réaction est de RÉDUIRE la sortie demandée (ex. import : re-découper le
    morceau en deux moitiés).
    """
--- a/brain/app/infrastructure/gemini_adapter.py
+++ b/brain/app/infrastructure/gemini_adapter.py
@@ -1,194 +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 LLMGenerationTimeout, 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 LLMGenerationTimeout(
                f"Erreur Gemini : génération non terminée en {self._timeout}s. Réduisez la "
                "taille des morceaux d'import ou augmentez le timeout."
            ) from exc
    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
        # Mode JSON natif (supporté par l'endpoint OpenAI-compatible de Gemini) :
        # supprime fences ```json et JSON invalide, principale cause de morceaux
        # ignorés. Un SCHÉMA (dict) est traduit en json_object : suffisant, les
        # grands modèles cloud respectent la structure demandée par le prompt.
        if output_format is not None:
            body["response_format"] = {"type": "json_object"}
        async with httpx.AsyncClient(timeout=self._timeout) as client:
            try:
                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()
                        # 401/403 = clé rejetée par GOOGLE (pas un problème LoreMind) :
                        # message actionnable plutôt que le JSON brut de l'API.
                        if response.status_code in (401, 403):
                            raise LLMProviderError(
                                "Erreur Gemini : clé API refusée par Google "
                                f"(HTTP {response.status_code}). Vérifiez que la clé vient bien "
                                "de aistudio.google.com (« Get API key ») et qu'elle n'a pas de "
                                "restrictions (API ou adresse IP) dans la Google Cloud Console. "
                                f"Détail : {detail[:300]}"
                            )
                        raise LLMProviderError(
                            f"Erreur Gemini (HTTP {response.status_code})"
                            + (f" : {detail[:500]}" if detail else "")
                        )
                    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}"
--- a/brain/app/infrastructure/mistral_adapter.py
+++ b/brain/app/infrastructure/mistral_adapter.py
@@ -1,195 +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 LLMGenerationTimeout, 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 LLMGenerationTimeout(
                f"Erreur Mistral : génération non terminée en {self._timeout}s. Réduisez la "
                "taille des morceaux d'import, augmentez le timeout, ou changez de modèle."
            ) from exc
    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
        # Mode JSON natif : TOUS les modèles Mistral le supportent → plus de fences
        # ```json ni de JSON invalide (retours à la ligne bruts dans les chaînes),
        # principale cause de morceaux d'import ignorés. Un SCHÉMA (dict) est
        # traduit en json_object : suffisant ici, les grands modèles cloud
        # respectent la structure demandée par le prompt.
        if output_format is not None:
            body["response_format"] = {"type": "json_object"}
        async with httpx.AsyncClient(timeout=self._timeout) as client:
            try:
                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}"
--- a/brain/app/infrastructure/mistral_embedding_adapter.py
+++ b/brain/app/infrastructure/mistral_embedding_adapter.py
@@ -1,59 +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], kind: str = "document") -> list[list[float]]:
        # `kind` ignoré : mistral-embed n'utilise pas de préfixe de tâche.
        if not texts:
            return []
        out: list[list[float]] = []
        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
--- a/brain/app/infrastructure/ollama_adapter.py
+++ b/brain/app/infrastructure/ollama_adapter.py
@@ -5,16 +5,13 @@ Isole le reste de l'application des spécificités du protocole Ollama
 demain, on écrit un nouvel adapter sans toucher au reste du code.
 """
 import json
 import logging
 from typing import AsyncIterator
 import httpx
 from app.core.config import Settings
 from app.domain.models import ChatMessage
-from app.domain.ports import LLMGenerationTimeout, LLMProviderError
+from app.domain.ports import LLMProviderError
 logger = logging.getLogger(__name__)
 class OllamaLLMProvider:
@@ -48,7 +45,7 @@ class OllamaLLMProvider:
        self,
        prompt: str,
        *,
-        output_format: str | dict | None = None,
+        output_format: str | None = None,
        temperature: float | None = None,
    ) -> str:
        url = f"{self._base_url}/api/generate"
@@ -58,10 +55,6 @@ class OllamaLLMProvider:
            "stream": False,
            "options": self._build_options(temperature),
        }
        # "json" (mode JSON simple) ou un SCHÉMA JSON complet (structured outputs) :
        # Ollama contraint alors la grammaire de génération au schéma — un petit
        # modèle local ne PEUT physiquement plus produire d'objets imbriqués, de
        # clés "thought" bavardes ou de texte hors JSON.
        if output_format is not None:
            payload["format"] = output_format
@@ -78,45 +71,12 @@ class OllamaLLMProvider:
                    raise LLMProviderError(
                        f"Ollama HTTP {response.status_code} : {err_msg.strip()[:500]}"
                    )
            except httpx.ConnectTimeout as exc:
                # Serveur injoignable : erreur d'infrastructure, pas de lenteur.
                raise LLMProviderError(
                    f"Erreur lors de l'appel à Ollama : {exc}"
                ) from exc
            except httpx.TimeoutException as exc:
                # `stream: False` → le read-timeout court jusqu'à la réponse COMPLÈTE,
                # donc le dépasser = génération trop lente pour la sortie demandée
                # (fréquent : modèle local modeste + gros morceau d'import à réécrire).
                # Type dédié → pas de retry à l'identique ; l'import re-découpe le
                # morceau en deux moitiés (sortie 2× plus courte) à la place.
                raise LLMGenerationTimeout(
                    f"Erreur Ollama : génération non terminée en {self._timeout}s. Réduisez "
                    "la taille des morceaux d'import, augmentez le timeout, ou utilisez un "
                    "modèle plus rapide."
                ) from exc
            except httpx.HTTPError as exc:
                raise LLMProviderError(
                    f"Erreur lors de l'appel à Ollama : {exc}"
                ) from exc
-        data = response.json()
+        return response.json()["response"]
        # Diagnostic crucial pour les imports : `done_reason` != "stop" signifie que
        # la génération a été INTERROMPUE (fenêtre de contexte pleine, num_predict…)
        # et non terminée par le modèle. Sans ce log, on ne voit qu'un JSON coupé
        # en aval, sans la cause. `prompt_eval_count` révèle aussi la VRAIE taille
        # du prompt en tokens du modèle (les morceaux sont mesurés en tokens
        # cl100k, ~20-40% plus compacts que les tokenizers locaux).
        done_reason = data.get("done_reason")
        if done_reason and done_reason != "stop":
            logger.warning(
                "Ollama a interrompu la génération (done_reason=%s) : prompt=%s tokens, "
                "sortie=%s tokens, num_ctx demandé=%s. Si prompt+sortie ≈ num_ctx, la "
                "fenêtre de contexte est pleine : réduisez la taille des morceaux "
                "d'import ou augmentez num_ctx (Paramètres).",
                done_reason, data.get("prompt_eval_count"),
                data.get("eval_count"), self._num_ctx,
            )
        return data["response"]
    async def stream_chat(
        self,
--- a/brain/app/infrastructure/ollama_embedding_adapter.py
+++ b/brain/app/infrastructure/ollama_embedding_adapter.py
@@ -1,62 +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
 # Préfixes de tâche des modèles nomic-embed : le modèle est ENTRAÎNÉ avec
 # (search_document pour le corpus, search_query pour la question). Sans eux,
 # la pertinence du retrieval est mesurablement dégradée. Ne s'applique qu'aux
 # modèles nomic — les autres (mxbai, bge…) ont leurs propres conventions ou
 # aucune ; on reste neutre pour eux.
 _NOMIC_PREFIXES = {"document": "search_document: ", "query": "search_query: "}
 class OllamaEmbeddingProvider:
    """Implémente EmbeddingProvider via Ollama /api/embed (batch)."""
    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
    def _prepare(self, texts: list[str], kind: str) -> list[str]:
        """Applique le préfixe de tâche si le modèle est de la famille nomic-embed.
        NB : les sources indexées AVANT l'introduction des préfixes doivent être
        ré-uploadées pour que documents et questions vivent dans le même espace.
        """
        if "nomic-embed" not in self._model:
            return texts
        prefix = _NOMIC_PREFIXES.get(kind, _NOMIC_PREFIXES["document"])
        return [prefix + t for t in texts]
    async def embed(self, texts: list[str], kind: str = "document") -> list[list[float]]:
        if not texts:
            return []
        url = f"{self._base_url}/api/embed"
        payload = {"model": self._model, "input": self._prepare(texts, kind)}
        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]
--- a/brain/app/infrastructure/ollama_model_installer.py
+++ b/brain/app/infrastructure/ollama_model_installer.py
@@ -1,51 +0,0 @@
 """Auto-installation du modèle d'embeddings Ollama au démarrage du Brain.
 Adapter d'infrastructure : parle directement à l'API HTTP d'Ollama. Best-effort
 (Ollama peut être absent / la connexion limitée) — n'empêche jamais le démarrage.
 """
 from __future__ import annotations
 import asyncio
 import logging
 import httpx
 logger = logging.getLogger(__name__)
 async def ensure_ollama_embedding_model(base_url: str, model: str) -> None:
    """Télécharge `model` sur le serveur Ollama s'il n'y est pas déjà.
    Attend qu'Ollama soit joignable (ordre de démarrage des conteneurs), puis
    vérifie la présence du modèle avant de le tirer.
    """
    for attempt in range(10):
        try:
            async with httpx.AsyncClient(timeout=10) as client:
                tags = await client.get(f"{base_url}/api/tags")
                tags.raise_for_status()
                names = [m.get("name", "") for m in tags.json().get("models", [])]
            if any(n == model or n.startswith(model + ":") for n in names):
                logger.info("Modèle d'embedding '%s' déjà présent.", model)
                return
            break  # Ollama joignable, modèle absent → on tire (ci-dessous)
        except httpx.HTTPError:
            await asyncio.sleep(min(5 * (attempt + 1), 30))
    else:
        logger.warning(
            "Ollama injoignable au démarrage — modèle d'embedding '%s' non auto-installé "
            "(il sera tirable manuellement : ollama pull %s).", model, model)
        return
    logger.info("Téléchargement automatique du modèle d'embedding '%s'…", model)
    try:
        async with httpx.AsyncClient(timeout=None) as client:
            async with client.stream("POST", f"{base_url}/api/pull", json={"name": model}) as resp:
                resp.raise_for_status()
                async for _line in resp.aiter_lines():
                    pass  # on draine la progression NDJSON jusqu'à la fin
        logger.info("Modèle d'embedding '%s' prêt.", model)
    except httpx.HTTPError as exc:
        logger.warning(
            "Auto-installation du modèle d'embedding '%s' échouée : %s "
            "(tirage manuel possible : ollama pull %s).", model, exc, model)
--- a/brain/app/infrastructure/openrouter_adapter.py
+++ b/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 LLMGenerationTimeout, 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 LLMGenerationTimeout(
                f"Erreur {provider} : génération non terminée en {self._timeout}s. Réduisez la "
                "taille des morceaux d'import, augmentez le timeout, ou changez de modèle."
            ) from exc
    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}"
--- a/brain/app/infrastructure/pdf_extractor.py
+++ b/brain/app/infrastructure/pdf_extractor.py
@@ -22,7 +22,7 @@ import pymupdf as fitz  # PyMuPDF — on importe par le nom canonique `pymupdf`
 # (et NON `import fitz`) pour éviter la collision avec le faux paquet PyPI "fitz"
 # qui échoue sur `from frontend import *`.
-from app.domain.models import ExtractedDocument, ExtractedPage, TocEntry
+from app.domain.models import ExtractedDocument, ExtractedPage
 from app.domain.ports import PdfExtractionError
 logger = logging.getLogger(__name__)
@@ -72,18 +72,7 @@ class PyMuPdfTextExtractor:
            raise PdfExtractionError(f"PDF illisible ou corrompu : {exc}") from exc
        pages: list[ExtractedPage] = []
        toc: list[TocEntry] = []
        try:
            # Bookmarks/outline du PDF : structure officielle du livre, gratuite
            # (pas d'appel LLM). Sert de squelette de référence aux imports.
            try:
                for level, title, page_no in doc.get_toc(simple=True) or []:
                    title = str(title or "").strip()
                    if title:
                        toc.append(TocEntry(level=int(level), title=title, page=int(page_no)))
            except Exception as exc:  # noqa: BLE001 — TOC best-effort, jamais bloquante
                logger.warning("Lecture de la table des matières impossible : %s", exc)
            for index, page in enumerate(doc):
                text = (page.get_text() or "").strip()
                used_ocr = False
@@ -96,7 +85,7 @@ class PyMuPdfTextExtractor:
        finally:
            doc.close()
-        return ExtractedDocument(pages=pages, toc=toc)
+        return ExtractedDocument(pages=pages)
    @staticmethod
    def _ocr_page(page: "fitz.Page") -> str:
--- a/brain/app/infrastructure/vector_store.py
+++ b/brain/app/infrastructure/vector_store.py
@@ -1,218 +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.
 Les fichiers sont mis en cache mémoire (invalidation par mtime) : le coûteux est
 le re-parse JSON des vecteurs, pas le cosinus.
 Recherche HYBRIDE : score = cosinus + bonus lexical (mots significatifs de la
 question présents dans l'extrait). Sur du JdR, les requêtes sont souvent des noms
 propres exacts (« Strahd », « Barovia ») où le lexical bat l'embedding.
 """
 from __future__ import annotations
 import json
 import math
 import re
 from pathlib import Path
 _STORE_DIR = Path("data/notebooks")
 _SAFE_ID = re.compile(r"[^A-Za-z0-9_-]")
 # Cache mémoire {source_id: (mtime_ns, chunks)} — évite de relire/re-parser le JSON
 # (vecteurs = gros) à chaque question. Invalidé si le fichier change (mtime).
 _CACHE: dict[str, tuple[int, list[dict]]] = {}
 _CACHE_MAX_SOURCES = 32  # garde-fou mémoire : ~10 Mo par gros livre en cache
 # Poids du bonus lexical dans le score hybride. Le cosinus reste dominant ; le
 # bonus (0..0.15) sert surtout à départager / repêcher les correspondances exactes.
 _LEX_WEIGHT = 0.15
 _WORD_RE = re.compile(r"[a-z0-9àâäçéèêëîïôöùûüœæ]{3,}")
 # Mots-outils FR/EN fréquents (≥3 lettres) : sans eux, le bonus lexical serait
 # dominé par « les », « pour », « the »… au lieu des termes porteurs de sens.
 _STOPWORDS = frozenset({
    "les", "des", "une", "est", "son", "ses", "aux", "par", "pour", "dans",
    "sur", "avec", "qui", "que", "quoi", "dont", "mais", "comme", "plus",
    "pas", "tout", "tous", "toute", "toutes", "ils", "elles", "leur", "leurs",
    "nous", "vous", "cette", "ces", "cet", "ont", "sont", "fait", "etre",
    "être", "avoir", "peut", "quel", "quelle", "quels", "quelles", "ainsi",
    "the", "and", "for", "with", "this", "that", "are", "was", "has", "have",
    "not", "you", "his", "her", "its", "they", "them", "from", "what", "which",
 })
 def _path(source_id: str) -> Path:
    safe = _SAFE_ID.sub("_", str(source_id))
    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")
    _CACHE.pop(source_id, None)  # le mtime suffirait, mais soyons explicites
    return len(chunks)
 def exists(source_id: str) -> bool:
    return _path(source_id).exists()
 def delete(source_id: str) -> None:
    _CACHE.pop(source_id, None)
    _path(source_id).unlink(missing_ok=True)
    _summaries_path(source_id).unlink(missing_ok=True)
 # --- Index de résumés (analyse approfondie) ----------------------------------
 # Cache disque des résumés PAR LOT d'une source : construit paresseusement à la
 # première analyse approfondie, réutilisé ensuite pour ne relire que les lots
 # pertinents. Invalidé avec la source (delete) et si batch_tokens change.
 def _summaries_path(source_id: str) -> Path:
    safe = _SAFE_ID.sub("_", str(source_id))
    return _STORE_DIR / f"{safe}.summaries.json"
 def save_summaries(source_id: str, batch_tokens: int, entries: list[dict]) -> None:
    """Persiste les résumés de lots ({"summary": str, "vector": [...]})."""
    _STORE_DIR.mkdir(parents=True, exist_ok=True)
    payload = {"batch_tokens": int(batch_tokens), "entries": entries}
    _summaries_path(source_id).write_text(
        json.dumps(payload, ensure_ascii=False), encoding="utf-8")
 def load_summaries(source_id: str, batch_tokens: int) -> list[dict] | None:
    """Résumés de lots d'une source, ou None si absents / construits avec une
    autre taille de lot (le découpage ne correspondrait plus)."""
    p = _summaries_path(source_id)
    if not p.exists():
        return None
    try:
        data = json.loads(p.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return None
    if not isinstance(data, dict) or data.get("batch_tokens") != int(batch_tokens):
        return None
    entries = data.get("entries")
    return entries if isinstance(entries, list) else None
 def _load(source_id: str) -> list[dict]:
    p = _path(source_id)
    try:
        mtime = p.stat().st_mtime_ns
    except OSError:
        _CACHE.pop(source_id, None)
        return []
    cached = _CACHE.get(source_id)
    if cached is not None and cached[0] == mtime:
        return cached[1]
    try:
        data = json.loads(p.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return []
    chunks = data.get("chunks", []) if isinstance(data, dict) else []
    if len(_CACHE) >= _CACHE_MAX_SOURCES:
        _CACHE.pop(next(iter(_CACHE)))  # éviction FIFO simple
    _CACHE[source_id] = (mtime, chunks)
    return chunks
 def all_chunks(source_id: str) -> list[dict]:
    """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 _significant_words(text: str) -> frozenset[str]:
    """Mots porteurs de sens d'un texte (minuscules, ≥3 lettres, hors mots-outils)."""
    return frozenset(w for w in _WORD_RE.findall(text.lower()) if w not in _STOPWORDS)
 def _chunk_words(chunk: dict) -> frozenset[str]:
    """Mots significatifs d'un extrait, mémoïsés sur le dict caché (calculés à la
    1ère recherche, réutilisés tant que la source reste en cache)."""
    words = chunk.get("_words")
    if words is None:
        words = _significant_words(chunk.get("text", ""))
        chunk["_words"] = words
    return words
 # Alias public du cosinus (réutilisé par l'index de résumés de l'analyse
 # approfondie — même métrique que la recherche).
 cosine_similarity = _cosine
 def search(
    source_ids: list[str],
    query_vector: list[float],
    top_k: int = 6,
    query_text: str = "",
    min_score: float = 0.0,
 ) -> list[dict]:
    """Renvoie les `top_k` extraits les plus proches, toutes sources confondues.
    Score HYBRIDE : cosinus + `_LEX_WEIGHT` × (part des mots significatifs de
    `query_text` présents dans l'extrait). Les extraits dont le cosinus est sous
    `min_score` sont écartés (peut donc renvoyer MOINS de `top_k` résultats —
    mieux vaut aucun extrait que du bruit injecté dans le prompt).
    Chaque résultat : {"text": str, "score": float, "source_id": str, "page": int|None}.
    """
    query_words = _significant_words(query_text) if query_text else frozenset()
    scored: list[dict] = []
    for sid in source_ids:
        for chunk in _load(sid):
            vector = chunk.get("vector") or []
            cos = _cosine(query_vector, vector)
            if cos < min_score:
                continue
            score = cos
            if query_words:
                overlap = len(query_words & _chunk_words(chunk)) / len(query_words)
                score += _LEX_WEIGHT * overlap
            scored.append({
                "text": chunk.get("text", ""),
                "score": score,
                "source_id": sid,
                "page": chunk.get("page"),
            })
    scored.sort(key=lambda c: c["score"], reverse=True)
    return scored[:top_k]
--- a/brain/app/main.py
+++ b/brain/app/main.py
--- a/brain/requirements.txt
+++ b/brain/requirements.txt
@@ -1,8 +1,4 @@
-fastapi==0.136.*
+fastapi==0.115.*
 # Pin EXPLICITE : fastapi n'exige que starlette>=0.46.0 — sans ce pin, un
 # environnement existant peut garder une starlette vulnérable.
 # >= 0.49.1 : corrige CVE-2025-54121 et CVE-2025-62727.
 starlette>=0.49.1,<1.0
 uvicorn[standard]==0.32.*
 httpx==0.27.*
 pydantic-settings==2.6.*
@@ -24,6 +20,4 @@ tiktoken==0.8.*
 #     (le binaire tesseract-ocr est installe dans le Dockerfile, langues fra+eng)
 pymupdf==1.24.*
 pytesseract==0.3.*
-# 12.2+ : corrige 6 CVE de parsing d'images (surface critique : pages de PDF
+Pillow==11.*
 # uploadés par l'utilisateur rasterisées puis passées à l'OCR).
 Pillow==12.2.*
--- a/brain/scripts/sanity_rag_check.py
+++ b/brain/scripts/sanity_rag_check.py
@@ -1,84 +0,0 @@
 # -*- coding: utf-8 -*-
 """Sanity check temporaire : overlap du chunking + recherche hybride du vector store."""
 import sys
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 from app.application.chunking import chunk_text
 # --- 1. Chunking avec overlap ---
 paras = [f"Paragraphe {i} : " + ("lorem ipsum dolor sit amet " * 8) for i in range(12)]
 text = "\n\n".join(paras)
 no_overlap = chunk_text(text, target_tokens=200)
 with_overlap = chunk_text(text, target_tokens=200, overlap_tokens=40)
 assert len(with_overlap) >= len(no_overlap), "l'overlap ne doit pas réduire le nb de chunks"
 # Chaque chunk (sauf le 1er) doit commencer par la fin du précédent
 overlapped = 0
 for prev, cur in zip(with_overlap, with_overlap[1:]):
    first_para = cur.split("\n\n")[0]
    if first_para in prev:
        overlapped += 1
 assert overlapped >= len(with_overlap) - 2, f"overlap absent: {overlapped}/{len(with_overlap)-1}"
 # Pas de chunk composé uniquement de l'overlap (dernier chunk dupliqué)
 assert with_overlap[-1] != with_overlap[-2], "dernier chunk = pur overlap (dupliqué)"
 # overlap_tokens=0 → comportement identique à l'ancien
 assert no_overlap == chunk_text(text, target_tokens=200, overlap_tokens=0)
 print(f"[OK] chunking : {len(no_overlap)} chunks sans overlap, {len(with_overlap)} avec ({overlapped} recouvrements)")
 # --- Paragraphe géant ---
 giant = "mot " * 2000
 sub = chunk_text(giant, target_tokens=300, overlap_tokens=50)
 assert len(sub) > 1
 print(f"[OK] paragraphe géant coupé en {len(sub)} sous-blocs")
 # --- 2. Vector store : hybride + seuil + cache ---
 import tempfile, os
 from app.infrastructure import vector_store
 with tempfile.TemporaryDirectory() as tmp:
    vector_store._STORE_DIR = Path(tmp)
    chunks = [
        "Strahd von Zarovich règne sur la sombre vallée de Barovia depuis son château.",
        "Les règles de combat utilisent un d20 plus le modificateur de caractéristique.",
        "La taverne du village sert un ragoût de navets aux voyageurs fatigués.",
    ]
    # Vecteurs factices : chunk 0 et 1 proches de la query, chunk 2 orthogonal
    vectors = [[1.0, 0.1, 0.0], [0.9, 0.4, 0.1], [0.0, 0.0, 1.0]]
    vector_store.save("src1", chunks, vectors, pages=[10, 20, 30])
    q = [1.0, 0.2, 0.0]
    # Sans seuil ni texte : 3 résultats, ordre cosinus
    r = vector_store.search(["src1"], q, top_k=10)
    assert len(r) == 3 and r[0]["page"] == 10
    # Avec seuil : le chunk orthogonal (cos~0) est écarté
    r = vector_store.search(["src1"], q, top_k=10, min_score=0.30)
    assert len(r) == 2, f"seuil non appliqué: {len(r)}"
    print(f"[OK] seuil : 2/3 extraits gardés (orthogonal écarté)")
    # Bonus lexical : la query mentionne « Strahd Barovia » → chunk 0 doit dominer
    r = vector_store.search(["src1"], q, top_k=10, query_text="Parle-moi de Strahd et de Barovia", min_score=0.30)
    assert r[0]["text"].startswith("Strahd"), r[0]["text"]
    assert r[0]["score"] > vector_store._cosine(q, vectors[0]), "bonus lexical absent"
    print(f"[OK] hybride : bonus lexical appliqué (score={r[0]['score']:.3f})")
    # Le set "_words" mémoïsé ne doit PAS fuiter dans les résultats
    assert all("_words" not in res for res in r)
    # Cache : 2e recherche sert depuis la mémoire (même objet liste)
    c1 = vector_store._load("src1")
    c2 = vector_store._load("src1")
    assert c1 is c2, "cache mtime inopérant"
    # save() invalide le cache
    vector_store.save("src1", chunks[:1], vectors[:1], pages=[10])
    c3 = vector_store._load("src1")
    assert len(c3) == 1, "cache non invalidé après save"
    # delete() purge cache + fichier
    vector_store.delete("src1")
    assert vector_store._load("src1") == []
    print("[OK] cache mémoire : hit, invalidation save, purge delete")
 print("\nTous les sanity checks passent.")
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -8,22 +8,18 @@
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.5.14</version>
+        <version>3.2.12</version>
        <relativePath/>
    </parent>
    <groupId>com.loremind</groupId>
    <artifactId>loremind-core</artifactId>
-    <version>0.12.4-beta</version>
+    <version>0.10.1-beta</version>
    <name>LoreMind Core</name>
    <description>Backend Core - Architecture Hexagonale</description>
    <properties>
        <java.version>17</java.version>
        <!-- Override de la transitive minio → commons-compress → commons-lang3 3.17.
             >= 3.18 : corrige CVE-2025-48924 (recursion infinie ClassUtils.getClass).
             Propriete reconnue par le BOM Spring Boot → s'applique partout. -->
        <commons-lang3.version>3.20.0</commons-lang3.version>
    </properties>
    <dependencies>
@@ -81,52 +77,33 @@
            <scope>test</scope>
        </dependency>
-        <!-- MinIO — client S3-compatible pour le stockage d'images (Shared Kernel images).
+        <!-- MinIO — client S3-compatible pour le stockage d'images (Shared Kernel images). -->
             8.6.x = derniere ligne 8.x (la 9.x change l'API) ; transitives a jour. -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
-            <version>8.6.0</version>
+            <version>8.5.11</version>
            <exclusions>
                <!-- OkHttp 5 : l'artefact `okhttp` est un alias multiplateforme dont la
                     resolution vers les classes JVM passe par les metadonnees Gradle —
                     que Maven ignore. On exclut l'alias et on declare `okhttp-jvm`
                     (les vraies classes) explicitement ci-dessous. -->
                <exclusion>
                    <groupId>com.squareup.okhttp3</groupId>
                    <artifactId>okhttp</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp-jvm</artifactId>
            <version>5.1.0</version>
        </dependency>
        <!-- Nimbus JOSE+JWT — verification des JWT Ed25519 (EdDSA) emis par le relais
-             Patreon. Supporte nativement les cles Ed25519 via BouncyCastle.
+             Patreon. Supporte nativement les cles Ed25519 via BouncyCastle. -->
             >= 10.0.2 : corrige CVE-2025-53864 (DoS par JSON profondement imbrique
             dans le claim set — surface critique : JWT colle par l'utilisateur). -->
        <dependency>
            <groupId>com.nimbusds</groupId>
            <artifactId>nimbus-jose-jwt</artifactId>
-            <version>10.9.1</version>
+            <version>9.40</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk18on</artifactId>
-            <version>1.84</version>
+            <version>1.78.1</version>
        </dependency>
        <!-- Google Tink : runtime requis par com.nimbusds.jose.crypto.Ed25519Verifier
             (depuis Nimbus 9.x, la verification EdDSA delegue a Tink.subtle.Ed25519Verify).
             Tink n'est PAS une dependance transitive de nimbus-jose-jwt → il faut
-             l'ajouter explicitement, sinon NoClassDefFoundError au premier verify().
+             l'ajouter explicitement, sinon NoClassDefFoundError au premier verify(). -->
             >= 1.15 : embarque un protobuf-java corrige (CVE-2024-7254). -->
        <dependency>
            <groupId>com.google.crypto.tink</groupId>
            <artifactId>tink</artifactId>
-            <version>1.21.0</version>
+            <version>1.14.1</version>
        </dependency>
    </dependencies>
--- a/core/src/main/java/com/loremind/application/campaigncontext/CampaignAdaptService.java
+++ b/core/src/main/java/com/loremind/application/campaigncontext/CampaignAdaptService.java
@@ -1,32 +1,46 @@
 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.campaigncontext.ports.CampaignPdfAdvisor;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 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;
 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
+ * <p>Assemble un « brief » de la campagne (structure + PNJ + univers/lore) — la même
- * {@link CampaignBriefBuilder} et délègue la génération streamée au Brain via
+ * matière que le chat de campagne — 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 CampaignStructuralContextBuilder campaignContextBuilder;
    private final LoreStructuralContextBuilder loreContextBuilder;
    private final CampaignPdfAdvisor advisor;
    public CampaignAdaptService(
            CampaignRepository campaignRepository,
-            CampaignBriefBuilder briefBuilder,
+            CampaignStructuralContextBuilder campaignContextBuilder,
            LoreStructuralContextBuilder loreContextBuilder,
            CampaignPdfAdvisor advisor) {
        this.campaignRepository = campaignRepository;
-        this.briefBuilder = briefBuilder;
+        this.campaignContextBuilder = campaignContextBuilder;
        this.loreContextBuilder = loreContextBuilder;
        this.advisor = advisor;
    }
@@ -41,6 +55,64 @@ public class CampaignAdaptService {
        Campaign campaign = campaignRepository.findById(campaignId)
                .orElseThrow(() -> new IllegalArgumentException("Campagne introuvable : " + campaignId));
        advisor.adviseStreaming(
-                pdfBytes, filename, briefBuilder.build(campaign), messagesJson, onToken, onComplete, onError);
+                pdfBytes, filename, buildBrief(campaign), messagesJson, onToken, onComplete, onError);
    }
    /** Construit un résumé markdown de la campagne (structure + PNJ + lore). */
    private String buildBrief(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();
    }
 }
--- a/core/src/main/java/com/loremind/application/campaigncontext/CampaignBriefBuilder.java
+++ b/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();
    }
 }
--- a/core/src/main/java/com/loremind/application/campaigncontext/CampaignImportService.java
+++ b/core/src/main/java/com/loremind/application/campaigncontext/CampaignImportService.java
@@ -6,7 +6,6 @@ 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.NpcProposal;
 import com.loremind.domain.campaigncontext.CampaignImportProposal.RoomProposal;
 import com.loremind.domain.campaigncontext.CampaignImportProposal.SceneProposal;
 import com.loremind.domain.campaigncontext.Chapter;
@@ -38,38 +37,31 @@ public class CampaignImportService {
    private final ArcService arcService;
    private final ChapterService chapterService;
    private final SceneService sceneService;
    private final NpcService npcService;
    public CampaignImportService(
            CampaignPdfImporter campaignPdfImporter,
            CampaignService campaignService,
            ArcService arcService,
            ChapterService chapterService,
-            SceneService sceneService,
+            SceneService sceneService) {
            NpcService npcService) {
        this.campaignPdfImporter = campaignPdfImporter;
        this.campaignService = campaignService;
        this.arcService = arcService;
        this.chapterService = chapterService;
        this.sceneService = sceneService;
        this.npcService = npcService;
    }
    /** Résumé de ce qui a été créé par {@link #applyStructure}. */
-    public record ApplyResult(
+    public record ApplyResult(int arcsCreated, int chaptersCreated, int scenesCreated) {}
            int arcsCreated, int chaptersCreated, int scenesCreated, int npcsCreated) {}
    /** Génère la proposition d'arbre (streamée). Ne persiste rien. */
    public void importStructureStreaming(
            byte[] pdfBytes,
            String filename,
            Consumer<CampaignImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<CampaignImportProposal> onDone,
            Consumer<Throwable> onError) {
-        campaignPdfImporter.importCampaignStreaming(
+        campaignPdfImporter.importCampaignStreaming(pdfBytes, filename, onProgress, onDone, onError);
                pdfBytes, filename, onProgress, onHeartbeat, onStatus, onDone, onError);
    }
    /**
@@ -138,36 +130,7 @@ public class CampaignImportService {
                }
            }
        }
-
+        return new ApplyResult(arcsCreated, chaptersCreated, scenesCreated);
        int npcsCreated = createNpcs(campaignId, proposal.npcs());
        return new ApplyResult(arcsCreated, chaptersCreated, scenesCreated, npcsCreated);
    }
    /**
     * Crée les PNJ proposés (description → values["Description"], même convention
     * que les cartes d'action des ateliers). Les PNJ portant un nom déjà présent
     * dans la campagne sont ignorés (ré-import sans doublon).
     */
    private int createNpcs(String campaignId, List<NpcProposal> proposals) {
        if (proposals == null || proposals.isEmpty()) return 0;
        java.util.Set<String> existingNames = new java.util.HashSet<>();
        for (var npc : npcService.getNpcsByCampaignId(campaignId)) {
            existingNames.add(npc.getName().trim().toLowerCase());
        }
        int created = 0;
        for (NpcProposal p : proposals) {
            if (isBlank(p.name()) || !existingNames.add(p.name().trim().toLowerCase())) {
                continue;
            }
            npcService.createNpc(new NpcService.NpcData(
                    p.name().trim(), null, null,
                    isBlank(p.description())
                            ? java.util.Map.of()
                            : java.util.Map.of("Description", p.description().trim()),
                    null, null, campaignId, null, null, null));
            created++;
        }
        return created;
    }
    /** Compte les nœuds déjà présents (existingId non vide) d'une liste. */
--- a/core/src/main/java/com/loremind/application/campaigncontext/ItemCatalogService.java
+++ b/core/src/main/java/com/loremind/application/campaigncontext/ItemCatalogService.java
@@ -1,122 +0,0 @@
 package com.loremind.application.campaigncontext;
 import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.CatalogItem;
 import com.loremind.domain.campaigncontext.ItemCatalog;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.ItemCatalogGenerator;
 import com.loremind.domain.campaigncontext.ports.ItemCatalogRepository;
 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 des catalogues d'objets (campagne) : CRUD + génération IA.
 */
@Service
 public class ItemCatalogService {
    private final ItemCatalogRepository repository;
    private final ItemCatalogGenerator generator;
    private final CampaignRepository campaignRepository;
    private final GameSystemRepository gameSystemRepository;
    public ItemCatalogService(
            ItemCatalogRepository repository,
            ItemCatalogGenerator generator,
            CampaignRepository campaignRepository,
            GameSystemRepository gameSystemRepository) {
        this.repository = repository;
        this.generator = generator;
        this.campaignRepository = campaignRepository;
        this.gameSystemRepository = gameSystemRepository;
    }
    public record CatalogData(
            String name,
            String description,
            String icon,
            List<CatalogItem> items,
            String campaignId,
            Integer order
    ) {}
    public ItemCatalog createCatalog(CatalogData data) {
        int order = data.order() != null ? data.order() : nextOrderFor(data.campaignId());
        ItemCatalog catalog = ItemCatalog.builder()
                .name(data.name())
                .description(data.description())
                .icon(data.icon())
                .items(copyItems(data.items()))
                .campaignId(data.campaignId())
                .order(order)
                .build();
        return repository.save(catalog);
    }
    public Optional<ItemCatalog> getCatalogById(String id) {
        return repository.findById(id);
    }
    public List<ItemCatalog> getCatalogsByCampaignId(String campaignId) {
        return repository.findByCampaignId(campaignId);
    }
    public ItemCatalog updateCatalog(String id, CatalogData data) {
        ItemCatalog existing = repository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("Catalogue d'objets introuvable: " + id));
        existing.setName(data.name());
        existing.setDescription(data.description());
        existing.setIcon(data.icon());
        existing.setItems(copyItems(data.items()));
        if (data.order() != null) {
            existing.setOrder(data.order());
        }
        return repository.save(existing);
    }
    public void deleteCatalog(String id) {
        repository.deleteById(id);
    }
    /** Génère une PROPOSITION de catalogue (non persistée) via l'IA, contextualisée campagne. */
    public ItemCatalog generateProposal(String campaignId, String description) {
        ItemCatalogGenerator.GeneratedCatalog g = generator.generate(description, buildContext(campaignId));
        return ItemCatalog.builder()
                .name(g.name())
                .description(g.description())
                .campaignId(campaignId)
                .items(g.items() != null ? new ArrayList<>(g.items()) : new ArrayList<>())
                .build();
    }
    private static List<CatalogItem> copyItems(List<CatalogItem> items) {
        return items != null ? new ArrayList<>(items) : new ArrayList<>();
    }
    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 int nextOrderFor(String campaignId) {
        return repository.findByCampaignId(campaignId).stream()
                .mapToInt(ItemCatalog::getOrder)
                .max()
                .orElse(-1) + 1;
    }
 }
--- a/core/src/main/java/com/loremind/application/campaigncontext/NotebookService.java
+++ b/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);
    }
 }
--- a/core/src/main/java/com/loremind/application/campaigncontext/NpcService.java
+++ b/core/src/main/java/com/loremind/application/campaigncontext/NpcService.java
@@ -1,12 +1,9 @@
 package com.loremind.application.campaigncontext;
 import com.loremind.domain.campaigncontext.Campaign;
 import com.loremind.domain.campaigncontext.Npc;
 import com.loremind.domain.campaigncontext.ports.CampaignRepository;
 import com.loremind.domain.campaigncontext.ports.NpcRepository;
 import org.springframework.stereotype.Service;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -19,11 +16,9 @@ import java.util.Optional;
 public class NpcService {
    private final NpcRepository npcRepository;
    private final CampaignRepository campaignRepository;
-    public NpcService(NpcRepository npcRepository, CampaignRepository campaignRepository) {
+    public NpcService(NpcRepository npcRepository) {
        this.npcRepository = npcRepository;
        this.campaignRepository = campaignRepository;
    }
    public record NpcData(
@@ -34,8 +29,6 @@ public class NpcService {
            Map<String, List<String>> imageValues,
            Map<String, Map<String, String>> keyValueValues,
            String campaignId,
            List<String> relatedPageIds,
            String folder,
            Integer order
    ) {}
@@ -51,8 +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())
                .relatedPageIds(data.relatedPageIds() != null ? new ArrayList<>(data.relatedPageIds()) : new ArrayList<>())
                .folder(normalizeFolder(data.folder()))
                .order(order)
                .build();
        return npcRepository.save(npc);
@@ -66,21 +57,6 @@ public class NpcService {
        return npcRepository.findByCampaignId(campaignId);
    }
    /**
     * PNJ de TOUTES les campagnes liées au Lore donné (via {@code campaign.loreId}).
     * Sert au graphe du Lore : relier les PNJ aux pages qu'ils référencent.
     * Volume faible (usage mono-utilisateur) → filtrage en mémoire assumé.
     */
    public List<Npc> getNpcsByLoreId(String loreId) {
        List<Npc> out = new ArrayList<>();
        for (Campaign campaign : campaignRepository.findAll()) {
            if (campaign.isLinkedToLore() && campaign.getLoreId().equals(loreId)) {
                out.addAll(npcRepository.findByCampaignId(campaign.getId()));
            }
        }
        return out;
    }
    public Npc updateNpc(String id, NpcData data) {
        Npc existing = npcRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("Npc non trouvé avec l'ID: " + id));
@@ -90,8 +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.setRelatedPageIds(data.relatedPageIds() != null ? new ArrayList<>(data.relatedPageIds()) : new ArrayList<>());
        existing.setFolder(normalizeFolder(data.folder()));
        if (data.order() != null) {
            existing.setOrder(data.order());
        }
@@ -102,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)
--- a/core/src/main/java/com/loremind/application/campaigncontext/RandomTableService.java
+++ b/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;
    }
 }
--- a/core/src/main/java/com/loremind/application/gamesystemcontext/GameSystemService.java
+++ b/core/src/main/java/com/loremind/application/gamesystemcontext/GameSystemService.java
@@ -39,12 +39,9 @@ public class GameSystemService {
            byte[] pdfBytes,
            String filename,
            java.util.function.Consumer<com.loremind.domain.gamesystemcontext.RulesImportProgress> onProgress,
            Runnable onHeartbeat,
            java.util.function.Consumer<String> onStatus,
            java.util.function.Consumer<RulesImportResult> onDone,
            java.util.function.Consumer<Throwable> onError) {
-        rulesPdfImporter.importRulesStreaming(
+        rulesPdfImporter.importRulesStreaming(pdfBytes, filename, onProgress, onDone, onError);
                pdfBytes, filename, onProgress, onHeartbeat, onStatus, onDone, onError);
    }
    /**
--- a/core/src/main/java/com/loremind/application/generationcontext/SessionStructuralContextBuilder.java
+++ b/core/src/main/java/com/loremind/application/generationcontext/SessionStructuralContextBuilder.java
@@ -174,9 +174,10 @@ public class SessionStructuralContextBuilder {
                .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
+        boolean anyHub = arcs.stream().anyMatch(a -> a.getType() == ArcType.HUB);
-        // ceux d'un arc linéaire qui portent des prérequis. Un chapitre linéaire sans
+        if (!anyHub) {
-        // condition reste hors du tableau (sinon tous les chapitres deviendraient des quêtes).
+            return new HubStatus(List.of(), List.of(), List.of(), activeFlags);
        }
        // Map chapterId -> ProgressionStatus pour ce Playthrough
        Map<String, ProgressionStatus> progressionByChapter = new HashMap<>();
@@ -196,10 +197,8 @@ public class SessionStructuralContextBuilder {
        List<String> lockedTitles = new ArrayList<>();
        for (Arc arc : arcs) {
-            boolean isHub = arc.getType() == ArcType.HUB;
+            if (arc.getType() != ArcType.HUB) continue;
            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());
--- a/core/src/main/java/com/loremind/application/lorecontext/PageService.java
+++ b/core/src/main/java/com/loremind/application/lorecontext/PageService.java
@@ -76,8 +76,6 @@ public class PageService {
        existing.setNodeId(changes.getNodeId());
        existing.setValues(CollectionUtils.copyMap(changes.getValues()));
        existing.setImageValues(CollectionUtils.copyMap(changes.getImageValues()));
        existing.setKeyValueValues(CollectionUtils.copyMap(changes.getKeyValueValues()));
        existing.setTableValues(CollectionUtils.copyMap(changes.getTableValues()));
        existing.setNotes(changes.getNotes());
        existing.setTags(CollectionUtils.copyList(changes.getTags()));
        existing.setRelatedPageIds(CollectionUtils.copyList(changes.getRelatedPageIds()));
--- a/core/src/main/java/com/loremind/domain/campaigncontext/CampaignImportProgress.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/CampaignImportProgress.java
@@ -14,6 +14,5 @@ public record CampaignImportProgress(
        int ocrPageCount,
        int arcCount,
        int chapterCount,
-        int sceneCount,
+        int sceneCount) {
        int npcCount) {
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/CampaignImportProposal.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/CampaignImportProposal.java
@@ -8,7 +8,7 @@ import java.util.List;
 * 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, List<NpcProposal> npcs) {
+public record CampaignImportProposal(List<ArcProposal> arcs) {
    /**
     * {@code existingId} (nullable) : si présent, le nœud existe DÉJÀ dans la
@@ -37,14 +37,4 @@ public record CampaignImportProposal(List<ArcProposal> arcs, List<NpcProposal> n
    public record RoomProposal(String name, String description, String enemies, String loot) {
    }
    /**
     * PNJ/creature notable detecte dans le PDF (PNJ nommes, boss). Propose a la
     * revue (coche par defaut) ; cree comme Npc de la campagne a l''apply avec
     * sa description dans values["Description"] (meme convention que les cartes
     * d''action des ateliers).
     */
    public record NpcProposal(String name, String description) {
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/CatalogItem.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/CatalogItem.java
@@ -1,24 +0,0 @@
 package com.loremind.domain.campaigncontext;
 import lombok.Builder;
 import lombok.Data;
 /**
 * Un objet d'un {@link ItemCatalog} (boutique, butin, trésor…).
 * Value object possédé par le catalogue : remplacé en bloc à chaque mise à jour.
 */
@Data
@Builder
 public class CatalogItem {
    private String name;
    /** Prix libre (ex. « 50 po », « 2 pa »). Nullable. */
    private String price;
    /** Catégorie de regroupement (ex. « Armes », « Potions »). Nullable. */
    private String category;
    /** Description / effet (markdown). Nullable. */
    private String description;
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ItemCatalog.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ItemCatalog.java
@@ -1,44 +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;
 /**
 * Catalogue d'objets prédéfinis d'une campagne : une boutique, un butin, un trésor…
 * Le MJ le remplit à la main ou via l'IA, et le consulte (notamment en session) quand
 * les joueurs visitent une échoppe. Scope campagne (cross-aggregate via ID).
 */
@Data
@Builder
 public class ItemCatalog {
    private String id;
    private String name;
    /** Description libre (à quoi sert ce catalogue / cette boutique). Nullable. */
    private String description;
    /** 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 catalogues de la campagne. */
    private int order;
    /** Objets ordonnés du catalogue. Jamais null après construction. */
    private List<CatalogItem> items;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    public List<CatalogItem> getItems() {
        if (items == null) items = new ArrayList<>();
        return items;
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/Notebook.java
+++ b/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;
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/NotebookMessage.java
+++ b/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;
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/NotebookSource.java
+++ b/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;
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/Npc.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/Npc.java
@@ -4,7 +4,6 @@ import lombok.Builder;
 import lombok.Data;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -47,16 +46,6 @@ public class Npc {
    /** Référence vers la Campaign parente (cross-aggregate via ID). */
    private String campaignId;
    /**
     * IDs de Pages de Lore référencées par ce PNJ (sa ville, sa faction, sa
     * région…). Référence faible cross-context, même principe que sur
     * Arc/Chapter/Scene — alimente notamment le graphe du Lore.
     */
    private List<String> relatedPageIds;
    /** Dossier de classement (texte libre, ex. « Bard's Gate »). Nullable = non classé. */
    private String folder;
    /** Ordre d'affichage dans la liste des PNJ de la campagne. */
    private int order;
@@ -77,9 +66,4 @@ public class Npc {
        if (keyValueValues == null) keyValueValues = new HashMap<>();
        return keyValueValues;
    }
    public List<String> getRelatedPageIds() {
        if (relatedPageIds == null) relatedPageIds = new ArrayList<>();
        return relatedPageIds;
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/RandomTable.java
+++ b/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;
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/RandomTableEntry.java
+++ b/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;
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignPdfImporter.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignPdfImporter.java
@@ -15,23 +15,14 @@ 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 onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onHeartbeat invoqué périodiquement pendant un appel LLM long (aucune
+     * @param onDone     invoqué une fois avec l'arbre proposé (non persisté).
-     *                    avancée à afficher, mais le canal SSE vers le navigateur
+     * @param onError    invoqué si l'extraction/structuration échoue.
     *                    doit rester actif — sinon un proxy intermédiaire le coupe).
     * @param onStatus    invoqué avec un message lisible quand quelque chose se
     *                    passe pendant l'attente (fournisseur saturé → retry,
     *                    morceau re-découpé, morceau ignoré…) — affiché par l'UI
     *                    pour que l'utilisateur n'ait pas à lire les logs.
     * @param onDone      invoqué une fois avec l'arbre proposé (non persisté).
     * @param onError     invoqué si l'extraction/structuration échoue.
     */
    void importCampaignStreaming(
            byte[] pdfBytes,
            String filename,
            Consumer<CampaignImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<CampaignImportProposal> onDone,
            Consumer<Throwable> onError);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogGenerationException.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogGenerationException.java
@@ -1,15 +0,0 @@
 package com.loremind.domain.campaigncontext.ports;
 /**
 * Échec de génération IA d'un catalogue d'objets (Brain injoignable, erreur du
 * modèle, réponse inexploitable…). Mappée en HTTP 502 par le contrôleur.
 */
 public class ItemCatalogGenerationException extends RuntimeException {
    public ItemCatalogGenerationException(String message) {
        super(message);
    }
    public ItemCatalogGenerationException(String message, Throwable cause) {
        super(message, cause);
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogGenerator.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogGenerator.java
@@ -1,21 +0,0 @@
 package com.loremind.domain.campaigncontext.ports;
 import com.loremind.domain.campaigncontext.CatalogItem;
 import java.util.List;
 /**
 * Port de sortie : génération IA d'un catalogue d'objets. Implémenté par un client
 * du Brain (service IA Python).
 */
 public interface ItemCatalogGenerator {
    /** Catalogue proposé (non persisté) à partir d'une description. */
    record GeneratedCatalog(String name, String description, List<CatalogItem> items) {}
    /**
     * Génère une proposition de catalogue (objets) sur le sujet donné, en s'appuyant
     * sur le contexte (campagne, système…) s'il est fourni.
     */
    GeneratedCatalog generate(String description, String context);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogRepository.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ItemCatalogRepository.java
@@ -1,22 +0,0 @@
 package com.loremind.domain.campaigncontext.ports;
 import com.loremind.domain.campaigncontext.ItemCatalog;
 import java.util.List;
 import java.util.Optional;
 /**
 * Port de sortie pour la persistance des {@link ItemCatalog}.
 */
 public interface ItemCatalogRepository {
    ItemCatalog save(ItemCatalog catalog);
    Optional<ItemCatalog> findById(String id);
    List<ItemCatalog> findByCampaignId(String campaignId);
    void deleteById(String id);
    boolean existsById(String id);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookChatStreamer.java
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookChatStreamer.java
@@ -1,38 +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 onSourcesJson} UNE fois avant le premier token (JSON brut des
     * passages utilisés — transparence UI), {@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> onSourcesJson,
            Consumer<String> onToken,
            Consumer<Progress> onProgress,
            Runnable onDone,
            Consumer<Throwable> onError);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookException.java
+++ b/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);
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookIndexer.java
+++ b/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);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/NotebookRepository.java
+++ b/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);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/RandomTableGenerationException.java
+++ b/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);
    }
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/RandomTableGenerator.java
+++ b/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);
 }
--- a/core/src/main/java/com/loremind/domain/campaigncontext/ports/RandomTableRepository.java
+++ b/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);
 }
--- a/core/src/main/java/com/loremind/domain/gamesystemcontext/ports/RulesPdfImporter.java
+++ b/core/src/main/java/com/loremind/domain/gamesystemcontext/ports/RulesPdfImporter.java
@@ -26,23 +26,14 @@ public interface RulesPdfImporter {
     * l'avancement au fil de l'eau. Les callbacks sont invoqués depuis le thread
     * d'exécution de l'adapter (synchrone jusqu'à {@code onDone}/{@code onError}).
     *
-     * @param onProgress  invoqué à chaque étape (extraction, puis par morceau).
+     * @param onProgress invoqué à chaque étape (extraction, puis par morceau).
-     * @param onHeartbeat invoqué périodiquement pendant un appel LLM long (aucune
+     * @param onDone     invoqué une fois avec le résultat final.
-     *                    avancée à afficher, mais le canal SSE vers le navigateur
+     * @param onError    invoqué si l'extraction/structuration échoue.
     *                    doit rester actif — sinon un proxy intermédiaire le coupe).
     * @param onStatus    invoqué avec un message lisible quand quelque chose se
     *                    passe pendant l'attente (fournisseur saturé → retry,
     *                    morceau re-découpé, morceau ignoré…) — affiché par l'UI
     *                    pour que l'utilisateur n'ait pas à lire les logs.
     * @param onDone      invoqué une fois avec le résultat final.
     * @param onError     invoqué si l'extraction/structuration échoue.
     */
    void importRulesStreaming(
            byte[] pdfBytes,
            String filename,
            Consumer<RulesImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<RulesImportResult> onDone,
            Consumer<Throwable> onError);
 }
--- a/core/src/main/java/com/loremind/domain/lorecontext/Page.java
+++ b/core/src/main/java/com/loremind/domain/lorecontext/Page.java
@@ -39,20 +39,6 @@ public class Page {
     */
    private Map<String, List<String>> imageValues;
    /**
     * Valeurs des champs KEY_VALUE_LIST (tableau libelle → valeur, comme sur les
     * fiches de personnage) : fieldName → (label → valeur). Les labels sont
     * definis par le Template ; seules les valeurs vivent sur la page.
     */
    private Map<String, Map<String, String>> keyValueValues;
    /**
     * Valeurs des champs TABLE (colonnes figees au template, lignes libres) :
     * fieldName → liste ordonnee de lignes, chaque ligne = colonne → cellule.
     * Usage type : inventaire de boutique, table d'objets.
     */
    private Map<String, List<Map<String, String>>> tableValues;
    /** Notes privées du MJ (non exportées vers FoundryVTT). */
    private String notes;
--- a/core/src/main/java/com/loremind/domain/shared/template/FieldType.java
+++ b/core/src/main/java/com/loremind/domain/shared/template/FieldType.java
@@ -9,11 +9,6 @@ package com.loremind.domain.shared.template;
 * - KEY_VALUE_LIST  : liste de paires {label, value} avec labels figes au template
 *                     (Map<String, Map<String, String>> : fieldName -> label -> value).
 *                     Usage : stat blocks, listes de competences, traits.
 * - TABLE           : tableau a colonnes figees au template (TemplateField.labels =
 *                     noms de colonnes) et lignes LIBRES ajoutees au remplissage
 *                     (Map<String, List<Map<String, String>>> : fieldName -> lignes,
 *                     chaque ligne = colonne -> cellule).
 *                     Usage : inventaire de boutique, tables d'objets, listes de prix.
 * <p>
 * Extension future possible : RICH_TEXT, DATE, BOOLEAN, REFERENCE...
 */
@@ -21,6 +16,5 @@ public enum FieldType {
    TEXT,
    IMAGE,
    NUMBER,
-    KEY_VALUE_LIST,
+    KEY_VALUE_LIST
    TABLE
 }
--- a/core/src/main/java/com/loremind/domain/shared/template/TemplateField.java
+++ b/core/src/main/java/com/loremind/domain/shared/template/TemplateField.java
@@ -30,9 +30,8 @@ public class TemplateField {
    /** Variante de rendu pour les champs IMAGE. Null = GALLERY. */
    private ImageLayout layout;
    /**
-     * Labels predefinis (ordre significatif), selon le type :
+     * Labels predefinis pour les champs KEY_VALUE_LIST (ordre significatif).
-     * - KEY_VALUE_LIST : libelles des lignes. Ex: ["FOR","DEX","CON","INT","SAG","CHA"].
+     * Ex: ["FOR","DEX","CON","INT","SAG","CHA"] pour un champ "Caracteristiques".
     * - TABLE          : noms des COLONNES. Ex: ["Objet","Prix","Description"].
     * Null/vide pour les autres types.
     */
    private List<String> labels;
@@ -71,9 +70,4 @@ public class TemplateField {
    public static TemplateField keyValueList(String name, List<String> labels) {
        return new TemplateField(name, FieldType.KEY_VALUE_LIST, null, labels);
    }
    /** Raccourci : construit un champ TABLE avec ses noms de colonnes. */
    public static TemplateField table(String name, List<String> columns) {
        return new TemplateField(name, FieldType.TABLE, null, columns);
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignImportClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainCampaignImportClient.java
@@ -6,7 +6,6 @@ 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.NpcProposal;
 import com.loremind.domain.campaigncontext.CampaignImportProposal.RoomProposal;
 import com.loremind.domain.campaigncontext.CampaignImportProposal.SceneProposal;
 import com.loremind.domain.campaigncontext.ports.CampaignImportException;
@@ -60,8 +59,6 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            byte[] pdfBytes,
            String filename,
            Consumer<CampaignImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<CampaignImportProposal> onDone,
            Consumer<Throwable> onError) {
@@ -85,8 +82,7 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            flux
                .timeout(Duration.ofSeconds(importTimeoutSeconds))
                .doOnNext(sse -> handleEvent(
-                        sse, pageCount, ocrPageCount, terminated,
+                        sse, pageCount, ocrPageCount, terminated, onProgress, onDone, onError))
                        onProgress, onHeartbeat, onStatus, onDone, onError))
                .blockLast();
            if (!terminated[0]) {
                onError.accept(new CampaignImportException(
@@ -94,12 +90,8 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            }
        } catch (Exception e) {
            if (!terminated[0]) {
                // On EXPOSE la cause réelle (type + message) : sans ça, le diagnostic
                // est impossible (timeout WebClient, connexion coupée, réponse non-2xx…).
                String cause = e.getClass().getSimpleName()
                        + (e.getMessage() != null ? " — " + e.getMessage() : "");
                onError.accept(new CampaignImportException(
-                        "Erreur lors du streaming d'import depuis le Brain : " + cause, e));
+                        "Erreur lors du streaming d'import depuis le Brain.", e));
            }
        }
    }
@@ -110,36 +102,12 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            int[] ocrPageCount,
            boolean[] terminated,
            Consumer<CampaignImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<CampaignImportProposal> onDone,
            Consumer<Throwable> onError) {
        String event = sse.event();
        String data = sse.data() == null ? "" : sse.data();
        if ("heartbeat".equals(event)) {
            // Keep-alive du Brain pendant un appel LLM long : à PROPAGER jusqu'au
            // navigateur, sinon nginx (proxy_read_timeout) coupe le SSE Core→front.
            onHeartbeat.run();
            return;
        }
        if ("status".equals(event)) {
            // Message d'attente lisible (retry sur fournisseur saturé, morceau
            // re-découpé…) : affiché par l'UI au lieu de n'exister qu'en logs.
            onStatus.accept(readMessage(data));
            return;
        }
        if ("chunk_failed".equals(event)) {
            JsonNode node = readJson(data);
            String msg = node != null && node.hasNonNull("message")
                    ? node.get("message").asText() : "";
            int current = node != null ? node.path("current").asInt() : 0;
            int total = node != null ? node.path("total").asInt() : 0;
            onStatus.accept("Morceau " + current + "/" + total + " ignoré"
                    + (msg.isEmpty() ? "." : " : " + msg));
            return;
        }
        if ("error".equals(event)) {
            terminated[0] = true;
            onError.accept(new CampaignImportException(
@@ -147,7 +115,7 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            return;
        }
        if ("extracting".equals(event)) {
-            onProgress.accept(new CampaignImportProgress(0, 0, 0, 0, 0, 0, 0, 0));
+            onProgress.accept(new CampaignImportProgress(0, 0, 0, 0, 0, 0, 0));
            return;
        }
@@ -158,7 +126,7 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
            pageCount[0] = node.path("page_count").asInt();
            ocrPageCount[0] = node.path("ocr_page_count").asInt();
            onProgress.accept(new CampaignImportProgress(
-                    0, node.path("total").asInt(), pageCount[0], ocrPageCount[0], 0, 0, 0, 0));
+                    0, node.path("total").asInt(), pageCount[0], ocrPageCount[0], 0, 0, 0));
        } else if ("progress".equals(event)) {
            onProgress.accept(new CampaignImportProgress(
                    node.path("current").asInt(),
@@ -167,12 +135,10 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
                    ocrPageCount[0],
                    node.path("arc_count").asInt(),
                    node.path("chapter_count").asInt(),
-                    node.path("scene_count").asInt(),
+                    node.path("scene_count").asInt()));
                    node.path("npc_count").asInt()));
        } else if ("done".equals(event)) {
            terminated[0] = true;
-            onDone.accept(new CampaignImportProposal(
+            onDone.accept(new CampaignImportProposal(toArcs(node.path("arcs"))));
                    toArcs(node.path("arcs")), toNpcs(node.path("npcs"))));
        }
    }
@@ -232,16 +198,6 @@ public class BrainCampaignImportClient implements CampaignPdfImporter {
        return rooms;
    }
    private List<NpcProposal> toNpcs(JsonNode npcsNode) {
        List<NpcProposal> npcs = new ArrayList<>();
        if (npcsNode != null && npcsNode.isArray()) {
            for (JsonNode n : npcsNode) {
                npcs.add(new NpcProposal(text(n, "name"), text(n, "description")));
            }
        }
        return npcs;
    }
    // --- Helpers -------------------------------------------------------------
    private ByteArrayResource filePart(byte[] pdfBytes, String filename) {
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainItemCatalogClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainItemCatalogClient.java
@@ -1,92 +0,0 @@
 package com.loremind.infrastructure.ai;
 import com.loremind.domain.campaigncontext.CatalogItem;
 import com.loremind.domain.campaigncontext.ports.ItemCatalogGenerationException;
 import com.loremind.domain.campaigncontext.ports.ItemCatalogGenerator;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestClientResponseException;
 import org.springframework.web.client.RestTemplate;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 /**
 * Adapter de sortie : génère un catalogue d'objets via le Brain (POST one-shot).
 */
@Component
 public class BrainItemCatalogClient implements ItemCatalogGenerator {
    private static final String GENERATE_PATH = "/generate/item-catalog";
    private final RestTemplate restTemplate;
    private final String baseUrl;
    public BrainItemCatalogClient(
            RestTemplate restTemplate,
            @Value("${brain.base-url}") String baseUrl) {
        this.restTemplate = restTemplate;
        this.baseUrl = baseUrl;
    }
    @Override
    @SuppressWarnings("unchecked")
    public GeneratedCatalog generate(String description, String context) {
        Map<String, Object> req = new LinkedHashMap<>();
        req.put("description", description == null ? "" : description);
        req.put("context", context == null ? "" : context);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(req, headers);
        Map<String, Object> resp;
        try {
            resp = restTemplate.postForObject(baseUrl + GENERATE_PATH, entity, Map.class);
        } catch (ResourceAccessException e) {
            throw new ItemCatalogGenerationException("Le Brain est injoignable (timeout ou arrêté).", e);
        } catch (RestClientResponseException e) {
            throw new ItemCatalogGenerationException(
                    "Le Brain a répondu HTTP " + e.getStatusCode().value() + " : " + e.getResponseBodyAsString(), e);
        } catch (Exception e) {
            throw new ItemCatalogGenerationException("Erreur inattendue lors de l'appel au Brain.", e);
        }
        if (resp == null) {
            throw new ItemCatalogGenerationException("Le Brain a renvoyé une réponse vide.");
        }
        List<CatalogItem> items = new ArrayList<>();
        Object rawItems = resp.get("items");
        if (rawItems instanceof List<?> list) {
            for (Object item : list) {
                if (!(item instanceof Map<?, ?> m)) continue;
                String name = asString(m.get("name"));
                if (name == null || name.isBlank()) continue;
                items.add(CatalogItem.builder()
                        .name(name)
                        .price(asString(m.get("price")))
                        .category(asString(m.get("category")))
                        .description(asString(m.get("description")))
                        .build());
            }
        }
        if (items.isEmpty()) {
            throw new ItemCatalogGenerationException("Aucun objet généré — réessaie ou reformule.");
        }
        String name = asString(resp.get("name"));
        return new GeneratedCatalog(
                name != null && !name.isBlank() ? name : description,
                asString(resp.get("description")),
                items);
    }
    private static String asString(Object o) {
        return o != null ? o.toString() : null;
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookChatClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookChatClient.java
@@ -1,146 +0,0 @@
 package com.loremind.infrastructure.ai;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.loremind.domain.campaigncontext.ports.NotebookChatStreamer;
 import com.loremind.domain.campaigncontext.ports.NotebookException;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.MediaType;
 import org.springframework.http.codec.ServerSentEvent;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.client.WebClient;
 import reactor.core.publisher.Flux;
 import java.time.Duration;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 /**
 * Adapter de sortie : relaie le chat ANCRÉ (RAG) du Brain via SSE (WebClient).
 * Pattern identique aux imports streamés (cf. BrainRulesImportClient).
 */
@Component
 public class BrainNotebookChatClient implements NotebookChatStreamer {
    private static final String PATH = "/chat/notebook/stream";
    private static final String DEEP_PATH = "/chat/notebook/deep/stream";
    private static final ParameterizedTypeReference<ServerSentEvent<String>> SSE_STRING_TYPE =
            new ParameterizedTypeReference<>() {};
    private final WebClient webClient;
    private final ObjectMapper objectMapper;
    private final long timeoutSeconds;
    public BrainNotebookChatClient(
            WebClient.Builder webClientBuilder,
            ObjectMapper objectMapper,
            @Value("${brain.base-url}") String baseUrl,
            @Value("${brain.import-timeout-seconds:600}") long timeoutSeconds) {
        this.webClient = webClientBuilder.baseUrl(baseUrl).build();
        this.objectMapper = objectMapper;
        this.timeoutSeconds = timeoutSeconds;
    }
    @Override
    public void stream(
            List<String> sourceIds,
            List<Msg> messages,
            String context,
            boolean deep,
            Consumer<String> onSourcesJson,
            Consumer<String> onToken,
            Consumer<Progress> onProgress,
            Runnable onDone,
            Consumer<Throwable> onError) {
        Map<String, Object> payload = new LinkedHashMap<>();
        payload.put("source_ids", sourceIds);
        payload.put("messages", messages.stream()
                .map(m -> Map.<String, Object>of("role", m.role(), "content", m.content()))
                .collect(Collectors.toList()));
        payload.put("context", context == null ? "" : context);
        Flux<ServerSentEvent<String>> flux = webClient.post()
                .uri(deep ? DEEP_PATH : PATH)
                .contentType(MediaType.APPLICATION_JSON)
                .accept(MediaType.TEXT_EVENT_STREAM)
                .bodyValue(payload)
                .retrieve()
                .bodyToFlux(SSE_STRING_TYPE);
        boolean[] terminated = {false};
        try {
            flux
                .timeout(Duration.ofSeconds(timeoutSeconds))
                .doOnNext(sse -> handleEvent(
                        sse, terminated, onSourcesJson, onToken, onProgress, onDone, onError))
                .blockLast();
            if (!terminated[0]) {
                onDone.run();  // flux terminé sans event done explicite
            }
        } catch (Exception e) {
            if (!terminated[0]) {
                String cause = e.getClass().getSimpleName()
                        + (e.getMessage() != null ? " — " + e.getMessage() : "");
                onError.accept(new NotebookException(
                        "Erreur lors du streaming du chat depuis le Brain : " + cause, e));
            }
        }
    }
    private void handleEvent(
            ServerSentEvent<String> sse,
            boolean[] terminated,
            Consumer<String> onSourcesJson,
            Consumer<String> onToken,
            Consumer<Progress> onProgress,
            Runnable onDone,
            Consumer<Throwable> onError) {
        String event = sse.event();
        String data = sse.data() == null ? "" : sse.data();
        if ("token".equals(event)) {
            String token = readField(data, "token");
            if (token != null && !token.isEmpty()) onToken.accept(token);
        } else if ("sources".equals(event)) {
            // Passages utilisés par le RAG : relayés tels quels (JSON brut) — le
            // Core n'a pas besoin de les comprendre, seulement de les transmettre.
            onSourcesJson.accept(data);
        } else if ("progress".equals(event)) {
            onProgress.accept(new Progress(readInt(data, "current"), readInt(data, "total")));
        } else if ("done".equals(event)) {
            terminated[0] = true;
            onDone.run();
        } else if ("error".equals(event)) {
            terminated[0] = true;
            onError.accept(new NotebookException("Le Brain a signalé une erreur : " + readMessage(data)));
        }
    }
    private int readInt(String data, String field) {
        try {
            JsonNode node = objectMapper.readTree(data);
            return node.hasNonNull(field) ? node.get(field).asInt() : 0;
        } catch (Exception e) {
            return 0;
        }
    }
    private String readField(String data, String field) {
        try {
            JsonNode node = objectMapper.readTree(data);
            return node.hasNonNull(field) ? node.get(field).asText() : null;
        } catch (Exception e) {
            return null;
        }
    }
    private String readMessage(String data) {
        String msg = readField(data, "message");
        return msg != null ? msg : data;
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookIndexClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainNotebookIndexClient.java
@@ -1,100 +0,0 @@
 package com.loremind.infrastructure.ai;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.loremind.domain.campaigncontext.ports.NotebookException;
 import com.loremind.domain.campaigncontext.ports.NotebookIndexer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.io.ByteArrayResource;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestClientResponseException;
 import org.springframework.web.client.RestTemplate;
 /**
 * Adapter de sortie : indexe une source de notebook via le Brain (multipart,
 * one-shot bloquant — l'indexation d'un livre peut prendre du temps, d'où le
 * RestTemplate à timeout long {@code brainImportRestTemplate}).
 */
@Component
 public class BrainNotebookIndexClient implements NotebookIndexer {
    private static final Logger LOG = LoggerFactory.getLogger(BrainNotebookIndexClient.class);
    private static final String INDEX_PATH = "/index/notebook-source";
    private final RestTemplate restTemplate;
    private final String baseUrl;
    public BrainNotebookIndexClient(
            @Qualifier("brainImportRestTemplate") RestTemplate restTemplate,
            @Value("${brain.base-url}") String baseUrl) {
        this.restTemplate = restTemplate;
        this.baseUrl = baseUrl;
    }
    @Override
    public IndexResult index(String sourceId, byte[] pdfBytes, String filename) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
        body.add("source_id", sourceId);
        body.add("file", filePart(pdfBytes, filename));
        HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(body, headers);
        try {
            IndexResponse resp = restTemplate.postForObject(
                    baseUrl + INDEX_PATH, entity, IndexResponse.class);
            if (resp == null) {
                throw new NotebookException("Le Brain a renvoyé une réponse vide à l'indexation.");
            }
            return new IndexResult(resp.chunks, resp.pageCount, resp.ocrPageCount);
        } catch (ResourceAccessException e) {
            throw new NotebookException("Le Brain est injoignable (timeout ou arrêté).", e);
        } catch (RestClientResponseException e) {
            throw new NotebookException(
                    "Le Brain a répondu HTTP " + e.getStatusCode().value()
                            + " : " + e.getResponseBodyAsString(), e);
        } catch (NotebookException e) {
            throw e;
        } catch (Exception e) {
            throw new NotebookException("Erreur inattendue lors de l'indexation via le Brain.", e);
        }
    }
    @Override
    public void delete(String sourceId) {
        // Best-effort : si le Brain est down, on ne bloque pas la suppression côté Core
        // (les vecteurs orphelins seront simplement ignorés / nettoyables plus tard).
        try {
            restTemplate.delete(baseUrl + INDEX_PATH + "/" + sourceId);
        } catch (Exception e) {
            LOG.warn("Suppression des vecteurs de la source {} échouée (ignorée) : {}", sourceId, e.getMessage());
        }
    }
    private ByteArrayResource filePart(byte[] pdfBytes, String filename) {
        return new ByteArrayResource(pdfBytes) {
            @Override
            public String getFilename() {
                return (filename == null || filename.isBlank()) ? "source.pdf" : filename;
            }
        };
    }
    /** Réponse JSON du Brain (snake_case). */
    private static class IndexResponse {
        public int chunks;
        @JsonProperty("page_count")
        public int pageCount;
        @JsonProperty("ocr_page_count")
        public int ocrPageCount;
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainRandomTableClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainRandomTableClient.java
@@ -1,120 +0,0 @@
 package com.loremind.infrastructure.ai;
 import com.loremind.domain.campaigncontext.RandomTableEntry;
 import com.loremind.domain.campaigncontext.ports.RandomTableGenerationException;
 import com.loremind.domain.campaigncontext.ports.RandomTableGenerator;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 import org.springframework.web.client.ResourceAccessException;
 import org.springframework.web.client.RestClientResponseException;
 import org.springframework.web.client.RestTemplate;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 /**
 * Adapter de sortie : implémente {@link RandomTableGenerator} en appelant le Brain
 * (POST one-shot, RestTemplate). Le secret inter-service est injecté par l'intercepteur
 * du bean {@code brainRestTemplate}.
 */
@Component
 public class BrainRandomTableClient implements RandomTableGenerator {
    private static final String GENERATE_PATH = "/generate/random-table";
    private static final String IMPROVISE_PATH = "/improvise/table-roll";
    private final RestTemplate restTemplate;
    private final String baseUrl;
    public BrainRandomTableClient(
            RestTemplate restTemplate,
            @Value("${brain.base-url}") String baseUrl) {
        this.restTemplate = restTemplate;
        this.baseUrl = baseUrl;
    }
    @Override
    public GeneratedTable generate(String description, String diceFormula, String context) {
        Map<String, Object> req = new LinkedHashMap<>();
        req.put("description", description == null ? "" : description);
        req.put("dice_formula", diceFormula == null ? "1d20" : diceFormula);
        req.put("context", context == null ? "" : context);
        Map<String, Object> resp = post(GENERATE_PATH, req);
        if (resp == null) {
            throw new RandomTableGenerationException("Le Brain a renvoyé une réponse vide.");
        }
        List<RandomTableEntry> entries = new ArrayList<>();
        Object rawEntries = resp.get("entries");
        if (rawEntries instanceof List<?> list) {
            for (Object item : list) {
                if (!(item instanceof Map<?, ?> m)) continue;
                Integer min = asInt(m.get("min_roll"));
                Integer max = asInt(m.get("max_roll"));
                String label = asString(m.get("label"));
                if (min == null || max == null || label == null || label.isBlank()) continue;
                entries.add(RandomTableEntry.builder()
                        .minRoll(min)
                        .maxRoll(Math.max(min, max))
                        .label(label)
                        .detail(asString(m.get("detail")))
                        .build());
            }
        }
        if (entries.isEmpty()) {
            throw new RandomTableGenerationException("Aucune entrée générée — réessaie ou reformule.");
        }
        String name = asString(resp.get("name"));
        return new GeneratedTable(
                name != null && !name.isBlank() ? name : description,
                asString(resp.get("description")),
                entries);
    }
    @Override
    public String improvise(String tableName, String resultLabel, String resultDetail, String context) {
        Map<String, Object> req = new LinkedHashMap<>();
        req.put("table_name", tableName == null ? "" : tableName);
        req.put("result_label", resultLabel == null ? "" : resultLabel);
        req.put("result_detail", resultDetail == null ? "" : resultDetail);
        req.put("context", context == null ? "" : context);
        Map<String, Object> resp = post(IMPROVISE_PATH, req);
        String narration = resp != null ? asString(resp.get("narration")) : null;
        return narration != null ? narration : "";
    }
    @SuppressWarnings("unchecked")
    private Map<String, Object> post(String path, Map<String, Object> body) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(body, headers);
        try {
            return restTemplate.postForObject(baseUrl + path, entity, Map.class);
        } catch (ResourceAccessException e) {
            throw new RandomTableGenerationException("Le Brain est injoignable (timeout ou arrêté).", e);
        } catch (RestClientResponseException e) {
            throw new RandomTableGenerationException(
                    "Le Brain a répondu HTTP " + e.getStatusCode().value() + " : " + e.getResponseBodyAsString(), e);
        } catch (Exception e) {
            throw new RandomTableGenerationException("Erreur inattendue lors de l'appel au Brain.", e);
        }
    }
    private static Integer asInt(Object o) {
        if (o instanceof Number n) return n.intValue();
        if (o instanceof String s) {
            try { return Integer.parseInt(s.trim()); } catch (NumberFormatException ignored) { return null; }
        }
        return null;
    }
    private static String asString(Object o) {
        return o != null ? o.toString() : null;
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/ai/BrainRulesImportClient.java
+++ b/core/src/main/java/com/loremind/infrastructure/ai/BrainRulesImportClient.java
@@ -114,8 +114,6 @@ public class BrainRulesImportClient implements RulesPdfImporter {
            byte[] pdfBytes,
            String filename,
            Consumer<RulesImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<RulesImportResult> onDone,
            Consumer<Throwable> onError) {
@@ -141,8 +139,7 @@ public class BrainRulesImportClient implements RulesPdfImporter {
            flux
                .timeout(Duration.ofSeconds(importTimeoutSeconds))
                .doOnNext(sse -> handleEvent(
-                        sse, pageCount, ocrPageCount, terminated,
+                        sse, pageCount, ocrPageCount, terminated, onProgress, onDone, onError))
                        onProgress, onHeartbeat, onStatus, onDone, onError))
                .blockLast();
            // Flux terminé sans event done/error (ex: connexion coupée) → on signale.
            if (!terminated[0]) {
@@ -151,13 +148,8 @@ public class BrainRulesImportClient implements RulesPdfImporter {
            }
        } catch (Exception e) {
            if (!terminated[0]) {
                // On EXPOSE la cause réelle (type + message) : sans ça, l'UI n'a qu'un
                // message générique et le diagnostic est impossible (timeout WebClient,
                // connexion coupée, réponse non-2xx du Brain, etc.).
                String cause = e.getClass().getSimpleName()
                        + (e.getMessage() != null ? " — " + e.getMessage() : "");
                onError.accept(new RulesImportException(
-                        "Erreur lors du streaming d'import depuis le Brain : " + cause, e));
+                        "Erreur lors du streaming d'import depuis le Brain.", e));
            }
        }
    }
@@ -168,37 +160,12 @@ public class BrainRulesImportClient implements RulesPdfImporter {
            int[] ocrPageCount,
            boolean[] terminated,
            Consumer<RulesImportProgress> onProgress,
            Runnable onHeartbeat,
            Consumer<String> onStatus,
            Consumer<RulesImportResult> onDone,
            Consumer<Throwable> onError) {
        String event = sse.event();
        String data = sse.data() == null ? "" : sse.data();
        if ("heartbeat".equals(event)) {
            // Keep-alive du Brain pendant un appel LLM long : à PROPAGER jusqu'au
            // navigateur, sinon nginx (proxy_read_timeout) coupe le SSE Core→front
            // resté silencieux pendant tout le traitement du morceau.
            onHeartbeat.run();
            return;
        }
        if ("status".equals(event)) {
            // Message d'attente lisible (retry sur fournisseur saturé, morceau
            // re-découpé…) : affiché par l'UI au lieu de n'exister qu'en logs.
            onStatus.accept(readMessage(data));
            return;
        }
        if ("chunk_failed".equals(event)) {
            JsonNode node = readJson(data);
            String msg = node != null && node.hasNonNull("message")
                    ? node.get("message").asText() : "";
            int current = node != null ? node.path("current").asInt() : 0;
            int total = node != null ? node.path("total").asInt() : 0;
            onStatus.accept("Morceau " + current + "/" + total + " ignoré"
                    + (msg.isEmpty() ? "." : " : " + msg));
            return;
        }
        if ("error".equals(event)) {
            terminated[0] = true;
            onError.accept(new RulesImportException(
--- a/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringRowListMapJsonConverter.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringRowListMapJsonConverter.java
@@ -1,51 +0,0 @@
 package com.loremind.infrastructure.persistence.converter;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.persistence.AttributeConverter;
 import jakarta.persistence.Converter;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 /**
 * Convertit une Map<String, List<Map<String, String>>> en JSON et inversement.
 * <p>
 * Utilise pour Page.tableValues : pour chaque champ TABLE du template, stocke
 * la liste ordonnee des LIGNES du tableau, chaque ligne etant une map
 * colonne -> cellule. Exemple :
 *   {"Inventaire": [{"Objet":"Potion","Prix":"50 po"}, {"Objet":"Corde","Prix":"1 po"}]}
 * <p>
 * Adaptateur technique pur : le domaine ignore ce converter.
 */
@Converter
 public class StringRowListMapJsonConverter
        implements AttributeConverter<Map<String, List<Map<String, String>>>, String> {
    private static final ObjectMapper MAPPER = new ObjectMapper();
    private static final TypeReference<Map<String, List<Map<String, String>>>> TYPE_REF =
            new TypeReference<>() {};
    @Override
    public String convertToDatabaseColumn(Map<String, List<Map<String, String>>> attribute) {
        if (attribute == null || attribute.isEmpty()) return "{}";
        try {
            return MAPPER.writeValueAsString(attribute);
        } catch (Exception e) {
            throw new IllegalStateException(
                    "Erreur serialisation Map<String, List<Map<String,String>>> -> JSON", e);
        }
    }
    @Override
    public Map<String, List<Map<String, String>>> convertToEntityAttribute(String dbData) {
        if (dbData == null || dbData.isBlank()) return Collections.emptyMap();
        try {
            return MAPPER.readValue(dbData, TYPE_REF);
        } catch (Exception e) {
            throw new IllegalStateException(
                    "Erreur deserialisation JSON -> Map<String, List<Map<String,String>>>", e);
        }
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/converter/TemplateFieldListJsonConverter.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/converter/TemplateFieldListJsonConverter.java
@@ -86,7 +86,7 @@ public class TemplateFieldListJsonConverter
                        }
                    }
                    List<String> labels = null;
-                    if (type == FieldType.KEY_VALUE_LIST || type == FieldType.TABLE) {
+                    if (type == FieldType.KEY_VALUE_LIST) {
                        JsonNode labelsNode = item.path("labels");
                        if (labelsNode.isArray()) {
                            labels = new ArrayList<>();
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/ArcJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ArcJpaEntity.java
@@ -3,7 +3,6 @@ package com.loremind.infrastructure.persistence.entity;
 import com.loremind.domain.campaigncontext.ArcType;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import jakarta.persistence.*;
 import org.hibernate.annotations.ColumnDefault;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -43,12 +42,8 @@ public class ArcJpaEntity {
     * Type structurel de l'arc (LINEAR par défaut).
     * Stocké en STRING pour rester lisible en DB et résistant aux refactos d'ordre.
     */
    // length + @ColumnDefault (PAS columnDefinition brut) : Hibernate 6.6 recopie
    // columnDefinition tel quel dans son ALTER ... SET DATA TYPE de migration, et
    // PostgreSQL refuse DEFAULT à cet endroit (erreur à chaque démarrage).
    @Enumerated(EnumType.STRING)
-    @Column(nullable = false, length = 16)
+    @Column(nullable = false, columnDefinition = "VARCHAR(16) DEFAULT 'LINEAR'")
    @ColumnDefault("'LINEAR'")
    @Builder.Default
    private ArcType type = ArcType.LINEAR;
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/CatalogItemJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/CatalogItemJpaEntity.java
@@ -1,49 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
 /**
 * Entité JPA d'un objet de catalogue (enfant de {@link ItemCatalogJpaEntity}).
 * Ordonné par {@code position}. Référence parente exclue de toString/equals.
 */
@Entity
@Table(name = "catalog_items", indexes = {
        @Index(name = "idx_catalog_items_catalog_id", columnList = "catalog_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class CatalogItemJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(length = 64)
    private String price;
    @Column(length = 128)
    private String category;
    @Column(columnDefinition = "TEXT")
    private String description;
    @Column(nullable = false)
    private int position;
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    @JoinColumn(name = "catalog_id", nullable = false)
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    private ItemCatalogJpaEntity catalog;
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/ItemCatalogJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ItemCatalogJpaEntity.java
@@ -1,71 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * Entité JPA d'un catalogue d'objets (parent) avec ses objets ordonnés (enfants).
 */
@Entity
@Table(name = "item_catalogs", indexes = {
        @Index(name = "idx_item_catalogs_campaign_id", columnList = "campaign_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class ItemCatalogJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(columnDefinition = "TEXT")
    private String description;
    @Column(length = 64)
    private String icon;
    @Column(name = "campaign_id", nullable = false)
    private Long campaignId;
    @Column(name = "\"order\"", nullable = false)
    private int order;
    @OneToMany(
            mappedBy = "catalog",
            cascade = CascadeType.ALL,
            orphanRemoval = true,
            fetch = FetchType.LAZY
    )
    @OrderBy("position ASC")
    @Builder.Default
    private List<CatalogItemJpaEntity> items = new ArrayList<>();
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;
    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }
    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookJpaEntity.java
@@ -1,47 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
@Entity
@Table(name = "notebooks", indexes = {
        @Index(name = "idx_notebooks_campaign_id", columnList = "campaign_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class NotebookJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(name = "campaign_id", nullable = false)
    private Long campaignId;
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;
    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }
    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookMessageJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookMessageJpaEntity.java
@@ -1,41 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
@Entity
@Table(name = "notebook_messages", indexes = {
        @Index(name = "idx_notebook_messages_notebook_id", columnList = "notebook_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class NotebookMessageJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "notebook_id", nullable = false)
    private Long notebookId;
    @Column(nullable = false, length = 16)
    private String role;
    @Column(columnDefinition = "TEXT", nullable = false)
    private String content;
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    @PrePersist
    protected void onCreate() {
        if (createdAt == null) createdAt = LocalDateTime.now();
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookSourceJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/NotebookSourceJpaEntity.java
@@ -1,47 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
@Entity
@Table(name = "notebook_sources", indexes = {
        @Index(name = "idx_notebook_sources_notebook_id", columnList = "notebook_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class NotebookSourceJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "notebook_id", nullable = false)
    private Long notebookId;
    @Column(nullable = false)
    private String filename;
    @Column(nullable = false, length = 16)
    private String status;
    @Column(name = "chunk_count", nullable = false)
    private int chunkCount;
    @Column(name = "page_count", nullable = false)
    private int pageCount;
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    @PrePersist
    protected void onCreate() {
        if (createdAt == null) createdAt = LocalDateTime.now();
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/NpcJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/NpcJpaEntity.java
@@ -1,6 +1,5 @@
 package com.loremind.infrastructure.persistence.entity;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapMapJsonConverter;
@@ -55,14 +54,6 @@ public class NpcJpaEntity {
    @Column(name = "campaign_id", nullable = false)
    private Long campaignId;
    /** IDs de Pages de Lore référencées (référence faible cross-context). JSON TEXT. */
    @Convert(converter = StringListJsonConverter.class)
    @Column(name = "related_page_ids", columnDefinition = "TEXT")
    private List<String> relatedPageIds;
    @Column(name = "folder")
    private String folder;
    @Column(name = "\"order\"", nullable = false)
    private int order;
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java
@@ -3,8 +3,6 @@ package com.loremind.infrastructure.persistence.entity;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringMapMapJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringRowListMapJsonConverter;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -54,16 +52,6 @@ public class PageJpaEntity {
    @Convert(converter = StringListMapJsonConverter.class)
    private Map<String, List<String>> imageValues;
    /** Valeurs des champs KEY_VALUE_LIST : fieldName → (label → valeur). JSON TEXT. */
    @Column(name = "key_value_values", columnDefinition = "TEXT")
    @Convert(converter = StringMapMapJsonConverter.class)
    private Map<String, Map<String, String>> keyValueValues;
    /** Valeurs des champs TABLE : fieldName → lignes (colonne → cellule). JSON TEXT. */
    @Column(name = "table_values", columnDefinition = "TEXT")
    @Convert(converter = StringRowListMapJsonConverter.class)
    private Map<String, List<Map<String, String>>> tableValues;
    @Column(columnDefinition = "TEXT")
    private String notes;
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/RandomTableEntryJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/RandomTableEntryJpaEntity.java
@@ -1,51 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
 /**
 * Entité JPA d'une entrée de table aléatoire (enfant de {@link RandomTableJpaEntity}).
 * Ordonnée par {@code position}. La référence parente est exclue de toString/equals
 * pour éviter les récursions infinies (relation bidirectionnelle).
 */
@Entity
@Table(name = "random_table_entries", indexes = {
        @Index(name = "idx_random_table_entries_table_id", columnList = "random_table_id")
 })
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class RandomTableEntryJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "min_roll", nullable = false)
    private int minRoll;
    @Column(name = "max_roll", nullable = false)
    private int maxRoll;
    @Column(nullable = false)
    private String label;
    @Column(columnDefinition = "TEXT")
    private String detail;
    /** Position d'affichage dans la table (ordre des entrées). */
    @Column(nullable = false)
    private int position;
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    @JoinColumn(name = "random_table_id", nullable = false)
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    private RandomTableJpaEntity randomTable;
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/entity/RandomTableJpaEntity.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/RandomTableJpaEntity.java
@@ -1,73 +0,0 @@
 package com.loremind.infrastructure.persistence.entity;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * Entité JPA d'une table aléatoire (parent) avec ses entrées ordonnées (enfants).
 * Tables créées automatiquement par Hibernate (ddl-auto=update).
 */
@Entity
@Table(name = "random_tables")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
 public class RandomTableJpaEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(columnDefinition = "TEXT")
    private String description;
    @Column(name = "dice_formula", nullable = false, length = 32)
    private String diceFormula;
    @Column(length = 64)
    private String icon;
    @Column(name = "campaign_id", nullable = false)
    private Long campaignId;
    @Column(name = "\"order\"", nullable = false)
    private int order;
    @OneToMany(
            mappedBy = "randomTable",
            cascade = CascadeType.ALL,
            orphanRemoval = true,
            fetch = FetchType.LAZY
    )
    @OrderBy("position ASC")
    @Builder.Default
    private List<RandomTableEntryJpaEntity> entries = new ArrayList<>();
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;
    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }
    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ItemCatalogJpaRepository.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ItemCatalogJpaRepository.java
@@ -1,13 +0,0 @@
 package com.loremind.infrastructure.persistence.jpa;
 import com.loremind.infrastructure.persistence.entity.ItemCatalogJpaEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 import java.util.List;
@Repository
 public interface ItemCatalogJpaRepository extends JpaRepository<ItemCatalogJpaEntity, Long> {
    List<ItemCatalogJpaEntity> findByCampaignIdOrderByOrderAsc(Long campaignId);
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/NotebookJpaRepository.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/NotebookJpaRepository.java
@@ -1,12 +0,0 @@
 package com.loremind.infrastructure.persistence.jpa;
 import com.loremind.infrastructure.persistence.entity.NotebookJpaEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 import java.util.List;
@Repository
 public interface NotebookJpaRepository extends JpaRepository<NotebookJpaEntity, Long> {
    List<NotebookJpaEntity> findByCampaignIdOrderByUpdatedAtDesc(Long campaignId);
 }
--- a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/NotebookMessageJpaRepository.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/NotebookMessageJpaRepository.java
@@ -1,13 +0,0 @@
 package com.loremind.infrastructure.persistence.jpa;
 import com.loremind.infrastructure.persistence.entity.NotebookMessageJpaEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 import java.util.List;
@Repository
 public interface NotebookMessageJpaRepository extends JpaRepository<NotebookMessageJpaEntity, Long> {
    List<NotebookMessageJpaEntity> findByNotebookIdOrderByCreatedAtAsc(Long notebookId);
    void deleteByNotebookId(Long notebookId);
 }
--- a/Show More
+++ b/Show More