Ajout d'un mode "jeu" (possibilité de lancer des sessions dans une campagne). Cela permet de faire de prendre des notes en live au cours d'une partie et d'avoir plusieurs outils sous la main pour aider le mj :

- Possibilité de parler à une IA pour règle de jeu ou élément de lore / campagne au cours d'une partie comme aide mémoire
- Onglet dédié aux personnages de la campagne
- Onglet dédié aux scènes
- Onglet avec dès pour ceux qui souhaitent ;

Possibilité de rajouté une note en tant qu'évènement, jet de dès ou encore action du joueur par exemple. D'autres ajouts seront fait dans le futur (notamment des tables aléatoires pour PNJ en live).

brain/app/application/chat.py

@@ -27,6 +27,7 @@ from app.domain.models import (
     NarrativeEntityContext,
     PageContext,
     PageSummary,
+    SessionContext,
 )
 from app.domain.ports import LLMChatProvider
 
@@ -67,6 +68,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 +78,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 +94,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 +112,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 +125,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 ---------------------------------------------------------
@@ -342,6 +348,53 @@ 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.
+
+        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.
+        """
+        status = "EN COURS" if sc.active else "TERMINÉE"
+        started = f" — démarrée {sc.started_at}" if sc.started_at else ""
+
+        if not sc.entries:
+            entries_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 ""
+                # Indentation sur les contenus multi-lignes pour préserver la lisibilité
+                content = e.content.replace("\n", "\n    ")
+                lines.append(f"- {label}{ts} : {content}")
+            entries_block = "\n".join(lines)
+
+        return (
+            "--- SESSION DE JEU EN COURS ---\n"
+            f"Nom : {sc.session_name}\n"
+            f"Statut : {status}{started}\n\n"
+            "Journal chronologique (du plus ancien au plus récent) :\n"
+            f"{entries_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 dans le journal ci-dessus.\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_narrative_entity(ne: NarrativeEntityContext) -> str:
         """Bloc équivalent à _format_page mais pour Arc/Chapter/Scene."""

brain/app/domain/models.py

@@ -229,3 +229,30 @@ 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 : type + contenu + horodatage."""
+
+    type: str
+    content: str
+    occurred_at: str | None
+
+
+@dataclass(frozen=True)
+class SessionContext:
+    """Contexte d'une Session de jeu en cours (Play Context).
+
+    Injecté dans le system prompt pendant qu'une partie est jouée pour que
+    l'IA voit le nom de la session, son statut, et un historique chronologique
+    des évènements/notes/jets capturés par le MJ.
+
+    Le journal a déjà été tronqué côté Core (cap à ~80 entrées récentes)
+    pour ne pas saturer le contexte LLM sur les sessions très longues.
+    """
+
+    session_name: str
+    active: bool
+    started_at: str | None
+    entries: list[JournalEntrySummary]

brain/app/main.py

@@ -26,6 +26,7 @@ from app.domain.models import (
     NpcSummary,
     ChatMessage,
     GameSystemContext,
+    JournalEntrySummary,
     LoreStructuralContext,
     NarrativeEntityContext,
     PageContext,
@@ -33,6 +34,7 @@ from app.domain.models import (
     PageSummary,
     SceneBranchHint,
     SceneSummary,
+    SessionContext,
 )
 from app.domain.ports import LLMProvider, LLMProviderError
 from app.infrastructure.ollama_adapter import OllamaLLMProvider
@@ -41,7 +43,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.7-beta",
+    version="0.9.0-beta",
 )
 
 
@@ -243,13 +245,34 @@ class GameSystemContextDTO(BaseModel):
     sections: dict[str, str] = Field(default_factory=dict)
 
 
+class JournalEntrySummaryDTO(BaseModel):
+    """Une entrée du journal de session — type + contenu + horodatage."""
+
+    type: str
+    content: str
+    occurred_at: str | None = None
+
+
+class SessionContextDTO(BaseModel):
+    """Contexte d'une Session de jeu en cours (Play Context).
+
+    Injecté par le Core quand le chat est ancré sur une Session.
+    Contient le journal chronologique (déjà plafonné côté Core).
+    """
+
+    session_name: str
+    active: bool
+    started_at: str | None = None
+    entries: list[JournalEntrySummaryDTO] = 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 +281,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 +413,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 +426,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 +451,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"
@@ -867,3 +898,22 @@ 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
+    entries = [
+        JournalEntrySummary(
+            type=e.type,
+            content=e.content,
+            occurred_at=e.occurred_at,
+        )
+        for e in dto.entries
+    ]
+    return SessionContext(
+        session_name=dto.session_name,
+        active=dto.active,
+        started_at=dto.started_at,
+        entries=entries,
+    )