Plusieurs ajouts :

- Possibilité de configurer des lieux dans une scène : permet de configurer un donjon par exemple avec les pièces, les trésors par pièce, la narration..... Mise en place également de conditions permettant de conditionner le déblocage des quêtes.
- Possibilité de transformé un arc en instance non linéaire afin de faire un hub. Permet de jouer de préparer des campagnes type Dragon of Icespire peak plus facilement.
- Configuration de partie : chaque partie va contenir les séances, ce qui permettra de suivre le déblocage des conditions pour les quêtes.

Passage en 0.9.1-beta

.gitea/workflows/release.yml

@@ -42,19 +42,24 @@ jobs:
           username: ${{ env.GHCR_NAMESPACE }}
           password: ${{ secrets.GHCR_TOKEN }}
 
-      - name: Extract version
+      # Detection du canal :
+      #   - tag vX.Y.Z         -> stable (push :latest + :version sur les repos publics)
+      #   - tag vX.Y.Z-beta*   -> beta  (push :beta + :version sur les repos GHCR prives
+      #                                  loremind-beta-<component> ; backup Gitea avec :version)
+      - name: Extract version & channel
         id: meta
-        run: echo "version=${GITHUB_REF_NAME#v}" >> $GITHUB_OUTPUT
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          if [[ "${VERSION}" == *-beta* ]]; then
+            echo "channel=beta" >> $GITHUB_OUTPUT
+          else
+            echo "channel=stable" >> $GITHUB_OUTPUT
+          fi
 
-      # Push vers les deux registries en un seul build (build-push-action
-      # accepte une liste de tags ; aucun build supplementaire necessaire).
-      # Naming :
-      #   - Gitea : conserve l'ancien pattern ietm64/<component> pour ne pas
-      #             casser les installs existantes qui ont REGISTRY=git.igmlcreation.fr
-      #             dans leur .env.
-      #   - GHCR  : nouveau pattern igmlcreation/loremind-<component> qui evite
-      #             la collision avec d'autres projets de l'org.
-      - name: Build & push ${{ matrix.component }}
+      # Build & push canal STABLE
+      - name: Build & push ${{ matrix.component }} (stable)
+        if: steps.meta.outputs.channel == 'stable'
         uses: docker/build-push-action@v5
         with:
           context: ./${{ matrix.component }}
@@ -64,3 +69,73 @@ jobs:
             ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/${{ matrix.component }}:${{ steps.meta.outputs.version }}
             ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-${{ matrix.component }}:latest
             ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-${{ matrix.component }}:${{ steps.meta.outputs.version }}
+
+      # Build & push canal BETA
+      # GHCR : repos prives loremind-beta-<component> (gated par PAT distribue
+      #        via le relais Patreon aux tiers Compagnon).
+      # Gitea : backup prive avec :version uniquement (pas de :latest pour ne
+      #         pas faire upgrader les installs branchees sur Gitea).
+      - name: Build & push ${{ matrix.component }} (beta)
+        if: steps.meta.outputs.channel == 'beta'
+        uses: docker/build-push-action@v5
+        with:
+          context: ./${{ matrix.component }}
+          push: true
+          tags: |
+            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/${{ matrix.component }}:${{ steps.meta.outputs.version }}
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-beta-${{ matrix.component }}:beta
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-beta-${{ matrix.component }}:${{ steps.meta.outputs.version }}
+
+  # Job separe pour le sidecar `switcher`.
+  # Pourquoi separe : le switcher est volontairement HORS de IMAGE_NAMESPACE
+  # (cf. docker-compose.yml). Il est toujours pulle depuis le repo public
+  # `loremind-switcher`, quel que soit le canal de l'instance. On le build
+  # donc uniquement sur les releases stables — pas la peine de re-publier
+  # une variante beta du switcher, c'est une infrastructure neutre.
+  build-switcher:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Detect channel
+        id: meta
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          if [[ "${VERSION}" == *-beta* ]]; then
+            echo "channel=beta" >> $GITHUB_OUTPUT
+          else
+            echo "channel=stable" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Login to Gitea Registry
+        if: steps.meta.outputs.channel == 'stable'
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GITEA_REGISTRY }}
+          username: ${{ env.GITEA_REGISTRY_USER }}
+          password: ${{ secrets.DOCKER_PAT }}
+
+      - name: Login to GHCR
+        if: steps.meta.outputs.channel == 'stable'
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.GHCR_REGISTRY }}
+          username: ${{ env.GHCR_NAMESPACE }}
+          password: ${{ secrets.GHCR_TOKEN }}
+
+      - name: Build & push switcher (stable only)
+        if: steps.meta.outputs.channel == 'stable'
+        uses: docker/build-push-action@v5
+        with:
+          context: ./switcher
+          push: true
+          tags: |
+            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/switcher:latest
+            ${{ env.GITEA_REGISTRY }}/${{ env.GITEA_REGISTRY_USER }}/switcher:${{ steps.meta.outputs.version }}
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-switcher:latest
+            ${{ env.GHCR_REGISTRY }}/${{ env.GHCR_NAMESPACE }}/loremind-switcher:${{ steps.meta.outputs.version }}

.gitignore

@@ -107,3 +107,4 @@ docker-compose.override.yml
 # Relais OAuth Patreon (repo Gitea separe, clone localement pour facilite)
 # ============================================================================
 relay/
+scripts/bump-version.mjs

brain/app/application/chat.py

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

brain/app/domain/models.py

@@ -122,9 +122,29 @@ class SceneBranchHint:
     condition: str | None = None
 
 
+@dataclass(frozen=True)
+class RoomBranchHint:
+    """Indice d'une sortie entre pièces (donjon). target_room_name déjà résolu côté Core."""
+
+    label: str
+    target_room_name: str
+    condition: str | None = None
+
+
+@dataclass(frozen=True)
+class RoomSummary:
+    """Pièce d'un lieu explorable. Projection plate pour le prompt IA (pas de notes MJ)."""
+
+    name: str
+    floor: int | None = None
+    description: str | None = None
+    enemies: str | None = None
+    branches: list[RoomBranchHint] = field(default_factory=list)
+
+
 @dataclass(frozen=True)
 class SceneSummary:
-    """Résumé d'une scène : nom + description courte + illustrations + branches."""
+    """Résumé d'une scène : nom + description courte + illustrations + branches + pièces."""
 
     name: str
     description: str | None
@@ -133,6 +153,8 @@ class SceneSummary:
     illustration_count: int = 0
     # Connexions narratives sortantes (livre dont vous etes le heros).
     branches: list[SceneBranchHint] = field(default_factory=list)
+    # Pièces du lieu explorable (vide = scène classique).
+    rooms: list[RoomSummary] = field(default_factory=list)
 
 
 @dataclass(frozen=True)
@@ -229,3 +251,53 @@ class GameSystemContext:
     system_name: str
     system_description: str | None
     sections: dict[str, str]
+
+
+@dataclass(frozen=True)
+class JournalEntrySummary:
+    """Une entrée du journal d'une Session.
+
+    `source_session_name` n'est renseigné que pour les entrées issues de
+    sessions précédentes (option 3 : continuité narrative entre séances).
+    """
+
+    type: str
+    content: str
+    occurred_at: str | None
+    source_session_name: str | None = None
+
+
+@dataclass(frozen=True)
+class QuestSummary:
+    """Résumé d'une quête (Chapter dans un Arc HUB) pour le system prompt.
+
+    Volontairement sans notes MJ ni statut texte : c'est déjà classé côté Core
+    dans available_quests / in_progress_quests / locked_quest_titles.
+    """
+
+    name: str
+    arc_name: str
+    description: str | None = None
+
+
+@dataclass(frozen=True)
+class SessionContext:
+    """Contexte d'une Session de jeu en cours (Play Context).
+
+    Combine plusieurs niveaux :
+    - `entries` : journal COMPLET de la session courante (cappé ~80 entrées)
+    - `previous_events` : EVENTs marquants des sessions précédentes (continuité)
+    - `available_quests` / `in_progress_quests` : quêtes du Hub ouvertes
+    - `locked_quest_titles` : titres seuls des quêtes verrouillées (anti-spoiler)
+    - `active_flags` : noms des flags de campagne actuellement à true
+    """
+
+    session_name: str
+    active: bool
+    started_at: str | None
+    entries: list[JournalEntrySummary]
+    previous_events: list[JournalEntrySummary]
+    available_quests: list[QuestSummary] = field(default_factory=list)
+    in_progress_quests: list[QuestSummary] = field(default_factory=list)
+    locked_quest_titles: list[str] = field(default_factory=list)
+    active_flags: list[str] = field(default_factory=list)

brain/app/main.py

@@ -26,13 +26,18 @@ from app.domain.models import (
     NpcSummary,
     ChatMessage,
     GameSystemContext,
+    JournalEntrySummary,
     LoreStructuralContext,
     NarrativeEntityContext,
     PageContext,
     PageGenerationContext,
     PageSummary,
+    QuestSummary,
+    RoomBranchHint,
+    RoomSummary,
     SceneBranchHint,
     SceneSummary,
+    SessionContext,
 )
 from app.domain.ports import LLMProvider, LLMProviderError
 from app.infrastructure.ollama_adapter import OllamaLLMProvider
@@ -41,7 +46,7 @@ from app.infrastructure.onemin_adapter import OneMinAiLLMProvider
 app = FastAPI(
     title="LoreMind Brain",
     description="Backend IA pour la génération de contenu narratif.",
-    version="0.8.3",
+    version="0.9.1-beta",
 )
 
 
@@ -169,6 +174,24 @@ class SceneBranchHintDTO(BaseModel):
     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)."""
 
@@ -179,6 +202,8 @@ class SceneSummaryDTO(BaseModel):
     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):
@@ -243,13 +268,54 @@ class GameSystemContextDTO(BaseModel):
     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 4 contextes (lore, page, campaign, narrative_entity) sont optionnels,
-    mais au moins l'un des deux "niveaux haut" (lore_context ou
-    campaign_context) doit être fourni. Le validateur `check_scope` applique
-    cette règle à la frontière HTTP.
+    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)
@@ -258,10 +324,15 @@ class ChatStreamRequestDTO(BaseModel):
     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 ou Campagne) est fourni."""
-        return self.lore_context is not None or self.campaign_context is not None
+        """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
+        )
 
 
 # --- Factories d'injection de dépendance ---
@@ -385,6 +456,7 @@ async def chat_stream(
     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
@@ -397,6 +469,7 @@ async def chat_stream(
         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
@@ -421,6 +494,7 @@ async def chat_stream(
                 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"
@@ -549,6 +623,23 @@ def _to_campaign_context(dto: CampaignContextDTO | None) -> CampaignStructuralCo
                                 )
                                 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
                     ],
@@ -867,3 +958,36 @@ def _to_game_system_context(dto: GameSystemContextDTO | None) -> GameSystemConte
         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,
+    )

core/pom.xml

@@ -8,13 +8,13 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.2.0</version>
+        <version>3.2.12</version>
         <relativePath/>
     </parent>
 
     <groupId>com.loremind</groupId>
     <artifactId>loremind-core</artifactId>
-    <version>0.8.3</version>
+    <version>0.9.1-beta</version>
     <name>LoreMind Core</name>
     <description>Backend Core - Architecture Hexagonale</description>
 
@@ -96,6 +96,15 @@
             <artifactId>bcprov-jdk18on</artifactId>
             <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(). -->
+        <dependency>
+            <groupId>com.google.crypto.tink</groupId>
+            <artifactId>tink</artifactId>
+            <version>1.14.1</version>
+        </dependency>
     </dependencies>
 
     <build>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -14,6 +14,9 @@ import com.loremind.domain.generationcontext.LoreStructuralContext;
 import com.loremind.domain.generationcontext.LoreStructuralContext.PageSummary;
 import com.loremind.domain.generationcontext.NarrativeEntityContext;
 import com.loremind.domain.generationcontext.PageContext;
+import com.loremind.domain.generationcontext.SessionContext;
+import com.loremind.domain.generationcontext.SessionContext.JournalEntrySummary;
+import com.loremind.domain.generationcontext.SessionContext.QuestSummary;
 import org.springframework.stereotype.Component;
 
 import java.util.LinkedHashMap;
@@ -58,9 +61,72 @@ public class BrainChatPayloadBuilder {
         if (request.gameSystemContext() != null) {
             root.put("game_system_context", gameSystemContextToMap(request.gameSystemContext()));
         }
+        if (request.sessionContext() != null) {
+            root.put("session_context", sessionContextToMap(request.sessionContext()));
+        }
         return root;
     }
 
+    private Map<String, Object> sessionContextToMap(SessionContext sc) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("session_name", sc.sessionName());
+        map.put("active", sc.active());
+        if (sc.startedAt() != null) {
+            map.put("started_at", sc.startedAt().toString());
+        }
+        map.put("entries", sc.entries() != null
+                ? sc.entries().stream().map(this::journalEntryToMap).collect(Collectors.toList())
+                : List.of());
+        // Évènements des sessions précédentes : omis si vide (campagne sur sa 1re session).
+        if (sc.previousEvents() != null && !sc.previousEvents().isEmpty()) {
+            map.put("previous_events", sc.previousEvents().stream()
+                    .map(this::journalEntryToMap)
+                    .collect(Collectors.toList()));
+        }
+        // État Hub (quêtes / flags). Toutes les listes sont omises si vides pour ne pas
+        // saturer le prompt sur les campagnes sans Hub.
+        if (sc.availableQuests() != null && !sc.availableQuests().isEmpty()) {
+            map.put("available_quests", sc.availableQuests().stream()
+                    .map(this::questSummaryToMap)
+                    .collect(Collectors.toList()));
+        }
+        if (sc.inProgressQuests() != null && !sc.inProgressQuests().isEmpty()) {
+            map.put("in_progress_quests", sc.inProgressQuests().stream()
+                    .map(this::questSummaryToMap)
+                    .collect(Collectors.toList()));
+        }
+        if (sc.lockedQuestTitles() != null && !sc.lockedQuestTitles().isEmpty()) {
+            map.put("locked_quest_titles", sc.lockedQuestTitles());
+        }
+        if (sc.activeFlags() != null && !sc.activeFlags().isEmpty()) {
+            map.put("active_flags", sc.activeFlags());
+        }
+        return map;
+    }
+
+    private Map<String, Object> questSummaryToMap(QuestSummary q) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("name", q.name());
+        map.put("arc_name", q.arcName());
+        if (q.description() != null && !q.description().isBlank()) {
+            map.put("description", q.description());
+        }
+        return map;
+    }
+
+    private Map<String, Object> journalEntryToMap(JournalEntrySummary e) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("type", e.type());
+        map.put("content", e.content());
+        if (e.occurredAt() != null) {
+            map.put("occurred_at", e.occurredAt().toString());
+        }
+        if (e.sourceSessionName() != null && !e.sourceSessionName().isBlank()) {
+            map.put("source_session_name", e.sourceSessionName());
+        }
+        return map;
+    }
+
     private Map<String, Object> gameSystemContextToMap(GameSystemContext gs) {
         Map<String, Object> map = new LinkedHashMap<>();
         map.put("system_name", gs.systemName());
@@ -215,6 +281,12 @@ public class BrainChatPayloadBuilder {
                                 .map(this::branchHintToMap)
                                 .collect(Collectors.toList()));
                     }
+                    // Pièces du lieu explorable : omises si scène classique.
+                    if (s.rooms() != null && !s.rooms().isEmpty()) {
+                        map.put("rooms", s.rooms().stream()
+                                .map(this::roomSummaryToMap)
+                                .collect(Collectors.toList()));
+                    }
                 });
     }
 
@@ -228,6 +300,24 @@ public class BrainChatPayloadBuilder {
         return map;
     }
 
+    private Map<String, Object> roomSummaryToMap(com.loremind.domain.generationcontext.CampaignStructuralContext.RoomSummary r) {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("name", r.name());
+        if (r.floor() != null) map.put("floor", r.floor());
+        if (r.description() != null && !r.description().isBlank()) map.put("description", r.description());
+        if (r.enemies() != null && !r.enemies().isBlank()) map.put("enemies", r.enemies());
+        if (r.branches() != null && !r.branches().isEmpty()) {
+            map.put("branches", r.branches().stream().map(b -> {
+                Map<String, Object> bm = new LinkedHashMap<>();
+                bm.put("label", b.label());
+                bm.put("target_room_name", b.targetRoomName());
+                if (b.condition() != null && !b.condition().isBlank()) bm.put("condition", b.condition());
+                return bm;
+            }).collect(Collectors.toList()));
+        }
+        return map;
+    }
+
     private Map<String, Object> narrativeEntityToMap(NarrativeEntityContext ne) {
         Map<String, Object> map = new LinkedHashMap<>();
         map.put("entity_type", ne.entityType());

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

@@ -0,0 +1,98 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loremind.domain.campaigncontext.Prerequisite;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Convertit une List<Prerequisite> (sealed type du domaine) en JSON stocké en base.
+ * <p>
+ * On utilise un discriminant {@code kind} explicite pour éviter de polluer le domaine
+ * avec des annotations Jackson (@JsonTypeInfo / @JsonSubTypes). Le format on-disk est
+ * stable et indépendant des noms de classes Java.
+ * <p>
+ * Format JSON :
+ *   [
+ *     {"kind": "QUEST_COMPLETED", "questId": "42"},
+ *     {"kind": "SESSION_REACHED", "minSessionNumber": 3},
+ *     {"kind": "FLAG_SET",        "flagName": "forgeron_rencontre"}
+ *   ]
+ */
+@Converter
+public class PrerequisiteListJsonConverter implements AttributeConverter<List<Prerequisite>, String> {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private static final String KIND = "kind";
+    private static final String KIND_QUEST_COMPLETED = "QUEST_COMPLETED";
+    private static final String KIND_SESSION_REACHED = "SESSION_REACHED";
+    private static final String KIND_FLAG_SET = "FLAG_SET";
+
+    @Override
+    public String convertToDatabaseColumn(List<Prerequisite> attribute) {
+        if (attribute == null || attribute.isEmpty()) return "[]";
+        try {
+            List<Map<String, Object>> raw = new ArrayList<>(attribute.size());
+            for (Prerequisite p : attribute) {
+                raw.add(toMap(p));
+            }
+            return MAPPER.writeValueAsString(raw);
+        } catch (Exception e) {
+            throw new IllegalStateException("Erreur sérialisation List<Prerequisite> → JSON", e);
+        }
+    }
+
+    @Override
+    public List<Prerequisite> convertToEntityAttribute(String dbData) {
+        if (dbData == null || dbData.isBlank()) return new ArrayList<>();
+        try {
+            List<Map<String, Object>> raw = MAPPER.readValue(dbData, new TypeReference<>() {});
+            List<Prerequisite> result = new ArrayList<>(raw.size());
+            for (Map<String, Object> m : raw) {
+                result.add(fromMap(m));
+            }
+            return result;
+        } catch (Exception e) {
+            throw new IllegalStateException("Erreur désérialisation JSON → List<Prerequisite>", e);
+        }
+    }
+
+    private Map<String, Object> toMap(Prerequisite p) {
+        Map<String, Object> m = new HashMap<>();
+        if (p instanceof Prerequisite.QuestCompleted q) {
+            m.put(KIND, KIND_QUEST_COMPLETED);
+            m.put("questId", q.questId());
+        } else if (p instanceof Prerequisite.SessionReached s) {
+            m.put(KIND, KIND_SESSION_REACHED);
+            m.put("minSessionNumber", s.minSessionNumber());
+        } else if (p instanceof Prerequisite.FlagSet f) {
+            m.put(KIND, KIND_FLAG_SET);
+            m.put("flagName", f.flagName());
+        } else {
+            throw new IllegalStateException("Prerequisite non géré : " + p.getClass().getName());
+        }
+        return m;
+    }
+
+    private Prerequisite fromMap(Map<String, Object> m) {
+        String kind = String.valueOf(m.get(KIND));
+        switch (kind) {
+            case KIND_QUEST_COMPLETED:
+                return new Prerequisite.QuestCompleted(String.valueOf(m.get("questId")));
+            case KIND_SESSION_REACHED:
+                Object n = m.get("minSessionNumber");
+                return new Prerequisite.SessionReached(((Number) n).intValue());
+            case KIND_FLAG_SET:
+                return new Prerequisite.FlagSet(String.valueOf(m.get("flagName")));
+            default:
+                throw new IllegalStateException("Kind Prerequisite inconnu : " + kind);
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loremind.domain.campaigncontext.Room;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Convertit la liste de pièces explorables d'une Scene en JSON pour la persistance.
+ *
+ * <p>Une Room contient elle-même une liste de {@link com.loremind.domain.campaigncontext.RoomBranch}
+ * (record Java) ; Jackson 2.12+ sait sérialiser/désérialiser les records nativement
+ * via le constructeur canonique, donc rien de spécial à faire pour les branches.</p>
+ */
+@Converter
+public class RoomListJsonConverter implements AttributeConverter<List<Room>, String> {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    @Override
+    public String convertToDatabaseColumn(List<Room> attribute) {
+        if (attribute == null || attribute.isEmpty()) return "[]";
+        try {
+            return MAPPER.writeValueAsString(attribute);
+        } catch (Exception e) {
+            throw new IllegalStateException("Erreur sérialisation List<Room> → JSON", e);
+        }
+    }
+
+    @Override
+    public List<Room> convertToEntityAttribute(String dbData) {
+        if (dbData == null || dbData.isBlank()) return Collections.emptyList();
+        try {
+            return MAPPER.readValue(dbData, new TypeReference<>() {});
+        } catch (Exception e) {
+            throw new IllegalStateException("Erreur désérialisation JSON → List<Room>", e);
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 package com.loremind.infrastructure.persistence.entity;
 
+import com.loremind.domain.campaigncontext.ArcType;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
@@ -37,6 +38,15 @@ public class ArcJpaEntity {
     @Column(name = "\"order\"", nullable = false)
     private int order;
 
+    /**
+     * Type structurel de l'arc (LINEAR par défaut).
+     * Stocké en STRING pour rester lisible en DB et résistant aux refactos d'ordre.
+     */
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false, columnDefinition = "VARCHAR(16) DEFAULT 'LINEAR'")
+    @Builder.Default
+    private ArcType type = ArcType.LINEAR;
+
     @Column
     private String icon;
 

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

@@ -1,5 +1,7 @@
 package com.loremind.infrastructure.persistence.entity;
 
+import com.loremind.domain.campaigncontext.Prerequisite;
+import com.loremind.infrastructure.persistence.converter.PrerequisiteListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
@@ -37,6 +39,16 @@ public class ChapterJpaEntity {
     @Column(name = "\"order\"", nullable = false)
     private int order;
 
+    /**
+     * Conditions de déblocage (combinées en ET). Sérialisées en JSON dans une colonne TEXT
+     * via {@link PrerequisiteListJsonConverter} (sealed type côté domaine).
+     * Donnée de SCÉNARIO — l'état réel est sur Playthrough.QuestProgression.
+     */
+    @Column(name = "prerequisites", columnDefinition = "TEXT")
+    @Convert(converter = PrerequisiteListJsonConverter.class)
+    @Builder.Default
+    private List<Prerequisite> prerequisites = new ArrayList<>();
+
     @Column
     private String icon;
 

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

@@ -59,9 +59,17 @@ public class CharacterJpaEntity {
     @Column(name = "key_value_values", columnDefinition = "TEXT")
     private Map<String, Map<String, String>> keyValueValues;
 
-    @Column(name = "campaign_id", nullable = false)
+    /**
+     * Ancienne référence directe vers la Campaign. Conservée nullable pour la
+     * migration ; le code utilise playthrough_id désormais.
+     */
+    @Column(name = "campaign_id")
     private Long campaignId;
 
+    /** ID du Playthrough (partie) auquel ce PJ appartient. Weak ref cross-context. */
+    @Column(name = "playthrough_id")
+    private Long playthroughId;
+
     @Column(name = "\"order\"", nullable = false)
     private int order;
 

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

@@ -0,0 +1,42 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Entité JPA pour les flags narratifs d'un Playthrough.
+ *
+ * <p>Remplace l'ancienne {@code CampaignFlagJpaEntity} : les flags suivent
+ * désormais la partie (table jouée), pas le scénario.</p>
+ */
+@Entity
+@Table(
+        name = "playthrough_flag",
+        uniqueConstraints = @UniqueConstraint(
+                name = "uk_playthrough_flag_name",
+                columnNames = {"playthrough_id", "name"}
+        ),
+        indexes = @Index(name = "ix_playthrough_flag_playthrough", columnList = "playthrough_id")
+)
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PlaythroughFlagJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "playthrough_id", nullable = false)
+    private Long playthroughId;
+
+    @Column(nullable = false, length = 128)
+    private String name;
+
+    @Column(nullable = false)
+    private boolean value;
+}

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

@@ -0,0 +1,54 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la table {@code playthroughs} — instances jouées d'une Campagne.
+ */
+@Entity
+@Table(
+        name = "playthroughs",
+        indexes = @Index(name = "ix_playthrough_campaign", columnList = "campaign_id")
+)
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PlaythroughJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "campaign_id", nullable = false)
+    private Long campaignId;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(columnDefinition = "TEXT")
+    private String description;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.domain.campaigncontext.ProgressionStatus;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Entité JPA pour la progression d'une quête (Chapter) au sein d'un Playthrough.
+ *
+ * <p>Contrainte d'unicité sur (playthrough_id, chapter_id) : une seule ligne par
+ * couple quête × partie. L'absence de ligne = NOT_STARTED.</p>
+ */
+@Entity
+@Table(
+        name = "quest_progression",
+        uniqueConstraints = @UniqueConstraint(
+                name = "uk_quest_progression_unique",
+                columnNames = {"playthrough_id", "chapter_id"}
+        ),
+        indexes = @Index(name = "ix_quest_progression_playthrough", columnList = "playthrough_id")
+)
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class QuestProgressionJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "playthrough_id", nullable = false)
+    private Long playthroughId;
+
+    @Column(name = "chapter_id", nullable = false)
+    private Long chapterId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false, length = 16)
+    private ProgressionStatus status;
+}

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

@@ -1,6 +1,8 @@
 package com.loremind.infrastructure.persistence.entity;
 
+import com.loremind.domain.campaigncontext.Room;
 import com.loremind.domain.campaigncontext.SceneBranch;
+import com.loremind.infrastructure.persistence.converter.RoomListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.SceneBranchListJsonConverter;
 import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
 import jakarta.persistence.*;
@@ -95,6 +97,15 @@ public class SceneJpaEntity {
     @Builder.Default
     private List<SceneBranch> branches = new ArrayList<>();
 
+    /**
+     * Pièces explorables de cette scène (donjon, crypte…). Vide = scène classique.
+     * Sérialisé en JSON dans une colonne TEXT.
+     */
+    @Column(name = "rooms", columnDefinition = "TEXT")
+    @Convert(converter = RoomListJsonConverter.class)
+    @Builder.Default
+    private List<Room> rooms = new ArrayList<>();
+
     @Column(name = "created_at", nullable = false, updatable = false)
     private LocalDateTime createdAt;
 

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

@@ -0,0 +1,60 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.domain.playcontext.EntryType;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la persistance des entrées de journal de session.
+ */
+@Entity
+@Table(name = "session_entries", indexes = {
+    @Index(name = "idx_session_entries_session_id", columnList = "session_id")
+})
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SessionEntryJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    /** Weak reference — pas de FK DB pour rester cohérent avec le reste du projet. */
+    @Column(name = "session_id", nullable = false)
+    private String sessionId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false, length = 32)
+    private EntryType type;
+
+    @Column(columnDefinition = "TEXT", nullable = false)
+    private String content;
+
+    @Column(name = "occurred_at", nullable = false)
+    private LocalDateTime occurredAt;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        LocalDateTime now = LocalDateTime.now();
+        createdAt = now;
+        updatedAt = now;
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la persistance des Sessions en PostgreSQL.
+ * Adaptateur d'infrastructure — n'est PAS dans le domaine.
+ */
+@Entity
+@Table(name = "sessions")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SessionJpaEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    /**
+     * Ancienne référence directe vers la Campaign. Conservée (nullable) pour la
+     * rétrocompatibilité de la migration, mais plus utilisée par le code.
+     * À supprimer manuellement quand toutes les sessions auront leur playthrough_id.
+     */
+    @Column(name = "campaign_id")
+    private String campaignId;
+
+    /**
+     * ID du Playthrough (partie) auquel cette session appartient.
+     * Weak reference inter-contexte.
+     */
+    @Column(name = "playthrough_id")
+    private Long playthroughId;
+
+    @Column(name = "started_at", nullable = false)
+    private LocalDateTime startedAt;
+
+    /** Null = session en cours. */
+    @Column(name = "ended_at")
+    private LocalDateTime endedAt;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        LocalDateTime now = LocalDateTime.now();
+        createdAt = now;
+        updatedAt = now;
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

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

@@ -9,5 +9,5 @@ import java.util.List;
 @Repository
 public interface CharacterJpaRepository extends JpaRepository<CharacterJpaEntity, Long> {
 
-    List<CharacterJpaEntity> findByCampaignIdOrderByOrderAsc(Long campaignId);
+    List<CharacterJpaEntity> findByPlaythroughIdOrderByOrderAsc(Long playthroughId);
 }

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

@@ -0,0 +1,25 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.PlaythroughFlagJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface PlaythroughFlagJpaRepository extends JpaRepository<PlaythroughFlagJpaEntity, Long> {
+
+    List<PlaythroughFlagJpaEntity> findByPlaythroughId(Long playthroughId);
+
+    Optional<PlaythroughFlagJpaEntity> findByPlaythroughIdAndName(Long playthroughId, String name);
+
+    @Modifying
+    @Transactional
+    @Query("DELETE FROM PlaythroughFlagJpaEntity f WHERE f.playthroughId = :playthroughId")
+    void deleteByPlaythroughId(@Param("playthroughId") Long playthroughId);
+}

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

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

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

@@ -0,0 +1,25 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.QuestProgressionJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface QuestProgressionJpaRepository extends JpaRepository<QuestProgressionJpaEntity, Long> {
+
+    List<QuestProgressionJpaEntity> findByPlaythroughId(Long playthroughId);
+
+    Optional<QuestProgressionJpaEntity> findByPlaythroughIdAndChapterId(Long playthroughId, Long chapterId);
+
+    @Modifying
+    @Transactional
+    @Query("DELETE FROM QuestProgressionJpaEntity q WHERE q.playthroughId = :playthroughId")
+    void deleteByPlaythroughId(@Param("playthroughId") Long playthroughId);
+}

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

@@ -0,0 +1,15 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.SessionEntryJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SessionEntryJpaRepository extends JpaRepository<SessionEntryJpaEntity, Long> {
+
+    List<SessionEntryJpaEntity> findBySessionIdOrderByOccurredAtAsc(String sessionId);
+
+    void deleteBySessionId(String sessionId);
+}

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

@@ -0,0 +1,21 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.SessionJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Repository Spring Data JPA pour SessionJpaEntity.
+ */
+@Repository
+public interface SessionJpaRepository extends JpaRepository<SessionJpaEntity, Long> {
+
+    List<SessionJpaEntity> findByPlaythroughIdOrderByStartedAtDesc(Long playthroughId);
+
+    Optional<SessionJpaEntity> findFirstByEndedAtIsNull();
+
+    Optional<SessionJpaEntity> findFirstByPlaythroughIdAndEndedAtIsNull(Long playthroughId);
+}

core/src/main/java/com/loremind/infrastructure/persistence/migration/PlaythroughMigrationRunner.java

@@ -0,0 +1,184 @@
+package com.loremind.infrastructure.persistence.migration;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.dao.DataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * Migration one-shot des données existantes vers le modèle Playthrough.
+ *
+ * <p>Idempotente : si une campagne a déjà au moins un Playthrough, on ne crée pas
+ * de Partie par défaut pour elle. Les opérations sur les sessions / characters /
+ * flags / progression sont toutes filtrées sur l'absence de {@code playthrough_id}
+ * pour ne rien dupliquer.</p>
+ *
+ * <p>Étapes :
+ *   1. Crée un Playthrough "Partie principale" pour chaque Campaign qui n'en a pas
+ *   2. Renseigne {@code sessions.playthrough_id} depuis l'ancien {@code campaign_id}
+ *   3. Renseigne {@code characters.playthrough_id} depuis l'ancien {@code campaign_id}
+ *   4. Copie {@code campaign_flag} → {@code playthrough_flag} (si tables présentes)
+ *   5. Copie {@code chapters.progression_status} (≠ NOT_STARTED) → {@code quest_progression}
+ *
+ * <p>S'exécute au démarrage, après Hibernate ddl-auto=update qui aura créé les nouvelles tables.</p>
+ */
+@Configuration
+public class PlaythroughMigrationRunner {
+
+    private static final Logger LOG = LoggerFactory.getLogger(PlaythroughMigrationRunner.class);
+
+    private static final String DEFAULT_PLAYTHROUGH_NAME = "Partie principale";
+
+    @Bean
+    public ApplicationRunner runPlaythroughMigration(JdbcTemplate jdbc) {
+        return args -> migrate(jdbc);
+    }
+
+    @Transactional
+    void migrate(JdbcTemplate jdbc) {
+        // Garde-fou : si la table playthroughs n'existe pas (anciens dumps), on saute.
+        if (!tableExists(jdbc, "playthroughs")) {
+            LOG.warn("Migration Playthrough : table 'playthroughs' absente — Hibernate ne l'a pas créée. Skip.");
+            return;
+        }
+
+        int createdPlaythroughs = createDefaultPlaythroughs(jdbc);
+        int migratedSessions = migrateSessions(jdbc);
+        int migratedCharacters = migrateCharacters(jdbc);
+        int migratedFlags = migrateFlags(jdbc);
+        int migratedProgressions = migrateProgressions(jdbc);
+        // Relaxe les NOT NULL legacy : ddl-auto=update n'assouplit pas les contraintes.
+        relaxLegacyNotNullConstraints(jdbc);
+
+        if (createdPlaythroughs + migratedSessions + migratedCharacters + migratedFlags + migratedProgressions > 0) {
+            LOG.info("Migration Playthrough : {} playthrough(s) créé(s), {} session(s), {} PJ, {} flag(s), {} progression(s)",
+                    createdPlaythroughs, migratedSessions, migratedCharacters, migratedFlags, migratedProgressions);
+        } else {
+            LOG.debug("Migration Playthrough : rien à migrer.");
+        }
+    }
+
+    private int createDefaultPlaythroughs(JdbcTemplate jdbc) {
+        List<Long> campaignsWithoutPlaythrough = jdbc.queryForList(
+                "SELECT c.id FROM campaigns c " +
+                "WHERE NOT EXISTS (SELECT 1 FROM playthroughs p WHERE p.campaign_id = c.id)",
+                Long.class
+        );
+        if (campaignsWithoutPlaythrough.isEmpty()) return 0;
+
+        LocalDateTime now = LocalDateTime.now();
+        for (Long campaignId : campaignsWithoutPlaythrough) {
+            jdbc.update(
+                    "INSERT INTO playthroughs (campaign_id, name, description, created_at, updated_at) " +
+                    "VALUES (?, ?, NULL, ?, ?)",
+                    campaignId, DEFAULT_PLAYTHROUGH_NAME, now, now
+            );
+        }
+        return campaignsWithoutPlaythrough.size();
+    }
+
+    private int migrateSessions(JdbcTemplate jdbc) {
+        if (!columnExists(jdbc, "sessions", "campaign_id")) return 0;
+        return jdbc.update(
+                "UPDATE sessions s " +
+                "SET playthrough_id = (SELECT p.id FROM playthroughs p WHERE p.campaign_id = CAST(s.campaign_id AS BIGINT) LIMIT 1) " +
+                "WHERE s.playthrough_id IS NULL AND s.campaign_id IS NOT NULL"
+        );
+    }
+
+    private int migrateCharacters(JdbcTemplate jdbc) {
+        if (!columnExists(jdbc, "characters", "campaign_id")) return 0;
+        return jdbc.update(
+                "UPDATE characters c " +
+                "SET playthrough_id = (SELECT p.id FROM playthroughs p WHERE p.campaign_id = c.campaign_id LIMIT 1) " +
+                "WHERE c.playthrough_id IS NULL AND c.campaign_id IS NOT NULL"
+        );
+    }
+
+    private int migrateFlags(JdbcTemplate jdbc) {
+        if (!tableExists(jdbc, "campaign_flag") || !tableExists(jdbc, "playthrough_flag")) return 0;
+        // Copie uniquement ce qui n'a pas déjà été copié — on déduplique par (playthrough_id, name)
+        return jdbc.update(
+                "INSERT INTO playthrough_flag (playthrough_id, name, value) " +
+                "SELECT p.id, cf.name, cf.value " +
+                "FROM campaign_flag cf " +
+                "JOIN playthroughs p ON p.campaign_id = cf.campaign_id " +
+                "WHERE NOT EXISTS (" +
+                "    SELECT 1 FROM playthrough_flag pf " +
+                "    WHERE pf.playthrough_id = p.id AND pf.name = cf.name" +
+                ")"
+        );
+    }
+
+    private int migrateProgressions(JdbcTemplate jdbc) {
+        if (!columnExists(jdbc, "chapters", "progression_status")) return 0;
+        if (!tableExists(jdbc, "quest_progression")) return 0;
+        // On copie les chapitres dont la progression était != NOT_STARTED, vers la Partie principale
+        // de la campagne du chapitre. Déduplique via NOT EXISTS sur (playthrough_id, chapter_id).
+        return jdbc.update(
+                "INSERT INTO quest_progression (playthrough_id, chapter_id, status) " +
+                "SELECT p.id, ch.id, ch.progression_status " +
+                "FROM chapters ch " +
+                "JOIN arcs a ON a.id = ch.arc_id " +
+                "JOIN playthroughs p ON p.campaign_id = a.campaign_id " +
+                "WHERE ch.progression_status IS NOT NULL " +
+                "  AND ch.progression_status <> 'NOT_STARTED' " +
+                "  AND NOT EXISTS (" +
+                "      SELECT 1 FROM quest_progression qp " +
+                "      WHERE qp.playthrough_id = p.id AND qp.chapter_id = ch.id" +
+                "  )"
+        );
+    }
+
+    /**
+     * Relâche les NOT NULL hérités des colonnes désormais optionnelles :
+     *   sessions.campaign_id, characters.campaign_id, chapters.progression_status
+     * Idempotent : PostgreSQL ne bronche pas si la colonne est déjà NULLABLE.
+     */
+    private void relaxLegacyNotNullConstraints(JdbcTemplate jdbc) {
+        relaxNotNull(jdbc, "sessions", "campaign_id");
+        relaxNotNull(jdbc, "characters", "campaign_id");
+        relaxNotNull(jdbc, "chapters", "progression_status");
+    }
+
+    private void relaxNotNull(JdbcTemplate jdbc, String table, String column) {
+        if (!columnExists(jdbc, table, column)) return;
+        try {
+            jdbc.execute("ALTER TABLE " + table + " ALTER COLUMN " + column + " DROP NOT NULL");
+        } catch (DataAccessException ex) {
+            // Déjà NULLABLE ou table en cours de migration : log et continue.
+            LOG.debug("relaxNotNull({}.{}) : déjà nullable ou non-applicable", table, column);
+        }
+    }
+
+    private boolean tableExists(JdbcTemplate jdbc, String table) {
+        try {
+            Integer n = jdbc.queryForObject(
+                    "SELECT COUNT(*) FROM information_schema.tables WHERE table_name = ?",
+                    Integer.class, table
+            );
+            return n != null && n > 0;
+        } catch (DataAccessException ex) {
+            return false;
+        }
+    }
+
+    private boolean columnExists(JdbcTemplate jdbc, String table, String column) {
+        try {
+            Integer n = jdbc.queryForObject(
+                    "SELECT COUNT(*) FROM information_schema.columns WHERE table_name = ? AND column_name = ?",
+                    Integer.class, table, column
+            );
+            return n != null && n > 0;
+        } catch (DataAccessException ex) {
+            return false;
+        }
+    }
+}

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

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

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

@@ -12,6 +12,9 @@ import java.util.stream.Collectors;
 
 /**
  * Adaptateur d'infrastructure qui implémente le Port CampaignRepository.
+ * <p>
+ * Depuis l'introduction de Playthrough : ne touche plus aux flags (ils
+ * appartiennent au Playthrough, pas à la Campagne).
  */
 @Repository
 public class PostgresCampaignRepository implements CampaignRepository {

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

@@ -71,6 +71,9 @@ public class PostgresChapterRepository implements ChapterRepository {
                 .description(jpaEntity.getDescription())
                 .arcId(jpaEntity.getArcId().toString())
                 .order(jpaEntity.getOrder())
+                .prerequisites(jpaEntity.getPrerequisites() != null
+                        ? new ArrayList<>(jpaEntity.getPrerequisites())
+                        : new ArrayList<>())
                 .icon(jpaEntity.getIcon())
                 .gmNotes(jpaEntity.getGmNotes())
                 .playerObjectives(jpaEntity.getPlayerObjectives())
@@ -97,6 +100,9 @@ public class PostgresChapterRepository implements ChapterRepository {
                 .description(chapter.getDescription())
                 .arcId(Long.parseLong(chapter.getArcId()))
                 .order(chapter.getOrder())
+                .prerequisites(chapter.getPrerequisites() != null
+                        ? new ArrayList<>(chapter.getPrerequisites())
+                        : new ArrayList<>())
                 .icon(chapter.getIcon())
                 .gmNotes(chapter.getGmNotes())
                 .playerObjectives(chapter.getPlayerObjectives())

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

@@ -33,8 +33,8 @@ public class PostgresCharacterRepository implements CharacterRepository {
     }
 
     @Override
-    public List<Character> findByCampaignId(String campaignId) {
-        return jpaRepository.findByCampaignIdOrderByOrderAsc(Long.parseLong(campaignId)).stream()
+    public List<Character> findByPlaythroughId(String playthroughId) {
+        return jpaRepository.findByPlaythroughIdOrderByOrderAsc(Long.parseLong(playthroughId)).stream()
                 .map(this::toDomainEntity)
                 .collect(Collectors.toList());
     }
@@ -58,7 +58,7 @@ public class PostgresCharacterRepository implements CharacterRepository {
                 .values(e.getValues() != null ? new HashMap<>(e.getValues()) : new HashMap<>())
                 .imageValues(e.getImageValues() != null ? new HashMap<>(e.getImageValues()) : new HashMap<>())
                 .keyValueValues(e.getKeyValueValues() != null ? new HashMap<>(e.getKeyValueValues()) : new HashMap<>())
-                .campaignId(e.getCampaignId().toString())
+                .playthroughId(e.getPlaythroughId() != null ? e.getPlaythroughId().toString() : null)
                 .order(e.getOrder())
                 .createdAt(e.getCreatedAt())
                 .updatedAt(e.getUpdatedAt())
@@ -75,7 +75,7 @@ public class PostgresCharacterRepository implements CharacterRepository {
                 .values(c.getValues() != null ? new HashMap<>(c.getValues()) : new HashMap<>())
                 .imageValues(c.getImageValues() != null ? new HashMap<>(c.getImageValues()) : new HashMap<>())
                 .keyValueValues(c.getKeyValueValues() != null ? new HashMap<>(c.getKeyValueValues()) : new HashMap<>())
-                .campaignId(Long.parseLong(c.getCampaignId()))
+                .playthroughId(c.getPlaythroughId() != null ? Long.parseLong(c.getPlaythroughId()) : null)
                 .order(c.getOrder())
                 .createdAt(c.getCreatedAt())
                 .updatedAt(c.getUpdatedAt())

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

@@ -0,0 +1,56 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.playcontext.ports.PlaythroughFlagRepository;
+import com.loremind.infrastructure.persistence.entity.PlaythroughFlagJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.PlaythroughFlagJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Repository
+public class PostgresPlaythroughFlagRepository implements PlaythroughFlagRepository {
+
+    private final PlaythroughFlagJpaRepository jpa;
+
+    public PostgresPlaythroughFlagRepository(PlaythroughFlagJpaRepository jpa) {
+        this.jpa = jpa;
+    }
+
+    @Override
+    public Map<String, Boolean> findByPlaythroughId(String playthroughId) {
+        Long pid = Long.parseLong(playthroughId);
+        Map<String, Boolean> out = new HashMap<>();
+        for (PlaythroughFlagJpaEntity f : jpa.findByPlaythroughId(pid)) {
+            out.put(f.getName(), f.isValue());
+        }
+        return out;
+    }
+
+    @Override
+    public void setFlag(String playthroughId, String name, boolean value) {
+        Long pid = Long.parseLong(playthroughId);
+        jpa.findByPlaythroughIdAndName(pid, name).ifPresentOrElse(
+                existing -> {
+                    existing.setValue(value);
+                    jpa.save(existing);
+                },
+                () -> jpa.save(PlaythroughFlagJpaEntity.builder()
+                        .playthroughId(pid)
+                        .name(name)
+                        .value(value)
+                        .build())
+        );
+    }
+
+    @Override
+    public void deleteFlag(String playthroughId, String name) {
+        Long pid = Long.parseLong(playthroughId);
+        jpa.findByPlaythroughIdAndName(pid, name).ifPresent(f -> jpa.deleteById(f.getId()));
+    }
+
+    @Override
+    public void deleteAllByPlaythroughId(String playthroughId) {
+        jpa.deleteByPlaythroughId(Long.parseLong(playthroughId));
+    }
+}

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

@@ -0,0 +1,77 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.playcontext.Playthrough;
+import com.loremind.domain.playcontext.ports.PlaythroughRepository;
+import com.loremind.infrastructure.persistence.entity.PlaythroughJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.PlaythroughJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Repository
+public class PostgresPlaythroughRepository implements PlaythroughRepository {
+
+    private final PlaythroughJpaRepository jpa;
+
+    public PostgresPlaythroughRepository(PlaythroughJpaRepository jpa) {
+        this.jpa = jpa;
+    }
+
+    @Override
+    public Playthrough save(Playthrough p) {
+        PlaythroughJpaEntity saved = jpa.save(toJpa(p));
+        return toDomain(saved);
+    }
+
+    @Override
+    public Optional<Playthrough> findById(String id) {
+        return jpa.findById(Long.parseLong(id)).map(this::toDomain);
+    }
+
+    @Override
+    public List<Playthrough> findByCampaignId(String campaignId) {
+        return jpa.findByCampaignId(Long.parseLong(campaignId)).stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<Playthrough> findAll() {
+        return jpa.findAll().stream().map(this::toDomain).collect(Collectors.toList());
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpa.deleteById(Long.parseLong(id));
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpa.existsById(Long.parseLong(id));
+    }
+
+    private Playthrough toDomain(PlaythroughJpaEntity e) {
+        return Playthrough.builder()
+                .id(e.getId().toString())
+                .campaignId(e.getCampaignId().toString())
+                .name(e.getName())
+                .description(e.getDescription())
+                .createdAt(e.getCreatedAt())
+                .updatedAt(e.getUpdatedAt())
+                .build();
+    }
+
+    private PlaythroughJpaEntity toJpa(Playthrough p) {
+        Long id = p.getId() != null ? Long.parseLong(p.getId()) : null;
+        return PlaythroughJpaEntity.builder()
+                .id(id)
+                .campaignId(Long.parseLong(p.getCampaignId()))
+                .name(p.getName())
+                .description(p.getDescription())
+                .createdAt(p.getCreatedAt())
+                .updatedAt(p.getUpdatedAt())
+                .build();
+    }
+}

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

@@ -0,0 +1,78 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.ProgressionStatus;
+import com.loremind.domain.playcontext.QuestProgression;
+import com.loremind.domain.playcontext.ports.QuestProgressionRepository;
+import com.loremind.infrastructure.persistence.entity.QuestProgressionJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.QuestProgressionJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Repository
+public class PostgresQuestProgressionRepository implements QuestProgressionRepository {
+
+    private final QuestProgressionJpaRepository jpa;
+
+    public PostgresQuestProgressionRepository(QuestProgressionJpaRepository jpa) {
+        this.jpa = jpa;
+    }
+
+    @Override
+    public List<QuestProgression> findByPlaythroughId(String playthroughId) {
+        return jpa.findByPlaythroughId(Long.parseLong(playthroughId)).stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Set<String> findCompletedChapterIdsByPlaythroughId(String playthroughId) {
+        Set<String> out = new HashSet<>();
+        for (QuestProgressionJpaEntity e : jpa.findByPlaythroughId(Long.parseLong(playthroughId))) {
+            if (e.getStatus() == ProgressionStatus.COMPLETED) {
+                out.add(e.getChapterId().toString());
+            }
+        }
+        return out;
+    }
+
+    @Override
+    public void setStatus(String playthroughId, String chapterId, ProgressionStatus status) {
+        Long pid = Long.parseLong(playthroughId);
+        Long cid = Long.parseLong(chapterId);
+        // Sémantique : NOT_STARTED = absence de ligne.
+        if (status == null || status == ProgressionStatus.NOT_STARTED) {
+            jpa.findByPlaythroughIdAndChapterId(pid, cid)
+                    .ifPresent(e -> jpa.deleteById(e.getId()));
+            return;
+        }
+        jpa.findByPlaythroughIdAndChapterId(pid, cid).ifPresentOrElse(
+                existing -> {
+                    existing.setStatus(status);
+                    jpa.save(existing);
+                },
+                () -> jpa.save(QuestProgressionJpaEntity.builder()
+                        .playthroughId(pid)
+                        .chapterId(cid)
+                        .status(status)
+                        .build())
+        );
+    }
+
+    @Override
+    public void deleteAllByPlaythroughId(String playthroughId) {
+        jpa.deleteByPlaythroughId(Long.parseLong(playthroughId));
+    }
+
+    private QuestProgression toDomain(QuestProgressionJpaEntity e) {
+        return QuestProgression.builder()
+                .id(e.getId().toString())
+                .playthroughId(e.getPlaythroughId().toString())
+                .chapterId(e.getChapterId().toString())
+                .status(e.getStatus())
+                .build();
+    }
+}

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

@@ -92,6 +92,9 @@ public class PostgresSceneRepository implements SceneRepository {
                 .branches(jpaEntity.getBranches() != null
                         ? new ArrayList<>(jpaEntity.getBranches())
                         : new ArrayList<>())
+                .rooms(jpaEntity.getRooms() != null
+                        ? new ArrayList<>(jpaEntity.getRooms())
+                        : new ArrayList<>())
                 .createdAt(jpaEntity.getCreatedAt())
                 .updatedAt(jpaEntity.getUpdatedAt())
                 .build();
@@ -126,6 +129,9 @@ public class PostgresSceneRepository implements SceneRepository {
                 .branches(scene.getBranches() != null
                         ? new ArrayList<>(scene.getBranches())
                         : new ArrayList<>())
+                .rooms(scene.getRooms() != null
+                        ? new ArrayList<>(scene.getRooms())
+                        : new ArrayList<>())
                 .createdAt(scene.getCreatedAt())
                 .updatedAt(scene.getUpdatedAt())
                 .build();

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

@@ -0,0 +1,85 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.playcontext.SessionEntry;
+import com.loremind.domain.playcontext.ports.SessionEntryRepository;
+import com.loremind.infrastructure.persistence.entity.SessionEntryJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.SessionEntryJpaRepository;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure : implémente le Port SessionEntryRepository.
+ */
+@Repository
+public class PostgresSessionEntryRepository implements SessionEntryRepository {
+
+    private final SessionEntryJpaRepository jpaRepository;
+
+    public PostgresSessionEntryRepository(SessionEntryJpaRepository jpaRepository) {
+        this.jpaRepository = jpaRepository;
+    }
+
+    @Override
+    public SessionEntry save(SessionEntry entry) {
+        SessionEntryJpaEntity saved = jpaRepository.save(toJpaEntity(entry));
+        return toDomain(saved);
+    }
+
+    @Override
+    public Optional<SessionEntry> findById(String id) {
+        return jpaRepository.findById(Long.parseLong(id)).map(this::toDomain);
+    }
+
+    @Override
+    public List<SessionEntry> findBySessionId(String sessionId) {
+        return jpaRepository.findBySessionIdOrderByOccurredAtAsc(sessionId).stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpaRepository.deleteById(Long.parseLong(id));
+    }
+
+    /** {@code @Transactional} requis : Spring Data exige une transaction pour les deleteByXxx dérivés. */
+    @Override
+    @Transactional
+    public void deleteBySessionId(String sessionId) {
+        jpaRepository.deleteBySessionId(sessionId);
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpaRepository.existsById(Long.parseLong(id));
+    }
+
+    private SessionEntry toDomain(SessionEntryJpaEntity jpa) {
+        return SessionEntry.builder()
+                .id(jpa.getId().toString())
+                .sessionId(jpa.getSessionId())
+                .type(jpa.getType())
+                .content(jpa.getContent())
+                .occurredAt(jpa.getOccurredAt())
+                .createdAt(jpa.getCreatedAt())
+                .updatedAt(jpa.getUpdatedAt())
+                .build();
+    }
+
+    private SessionEntryJpaEntity toJpaEntity(SessionEntry entry) {
+        Long id = entry.getId() != null ? Long.parseLong(entry.getId()) : null;
+        return SessionEntryJpaEntity.builder()
+                .id(id)
+                .sessionId(entry.getSessionId())
+                .type(entry.getType())
+                .content(entry.getContent())
+                .occurredAt(entry.getOccurredAt())
+                .createdAt(entry.getCreatedAt())
+                .updatedAt(entry.getUpdatedAt())
+                .build();
+    }
+}

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

@@ -0,0 +1,96 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.playcontext.Session;
+import com.loremind.domain.playcontext.ports.SessionRepository;
+import com.loremind.infrastructure.persistence.entity.SessionJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.SessionJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure : implémente le port SessionRepository en utilisant
+ * playthrough_id comme parent (depuis la refonte Playthrough).
+ */
+@Repository
+public class PostgresSessionRepository implements SessionRepository {
+
+    private final SessionJpaRepository jpaRepository;
+
+    public PostgresSessionRepository(SessionJpaRepository jpaRepository) {
+        this.jpaRepository = jpaRepository;
+    }
+
+    @Override
+    public Session save(Session session) {
+        SessionJpaEntity saved = jpaRepository.save(toJpaEntity(session));
+        return toDomain(saved);
+    }
+
+    @Override
+    public Optional<Session> findById(String id) {
+        return jpaRepository.findById(Long.parseLong(id)).map(this::toDomain);
+    }
+
+    @Override
+    public List<Session> findAll() {
+        return jpaRepository.findAll().stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<Session> findByPlaythroughId(String playthroughId) {
+        return jpaRepository.findByPlaythroughIdOrderByStartedAtDesc(Long.parseLong(playthroughId)).stream()
+                .map(this::toDomain)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Optional<Session> findActive() {
+        return jpaRepository.findFirstByEndedAtIsNull().map(this::toDomain);
+    }
+
+    @Override
+    public Optional<Session> findActiveByPlaythroughId(String playthroughId) {
+        return jpaRepository.findFirstByPlaythroughIdAndEndedAtIsNull(Long.parseLong(playthroughId))
+                .map(this::toDomain);
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpaRepository.deleteById(Long.parseLong(id));
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpaRepository.existsById(Long.parseLong(id));
+    }
+
+    private Session toDomain(SessionJpaEntity jpa) {
+        return Session.builder()
+                .id(jpa.getId().toString())
+                .name(jpa.getName())
+                .playthroughId(jpa.getPlaythroughId() != null ? jpa.getPlaythroughId().toString() : null)
+                .startedAt(jpa.getStartedAt())
+                .endedAt(jpa.getEndedAt())
+                .createdAt(jpa.getCreatedAt())
+                .updatedAt(jpa.getUpdatedAt())
+                .build();
+    }
+
+    private SessionJpaEntity toJpaEntity(Session session) {
+        Long id = session.getId() != null ? Long.parseLong(session.getId()) : null;
+        return SessionJpaEntity.builder()
+                .id(id)
+                .name(session.getName())
+                .playthroughId(session.getPlaythroughId() != null ? Long.parseLong(session.getPlaythroughId()) : null)
+                .startedAt(session.getStartedAt())
+                .endedAt(session.getEndedAt())
+                .createdAt(session.getCreatedAt())
+                .updatedAt(session.getUpdatedAt())
+                .build();
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/GlobalExceptionHandler.java

@@ -0,0 +1,97 @@
+package com.loremind.infrastructure.web;
+
+import jakarta.persistence.EntityNotFoundException;
+import jakarta.servlet.http.HttpServletRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Intercepteur global d'exceptions pour TOUS les @RestController.
+ *
+ * <p>Role :
+ * <ul>
+ *   <li>Logger systematiquement les exceptions non gerees (avec stack trace + path)
+ *       — evite d'avoir a creuser dans les logs Docker apres coup.</li>
+ *   <li>Renvoyer un JSON propre au client (`{error, type, ...}`) au lieu du 500 nu
+ *       par defaut de Spring — utile pour debug cote frontend (visible directement
+ *       dans la DevTools reseau).</li>
+ *   <li>Mapper les exceptions courantes vers des status HTTP appropries
+ *       (IllegalArgumentException -> 400, EntityNotFoundException -> 404).</li>
+ * </ul>
+ *
+ * <p>Important : ne court-circuite PAS les try/catch locaux des controllers
+ * (ex: LicenseController.install catche InstallException -> 400 lui-meme).
+ * Ce handler n'attrape QUE ce qui a echappe au catch local.
+ */
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
+
+    /**
+     * Violation d'invariant domaine (doublons, valeurs invalides, etc.) -> 400.
+     * Concentre ici la logique qui etait dupliquee dans GameSystemController.
+     */
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<Map<String, String>> handleIllegalArgument(IllegalArgumentException ex) {
+        return ResponseEntity.badRequest().body(Map.of("error", safeMessage(ex)));
+    }
+
+    /** Entite JPA introuvable -> 404. */
+    @ExceptionHandler(EntityNotFoundException.class)
+    public ResponseEntity<Map<String, String>> handleNotFound(EntityNotFoundException ex) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("error", safeMessage(ex)));
+    }
+
+    /** JSON malforme dans le body de la requete -> 400. */
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResponseEntity<Map<String, String>> handleUnreadable(HttpMessageNotReadableException ex) {
+        return ResponseEntity.badRequest().body(Map.of("error", "Malformed request body"));
+    }
+
+    /** Validation @Valid echouee -> 400 avec liste des erreurs par champ. */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<Map<String, Object>> handleValidation(MethodArgumentNotValidException ex) {
+        Map<String, String> fields = new LinkedHashMap<>();
+        ex.getBindingResult().getFieldErrors().forEach(e ->
+                fields.put(e.getField(), e.getDefaultMessage() != null ? e.getDefaultMessage() : "invalid"));
+        return ResponseEntity.badRequest().body(Map.of(
+                "error", "Validation failed",
+                "fields", fields
+        ));
+    }
+
+    /**
+     * Fallback : tout ce qui n'a pas ete catche au-dessus -> 500, mais avec
+     * un log ERROR explicite (path + stack trace) et un body JSON debuggable
+     * cote client. C'est LE filet de securite.
+     *
+     * Note : on attrape Throwable (pas Exception) pour aussi capturer les
+     * Error (NoClassDefFoundError, OutOfMemoryError... — cf. incident Tink).
+     * On NE swallow PAS — on log AVANT de renvoyer une reponse.
+     */
+    @ExceptionHandler(Throwable.class)
+    public ResponseEntity<Map<String, String>> handleUnexpected(HttpServletRequest request, Throwable ex) {
+        log.error("Unhandled exception on {} {}", request.getMethod(), request.getRequestURI(), ex);
+        Map<String, String> body = new LinkedHashMap<>();
+        body.put("error", "Internal server error");
+        body.put("type", ex.getClass().getSimpleName());
+        String msg = safeMessage(ex);
+        if (!msg.isEmpty()) body.put("message", msg);
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
+    }
+
+    /** Evite les NPE quand getMessage() est null sur certaines exceptions. */
+    private static String safeMessage(Throwable ex) {
+        return ex.getMessage() != null ? ex.getMessage() : "";
+    }
+}

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

@@ -2,11 +2,13 @@ package com.loremind.infrastructure.web.controller;
 
 import com.loremind.application.generationcontext.StreamChatForCampaignUseCase;
 import com.loremind.application.generationcontext.StreamChatForLoreUseCase;
+import com.loremind.application.generationcontext.StreamChatForSessionUseCase;
 import com.loremind.domain.generationcontext.ChatMessage;
 import com.loremind.domain.generationcontext.ChatUsage;
 import com.loremind.infrastructure.web.dto.generationcontext.ChatMessageDTO;
 import com.loremind.infrastructure.web.dto.generationcontext.ChatStreamCampaignRequestDTO;
 import com.loremind.infrastructure.web.dto.generationcontext.ChatStreamRequestDTO;
+import com.loremind.infrastructure.web.dto.generationcontext.ChatStreamSessionRequestDTO;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.core.task.TaskExecutor;
 import org.springframework.http.MediaType;
@@ -42,14 +44,17 @@ public class AiChatController {
 
     private final StreamChatForLoreUseCase streamChatForLoreUseCase;
     private final StreamChatForCampaignUseCase streamChatForCampaignUseCase;
+    private final StreamChatForSessionUseCase streamChatForSessionUseCase;
     private final TaskExecutor taskExecutor;
 
     public AiChatController(
             StreamChatForLoreUseCase streamChatForLoreUseCase,
             StreamChatForCampaignUseCase streamChatForCampaignUseCase,
+            StreamChatForSessionUseCase streamChatForSessionUseCase,
             @Qualifier("applicationTaskExecutor") TaskExecutor taskExecutor) {
         this.streamChatForLoreUseCase = streamChatForLoreUseCase;
         this.streamChatForCampaignUseCase = streamChatForCampaignUseCase;
+        this.streamChatForSessionUseCase = streamChatForSessionUseCase;
         this.taskExecutor = taskExecutor;
     }
 
@@ -74,6 +79,19 @@ public class AiChatController {
         return emitter;
     }
 
+    /**
+     * Chat IA ancré sur une Session de jeu : récupère automatiquement la
+     * Campagne / Lore / GameSystem associés + injecte le journal horodaté.
+     */
+    @PostMapping(value = "/chat/stream-session", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public SseEmitter chatStreamSession(@RequestBody ChatStreamSessionRequestDTO body) {
+        SseEmitter emitter = new SseEmitter(SSE_TIMEOUT_MS);
+        List<ChatMessage> messages = toDomainMessages(body.getMessages());
+
+        taskExecutor.execute(() -> runSessionStreaming(emitter, body.getSessionId(), messages));
+        return emitter;
+    }
+
     // --- Exécution du streaming dans un thread dédié ------------------------
 
     private void runLoreStreaming(
@@ -111,6 +129,22 @@ public class AiChatController {
         }
     }
 
+    private void runSessionStreaming(
+            SseEmitter emitter,
+            String sessionId,
+            List<ChatMessage> messages) {
+        try {
+            streamChatForSessionUseCase.execute(
+                    sessionId, messages,
+                    usage -> sendUsage(emitter, usage),
+                    token -> sendToken(emitter, token),
+                    () -> complete(emitter),
+                    error -> fail(emitter, error));
+        } catch (Exception e) {
+            fail(emitter, e);
+        }
+    }
+
     // --- Helpers SSE (un seul point d'écriture par type d'événement) --------
 
     private void sendUsage(SseEmitter emitter, ChatUsage usage) {

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

@@ -27,8 +27,8 @@ public class ArcController {
 
     @PostMapping
     public ResponseEntity<ArcDTO> createArc(@RequestBody ArcDTO arcDTO) {
-        Arc arc = arcMapper.toDomain(arcDTO);
-        Arc createdArc = arcService.createArc(arc.getName(), arc.getDescription(), arc.getCampaignId(), arc.getOrder(), arc.getIcon());
+        // Surcharge "Arc complet" pour propager le champ type (LINEAR/HUB) à la création.
+        Arc createdArc = arcService.createArc(arcMapper.toDomain(arcDTO));
         return ResponseEntity.ok(arcMapper.toDTO(createdArc));
     }
 

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

@@ -0,0 +1,30 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.CampaignReferencedFlagsService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * REST Controller des faits d'une Campagne.
+ *
+ * <p>Sémantique « déclaration implicite » : il n'y a pas de table de déclarations
+ * globales. La liste retournée est la déduplication des noms de faits référencés
+ * dans les prérequis des chapitres de la campagne.</p>
+ */
+@RestController
+@RequestMapping("/api/campaigns/{campaignId}/flags")
+public class CampaignFlagController {
+
+    private final CampaignReferencedFlagsService service;
+
+    public CampaignFlagController(CampaignReferencedFlagsService service) {
+        this.service = service;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<String>> list(@PathVariable String campaignId) {
+        return ResponseEntity.ok(service.listForCampaign(campaignId));
+    }
+}

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

@@ -1,6 +1,7 @@
 package com.loremind.infrastructure.web.controller;
 
 import com.loremind.application.campaigncontext.ChapterService;
+import com.loremind.application.campaigncontext.ChapterStatusEnricher;
 import com.loremind.domain.campaigncontext.Chapter;
 import com.loremind.infrastructure.web.dto.campaigncontext.ChapterDTO;
 import com.loremind.infrastructure.web.mapper.ChapterMapper;
@@ -12,6 +13,8 @@ import java.util.stream.Collectors;
 
 /**
  * REST Controller pour le contexte Chapter.
+ * Si {@code ?playthroughId=} est fourni, les DTOs renvoyés sont enrichis de leur
+ * {@code progressionStatus} et {@code effectiveStatus} relatifs à ce Playthrough.
  */
 @RestController
 @RequestMapping("/api/chapters")
@@ -19,42 +22,58 @@ public class ChapterController {
 
     private final ChapterService chapterService;
     private final ChapterMapper chapterMapper;
+    private final ChapterStatusEnricher statusEnricher;
 
-    public ChapterController(ChapterService chapterService, ChapterMapper chapterMapper) {
+    public ChapterController(ChapterService chapterService,
+                             ChapterMapper chapterMapper,
+                             ChapterStatusEnricher statusEnricher) {
         this.chapterService = chapterService;
         this.chapterMapper = chapterMapper;
+        this.statusEnricher = statusEnricher;
     }
 
     @PostMapping
     public ResponseEntity<ChapterDTO> createChapter(@RequestBody ChapterDTO chapterDTO) {
-        Chapter chapter = chapterMapper.toDomain(chapterDTO);
-        Chapter createdChapter = chapterService.createChapter(chapter.getName(), chapter.getDescription(), chapter.getArcId(), chapter.getOrder(), chapter.getIcon());
-        return ResponseEntity.ok(chapterMapper.toDTO(createdChapter));
+        Chapter created = chapterService.createChapter(chapterMapper.toDomain(chapterDTO));
+        return ResponseEntity.ok(chapterMapper.toDTO(created));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<ChapterDTO> getChapterById(@PathVariable String id) {
+    public ResponseEntity<ChapterDTO> getChapterById(
+            @PathVariable String id,
+            @RequestParam(value = "playthroughId", required = false) String playthroughId) {
         return chapterService.getChapterById(id)
-                .map(chapter -> ResponseEntity.ok(chapterMapper.toDTO(chapter)))
+                .map(chapter -> {
+                    ChapterDTO dto = chapterMapper.toDTO(chapter);
+                    if (playthroughId != null && !playthroughId.isBlank()) {
+                        statusEnricher.enrich(List.of(dto), List.of(chapter), playthroughId);
+                    }
+                    return ResponseEntity.ok(dto);
+                })
                 .orElse(ResponseEntity.notFound().build());
     }
 
     @GetMapping
     public ResponseEntity<List<ChapterDTO>> getAllChapters(
-            @RequestParam(value = "arcId", required = false) String arcId) {
+            @RequestParam(value = "arcId", required = false) String arcId,
+            @RequestParam(value = "playthroughId", required = false) String playthroughId) {
         List<Chapter> chapters = (arcId != null && !arcId.isBlank())
                 ? chapterService.getChaptersByArcId(arcId)
                 : chapterService.getAllChapters();
         List<ChapterDTO> chapterDTOs = chapters.stream()
                 .map(chapterMapper::toDTO)
                 .collect(Collectors.toList());
+
+        if (playthroughId != null && !playthroughId.isBlank()) {
+            statusEnricher.enrich(chapterDTOs, chapters, playthroughId);
+        }
         return ResponseEntity.ok(chapterDTOs);
     }
 
     @PutMapping("/{id}")
     public ResponseEntity<ChapterDTO> updateChapter(@PathVariable String id, @RequestBody ChapterDTO chapterDTO) {
-        Chapter updatedChapter = chapterService.updateChapter(id, chapterMapper.toDomain(chapterDTO));
-        return ResponseEntity.ok(chapterMapper.toDTO(updatedChapter));
+        Chapter updated = chapterService.updateChapter(id, chapterMapper.toDomain(chapterDTO));
+        return ResponseEntity.ok(chapterMapper.toDTO(updated));
     }
 
     @DeleteMapping("/{id}")

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

@@ -35,9 +35,9 @@ public class CharacterController {
                 .orElse(ResponseEntity.notFound().build());
     }
 
-    @GetMapping("/campaign/{campaignId}")
-    public ResponseEntity<List<CharacterDTO>> getCharactersByCampaign(@PathVariable String campaignId) {
-        List<CharacterDTO> dtos = characterService.getCharactersByCampaignId(campaignId).stream()
+    @GetMapping("/playthrough/{playthroughId}")
+    public ResponseEntity<List<CharacterDTO>> getCharactersByPlaythrough(@PathVariable String playthroughId) {
+        List<CharacterDTO> dtos = characterService.getCharactersByPlaythroughId(playthroughId).stream()
                 .map(characterMapper::toDTO)
                 .collect(Collectors.toList());
         return ResponseEntity.ok(dtos);
@@ -63,7 +63,7 @@ public class CharacterController {
                 dto.getValues(),
                 dto.getImageValues(),
                 dto.getKeyValueValues(),
-                dto.getCampaignId(),
+                dto.getPlaythroughId(),
                 order
         );
     }

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

@@ -7,7 +7,6 @@ import com.loremind.infrastructure.web.dto.gamesystemcontext.GameSystemDTO;
 import com.loremind.infrastructure.web.dto.shared.TemplateFieldDTO;
 import com.loremind.infrastructure.web.mapper.GameSystemMapper;
 import com.loremind.infrastructure.web.mapper.TemplateFieldMapper;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
@@ -72,12 +71,6 @@ public class GameSystemController {
         return ResponseEntity.noContent().build();
     }
 
-    /** Mappe les violations d'invariants domaine (doublons de champs, etc.) en 400. */
-    @ExceptionHandler(IllegalArgumentException.class)
-    public ResponseEntity<String> onIllegalArgument(IllegalArgumentException ex) {
-        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ex.getMessage());
-    }
-
     private GameSystemService.GameSystemData toData(GameSystemDTO dto) {
         return new GameSystemService.GameSystemData(
                 dto.getName(),

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

@@ -1,12 +1,16 @@
 package com.loremind.infrastructure.web.controller;
 
+import com.loremind.application.licensing.ChannelSwitcherService;
 import com.loremind.application.licensing.LicenseService;
 import com.loremind.application.licensing.LicenseService.InstallException;
 import com.loremind.domain.licensing.LicenseSnapshot;
+import com.loremind.infrastructure.web.dto.licensing.ChannelStatusDTO;
 import com.loremind.infrastructure.web.dto.licensing.LicenseStatusDTO;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.io.IOException;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -26,9 +30,11 @@ import java.util.Map;
 public class LicenseController {
 
     private final LicenseService licenseService;
+    private final ChannelSwitcherService channelSwitcher;
 
-    public LicenseController(LicenseService licenseService) {
+    public LicenseController(LicenseService licenseService, ChannelSwitcherService channelSwitcher) {
         this.licenseService = licenseService;
+        this.channelSwitcher = channelSwitcher;
     }
 
     @GetMapping
@@ -82,6 +88,68 @@ public class LicenseController {
         }
     }
 
+    // ─── Bascule de canal (stable <-> beta) via sidecar switcher ────────────
+    //
+    // Le flux :
+    //  1. UI POST /api/license/channel/switch { channel: "beta" }
+    //  2. Core valide la licence (refus si target=beta sans Patreon actif)
+    //  3. Core depose une commande dans le volume partage
+    //  4. Sidecar `switcher` la traite (sed .env, docker compose up -d)
+    //  5. UI poll GET /api/license/channel pour suivre le status
+
+    /** Etat courant : canal actuel + dispo du sidecar + dernier resultat. */
+    @GetMapping("/channel")
+    public ChannelStatusDTO getChannel() {
+        return ChannelStatusDTO.from(channelSwitcher);
+    }
+
+    /** Declenche un switch de canal. Renvoie l'ID de la commande pour le polling. */
+    @PostMapping("/channel/switch")
+    public ResponseEntity<?> switchChannel(@RequestBody ChannelSwitchRequest request) {
+        if (request == null || request.channel() == null) {
+            return ResponseEntity.badRequest().body(Map.of("error", "missing channel"));
+        }
+
+        ChannelSwitcherService.Channel target;
+        try {
+            target = ChannelSwitcherService.Channel.valueOf(request.channel().toUpperCase(Locale.ROOT));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.badRequest().body(Map.of(
+                    "error", "invalid channel (allowed: stable, beta)"));
+        }
+
+        // Garde : pas de switch vers beta sans licence Patreon valide.
+        // Le switcher ferait le boulot quoi qu'il arrive (il valide juste le
+        // format), donc c'est ici qu'on doit refuser cote metier.
+        // VALID + GRACE autorisent l'acces beta (cf. javadoc de LicenseStatus).
+        if (target == ChannelSwitcherService.Channel.BETA) {
+            LicenseSnapshot snap = licenseService.getCurrentSnapshot();
+            com.loremind.domain.licensing.LicenseStatus s = (snap != null) ? snap.status() : null;
+            boolean allowed = s == com.loremind.domain.licensing.LicenseStatus.VALID
+                           || s == com.loremind.domain.licensing.LicenseStatus.GRACE;
+            if (!allowed) {
+                return ResponseEntity.status(403).body(Map.of(
+                        "error", "Aucune licence Patreon active — impossible de basculer sur le canal beta."));
+            }
+        }
+
+        if (!channelSwitcher.isSwitcherAvailable()) {
+            return ResponseEntity.status(503).body(Map.of(
+                    "error", "Sidecar switcher non disponible (mise a jour requise du docker-compose.yml)."));
+        }
+
+        try {
+            String id = channelSwitcher.requestSwitch(target);
+            return ResponseEntity.accepted().body(Map.of(
+                    "id", id,
+                    "channel", target.name().toLowerCase(Locale.ROOT)));
+        } catch (IOException e) {
+            return ResponseEntity.status(500).body(Map.of(
+                    "error", "Impossible d'ecrire la commande de switch: " + e.getMessage()));
+        }
+    }
+
     public record InstallRequest(String jwt) {}
     public record BetaChannelRequest(boolean enabled) {}
+    public record ChannelSwitchRequest(String channel) {}
 }

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

@@ -0,0 +1,64 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.playcontext.PlaythroughService;
+import com.loremind.domain.playcontext.Playthrough;
+import com.loremind.infrastructure.web.dto.playcontext.PlaythroughDTO;
+import com.loremind.infrastructure.web.mapper.PlaythroughMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api/playthroughs")
+public class PlaythroughController {
+
+    private final PlaythroughService service;
+    private final PlaythroughMapper mapper;
+
+    public PlaythroughController(PlaythroughService service, PlaythroughMapper mapper) {
+        this.service = service;
+        this.mapper = mapper;
+    }
+
+    @PostMapping
+    public ResponseEntity<PlaythroughDTO> create(@RequestBody PlaythroughDTO body) {
+        Playthrough created = service.create(body.getCampaignId(), body.getName(), body.getDescription());
+        return ResponseEntity.ok(mapper.toDTO(created));
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<PlaythroughDTO> getById(@PathVariable String id) {
+        return service.getById(id)
+                .map(p -> ResponseEntity.ok(mapper.toDTO(p)))
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @GetMapping
+    public ResponseEntity<List<PlaythroughDTO>> list(
+            @RequestParam(value = "campaignId", required = false) String campaignId) {
+        List<Playthrough> list = (campaignId != null && !campaignId.isBlank())
+                ? service.getByCampaignId(campaignId)
+                : List.of();
+        return ResponseEntity.ok(list.stream().map(mapper::toDTO).collect(Collectors.toList()));
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<PlaythroughDTO> update(@PathVariable String id, @RequestBody PlaythroughDTO body) {
+        Playthrough updated = service.update(id, mapper.toDomain(body));
+        return ResponseEntity.ok(mapper.toDTO(updated));
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable String id) {
+        service.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @GetMapping("/{id}/deletion-impact")
+    public ResponseEntity<PlaythroughService.DeletionImpact> deletionImpact(@PathVariable String id) {
+        if (!service.exists(id)) return ResponseEntity.notFound().build();
+        return ResponseEntity.ok(service.getDeletionImpact(id));
+    }
+}

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

@@ -0,0 +1,47 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.domain.playcontext.ports.PlaythroughFlagRepository;
+import com.loremind.infrastructure.web.dto.playcontext.PlaythroughFlagDTO;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Endpoint des flags narratifs d'une Partie.
+ * Remplace l'ancien {@code /api/campaigns/{id}/flags} : les flags suivent la Partie.
+ */
+@RestController
+@RequestMapping("/api/playthroughs/{playthroughId}/flags")
+public class PlaythroughFlagController {
+
+    private final PlaythroughFlagRepository repo;
+
+    public PlaythroughFlagController(PlaythroughFlagRepository repo) {
+        this.repo = repo;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<PlaythroughFlagDTO>> list(@PathVariable String playthroughId) {
+        Map<String, Boolean> flags = repo.findByPlaythroughId(playthroughId);
+        List<PlaythroughFlagDTO> dtos = new ArrayList<>(flags.size());
+        flags.forEach((name, value) -> dtos.add(new PlaythroughFlagDTO(name, value)));
+        return ResponseEntity.ok(dtos);
+    }
+
+    @PutMapping("/{name}")
+    public ResponseEntity<PlaythroughFlagDTO> setFlag(@PathVariable String playthroughId,
+                                                     @PathVariable String name,
+                                                     @RequestBody PlaythroughFlagDTO body) {
+        repo.setFlag(playthroughId, name, body.isValue());
+        return ResponseEntity.ok(new PlaythroughFlagDTO(name, body.isValue()));
+    }
+
+    @DeleteMapping("/{name}")
+    public ResponseEntity<Void> deleteFlag(@PathVariable String playthroughId, @PathVariable String name) {
+        repo.deleteFlag(playthroughId, name);
+        return ResponseEntity.noContent().build();
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.domain.campaigncontext.ProgressionStatus;
+import com.loremind.domain.playcontext.ports.QuestProgressionRepository;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Endpoint pour piloter la progression d'une quête (Chapter) au sein d'un Playthrough.
+ *
+ * <p>Modèle "absence = NOT_STARTED" — envoyer NOT_STARTED supprime la ligne.</p>
+ */
+@RestController
+@RequestMapping("/api/playthroughs/{playthroughId}/quest-progressions")
+public class QuestProgressionController {
+
+    private final QuestProgressionRepository repo;
+
+    public QuestProgressionController(QuestProgressionRepository repo) {
+        this.repo = repo;
+    }
+
+    public record SetStatusRequest(String status) {}
+
+    /**
+     * GET : renvoie une map chapterId -> ProgressionStatus pour le Playthrough.
+     * Pratique pour le front qui peut indexer puissamment.
+     */
+    @GetMapping
+    public ResponseEntity<Map<String, String>> list(@PathVariable String playthroughId) {
+        Map<String, String> out = new HashMap<>();
+        repo.findByPlaythroughId(playthroughId)
+                .forEach(qp -> out.put(qp.getChapterId(), qp.getStatus().name()));
+        return ResponseEntity.ok(out);
+    }
+
+    @PutMapping("/{chapterId}")
+    public ResponseEntity<Void> setStatus(@PathVariable String playthroughId,
+                                          @PathVariable String chapterId,
+                                          @RequestBody SetStatusRequest body) {
+        ProgressionStatus parsed = ProgressionStatus.NOT_STARTED;
+        if (body.status() != null && !body.status().isBlank()) {
+            try {
+                parsed = ProgressionStatus.valueOf(body.status());
+            } catch (IllegalArgumentException ex) {
+                return ResponseEntity.badRequest().build();
+            }
+        }
+        repo.setStatus(playthroughId, chapterId, parsed);
+        return ResponseEntity.noContent().build();
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.playcontext.SessionService;
+import com.loremind.domain.playcontext.Session;
+import com.loremind.infrastructure.web.dto.playcontext.SessionDTO;
+import com.loremind.infrastructure.web.mapper.SessionMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le Play Context.
+ * Adaptateur d'infrastructure qui expose l'API REST des Sessions.
+ */
+@RestController
+@RequestMapping("/api/sessions")
+public class SessionController {
+
+    private final SessionService sessionService;
+    private final SessionMapper sessionMapper;
+
+    public SessionController(SessionService sessionService, SessionMapper sessionMapper) {
+        this.sessionService = sessionService;
+        this.sessionMapper = sessionMapper;
+    }
+
+    public record StartSessionRequest(String playthroughId) {}
+
+    public record RenameSessionRequest(String name) {}
+
+    @PostMapping
+    public ResponseEntity<SessionDTO> startSession(@RequestBody StartSessionRequest request) {
+        Session session = sessionService.startSession(request.playthroughId());
+        return ResponseEntity.ok(sessionMapper.toDTO(session));
+    }
+
+    @GetMapping("/active")
+    public ResponseEntity<SessionDTO> getActiveSession(
+            @RequestParam(value = "playthroughId", required = false) String playthroughId) {
+        var maybe = (playthroughId == null || playthroughId.isBlank())
+                ? sessionService.getActive()
+                : sessionService.getActiveByPlaythrough(playthroughId);
+        return maybe
+                .map(s -> ResponseEntity.ok(sessionMapper.toDTO(s)))
+                .orElse(ResponseEntity.noContent().build());
+    }
+
+    @GetMapping
+    public ResponseEntity<List<SessionDTO>> getSessions(@RequestParam(value = "playthroughId", required = false) String playthroughId) {
+        List<Session> sessions = (playthroughId == null || playthroughId.isBlank())
+                ? sessionService.getAll()
+                : sessionService.getByPlaythroughId(playthroughId);
+        List<SessionDTO> dtos = sessions.stream()
+                .map(sessionMapper::toDTO)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(dtos);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<SessionDTO> getSessionById(@PathVariable String id) {
+        return sessionService.getById(id)
+                .map(s -> ResponseEntity.ok(sessionMapper.toDTO(s)))
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping("/{id}/end")
+    public ResponseEntity<SessionDTO> endSession(@PathVariable String id) {
+        Session ended = sessionService.endSession(id);
+        return ResponseEntity.ok(sessionMapper.toDTO(ended));
+    }
+
+    @PatchMapping("/{id}")
+    public ResponseEntity<SessionDTO> renameSession(@PathVariable String id,
+                                                    @RequestBody RenameSessionRequest request) {
+        Session renamed = sessionService.renameSession(id, request.name());
+        return ResponseEntity.ok(sessionMapper.toDTO(renamed));
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteSession(@PathVariable String id) {
+        sessionService.deleteSession(id);
+        return ResponseEntity.noContent().build();
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.playcontext.SessionEntryService;
+import com.loremind.domain.playcontext.EntryType;
+import com.loremind.domain.playcontext.SessionEntry;
+import com.loremind.infrastructure.web.dto.playcontext.SessionEntryDTO;
+import com.loremind.infrastructure.web.mapper.SessionEntryMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour les entrées de journal d'une Session.
+ * Endpoints imbriqués sous /api/sessions/{sessionId}/entries.
+ */
+@RestController
+@RequestMapping("/api/sessions/{sessionId}/entries")
+public class SessionEntryController {
+
+    private final SessionEntryService entryService;
+    private final SessionEntryMapper entryMapper;
+
+    public SessionEntryController(SessionEntryService entryService, SessionEntryMapper entryMapper) {
+        this.entryService = entryService;
+        this.entryMapper = entryMapper;
+    }
+
+    public record EntryRequest(EntryType type, String content, LocalDateTime occurredAt) {}
+
+    @GetMapping
+    public ResponseEntity<List<SessionEntryDTO>> getEntries(@PathVariable String sessionId) {
+        List<SessionEntryDTO> dtos = entryService.getBySessionId(sessionId).stream()
+                .map(entryMapper::toDTO)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(dtos);
+    }
+
+    @PostMapping
+    public ResponseEntity<SessionEntryDTO> createEntry(@PathVariable String sessionId,
+                                                       @RequestBody EntryRequest request) {
+        SessionEntry created = entryService.createEntry(
+                sessionId,
+                new SessionEntryService.EntryData(request.type(), request.content(), request.occurredAt())
+        );
+        return ResponseEntity.ok(entryMapper.toDTO(created));
+    }
+
+    @PutMapping("/{entryId}")
+    public ResponseEntity<SessionEntryDTO> updateEntry(@PathVariable String sessionId,
+                                                       @PathVariable String entryId,
+                                                       @RequestBody EntryRequest request) {
+        SessionEntry updated = entryService.updateEntry(
+                entryId,
+                new SessionEntryService.EntryData(request.type(), request.content(), request.occurredAt())
+        );
+        return ResponseEntity.ok(entryMapper.toDTO(updated));
+    }
+
+    @DeleteMapping("/{entryId}")
+    public ResponseEntity<Void> deleteEntry(@PathVariable String sessionId,
+                                            @PathVariable String entryId) {
+        entryService.deleteEntry(entryId);
+        return ResponseEntity.noContent().build();
+    }
+}

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

@@ -17,6 +17,9 @@ public class ArcDTO {
     private String campaignId;
     private int order;
 
+    /** Type structurel : "LINEAR" (défaut) | "HUB". Sérialisé comme String pour faciliter le front. */
+    private String type;
+
     /** Cle d'icone (cf. CAMPAIGN_ICON_OPTIONS cote front). */
     private String icon;
 

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

@@ -17,6 +17,22 @@ public class ChapterDTO {
     private String arcId;
     private int order;
 
+    /** Conditions de déblocage (ET logique). Donnée de SCÉNARIO. */
+    private List<PrerequisiteDTO> prerequisites = new ArrayList<>();
+
+    /**
+     * Statut de progression — lecture seule, populé uniquement quand le client demande
+     * l'enrichissement pour un Playthrough donné (param ?playthroughId=).
+     * Valeurs : "NOT_STARTED" | "IN_PROGRESS" | "COMPLETED".
+     */
+    private String progressionStatus;
+
+    /**
+     * Statut effectif calculé côté backend ("LOCKED" | "AVAILABLE" | "IN_PROGRESS" | "COMPLETED").
+     * Read-only — populé en même temps que {@code progressionStatus}.
+     */
+    private String effectiveStatus;
+
     /** Cle d'icone (cf. CAMPAIGN_ICON_OPTIONS cote front). */
     private String icon;
 

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

@@ -22,6 +22,6 @@ public class CharacterDTO {
     private Map<String, String> values = new HashMap<>();
     private Map<String, List<String>> imageValues = new HashMap<>();
     private Map<String, Map<String, String>> keyValueValues = new HashMap<>();
-    private String campaignId;
+    private String playthroughId;
     private int order;
 }

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

@@ -0,0 +1,30 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * DTO unique pour tous les types de Prerequisite.
+ * Le champ {@code kind} discrimine le type (miroir du converter JPA et de l'union TS côté front).
+ * Les champs non pertinents pour un kind donné restent null.
+ * <p>
+ * Valeurs de {@code kind} : "QUEST_COMPLETED" | "SESSION_REACHED" | "FLAG_SET".
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class PrerequisiteDTO {
+
+    /** Discriminant : QUEST_COMPLETED | SESSION_REACHED | FLAG_SET. */
+    private String kind;
+
+    /** Pour kind=QUEST_COMPLETED : ID de la quête à terminer. */
+    private String questId;
+
+    /** Pour kind=SESSION_REACHED : numéro de session minimum atteint. */
+    private Integer minSessionNumber;
+
+    /** Pour kind=FLAG_SET : nom du flag de campagne. */
+    private String flagName;
+}

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

@@ -0,0 +1,18 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Sortie d'une pièce vers une autre pièce d'un lieu explorable.
+ * Pendant web du record domaine RoomBranch.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RoomBranchDTO {
+    private String label;
+    private String targetRoomId;
+    private String condition;
+}

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

@@ -0,0 +1,28 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * DTO d'une pièce d'un lieu explorable.
+ */
+@Data
+public class RoomDTO {
+
+    /** UUID stable généré côté front à la création. */
+    private String id;
+    private String name;
+    private String description;
+    private String enemies;
+    private String loot;
+    private String traps;
+    private String gmNotes;
+    /** Étage (0 = RdC, 1 = 1er…). Nullable = pas d'étage défini. */
+    private Integer floor;
+    private int order;
+    private List<String> illustrationImageIds = new ArrayList<>();
+    private String mapImageId;
+    private List<RoomBranchDTO> branches = new ArrayList<>();
+}

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

@@ -41,4 +41,7 @@ public class SceneDTO {
 
     /** Branches narratives : sorties possibles vers d'autres scènes du même chapitre. */
     private List<SceneBranchDTO> branches = new ArrayList<>();
+
+    /** Pièces du lieu explorable (donjon, crypte…). Vide = scène classique. */
+    private List<RoomDTO> rooms = new ArrayList<>();
 }

core/src/main/java/com/loremind/infrastructure/web/dto/generationcontext/ChatStreamSessionRequestDTO.java

@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.web.dto.generationcontext;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * DTO de requête pour le chat IA d'une Session de jeu.
+ * Le contexte (lore, campagne, gamesystem, journal) est dérivé du sessionId
+ * côté serveur — l'appelant n'a qu'à fournir l'id et les messages.
+ */
+@Data
+public class ChatStreamSessionRequestDTO {
+    private String sessionId;
+    private List<ChatMessageDTO> messages;
+}

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

@@ -0,0 +1,30 @@
+package com.loremind.infrastructure.web.dto.licensing;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.loremind.application.licensing.ChannelSwitcherService;
+
+/**
+ * Etat du canal courant + dernier resultat de switch.
+ *
+ * <p>{@code currentChannel} : detecte au demarrage de Core a partir du prefixe
+ * d'image. {@code switcherAvailable} : indique si le sidecar de switch est
+ * monte (V0.9+) ou si on est sur une vieille install qui doit encore passer
+ * par les instructions manuelles.
+ *
+ * <p>{@code lastSwitch} : null tant qu'aucun switch n'a ete tente sur cette
+ * instance. Sinon, contient le resultat du dernier appel (en cours / succes /
+ * erreur), utilise par l'UI pour suivre la progression apres clic.
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public record ChannelStatusDTO(
+        String currentChannel,
+        boolean switcherAvailable,
+        ChannelSwitcherService.SwitchResult lastSwitch) {
+
+    public static ChannelStatusDTO from(ChannelSwitcherService service) {
+        return new ChannelStatusDTO(
+                service.getCurrentChannel().name().toLowerCase(),
+                service.isSwitcherAvailable(),
+                service.getLastResult());
+    }
+}

core/src/main/java/com/loremind/infrastructure/web/dto/playcontext/PlaythroughDTO.java

@@ -0,0 +1,19 @@
+package com.loremind.infrastructure.web.dto.playcontext;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * DTO d'un Playthrough (Partie) — instance jouée d'une Campagne.
+ */
+@Data
+public class PlaythroughDTO {
+
+    private String id;
+    private String campaignId;
+    private String name;
+    private String description;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

core/src/main/java/com/loremind/infrastructure/web/dto/playcontext/PlaythroughFlagDTO.java

@@ -0,0 +1,13 @@
+package com.loremind.infrastructure.web.dto.playcontext;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class PlaythroughFlagDTO {
+    private String name;
+    private boolean value;
+}

core/src/main/java/com/loremind/infrastructure/web/dto/playcontext/SessionDTO.java

@@ -0,0 +1,22 @@
+package com.loremind.infrastructure.web.dto.playcontext;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * DTO pour l'entité Session — objet de transfert de l'API REST.
+ */
+@Data
+public class SessionDTO {
+
+    private String id;
+    private String name;
+    private String playthroughId;
+    private LocalDateTime startedAt;
+    /** Null = session en cours. */
+    private LocalDateTime endedAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+    private boolean active;
+}

core/src/main/java/com/loremind/infrastructure/web/dto/playcontext/SessionEntryDTO.java

@@ -0,0 +1,21 @@
+package com.loremind.infrastructure.web.dto.playcontext;
+
+import com.loremind.domain.playcontext.EntryType;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * DTO d'une entrée de journal de session.
+ */
+@Data
+public class SessionEntryDTO {
+
+    private String id;
+    private String sessionId;
+    private EntryType type;
+    private String content;
+    private LocalDateTime occurredAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}