Add per-game adventure text with RAG-based retrieval

Players can now paste the full text of a freely available adventure
when creating a game, and the DM will follow it instead of inventing
its own plot/NPCs/locations. Reuses the existing rulebook RAG
pipeline (chunking, local embedding) rather than injecting the raw
text into every turn, since real adventure modules range from a few
pages to hundreds — far beyond what fits in a prompt.

- New adventure_chunks table (game-scoped, unlike the global
  rulebook_chunks) + Game.adventure_text storing the raw source.
- ingest_adventure_text() chunks/embeds synchronously during
  POST /api/games when adventure_text is non-empty.
- build_adventure_rag_block() retrieves by similarity to the latest
  player message, scoped to game_id — plus always includes chunk 0
  (the adventure's opening) regardless of the query, since early
  Session-0 messages rarely resemble the adventure's actual hook and
  pure similarity search could miss the beginning entirely.
- System prompt instructs the DM to follow provided adventure
  excerpts strictly, deviating only when players clearly go off-script.
- Frontend: optional adventure-text field in the game creation form,
  a has_adventure flag surfaced as a small badge on the game card and
  session header.

Verified with an isolated two-game test that chunks/retrieval never
leak across games (the critical failure mode here), and live against
x.ai: a custom-written one-shot's specific NPCs, location, and hook
appeared verbatim in the DM's opening scene instead of invented ones.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

backend/app/rag/adventure_ingestion.py

@@ -0,0 +1,40 @@
+import asyncio
+import uuid
+
+from sqlalchemy import delete
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.adventure_chunk import AdventureChunk
+from app.rag.chunking import chunk_text
+from app.rag.embeddings import embed_texts
+
+EMBED_BATCH_SIZE = 32
+
+
+async def ingest_adventure_text(session: AsyncSession, game_id: uuid.UUID, text: str) -> int:
+    """Chunks and embeds a player-supplied adventure text, scoped to one game. Safe to call
+    again for the same game (e.g. future re-ingest) — previous chunks are cleared first."""
+    await session.execute(delete(AdventureChunk).where(AdventureChunk.game_id == game_id))
+
+    chunks = chunk_text(text)
+    if not chunks:
+        await session.commit()
+        return 0
+
+    for batch_start in range(0, len(chunks), EMBED_BATCH_SIZE):
+        batch = chunks[batch_start : batch_start + EMBED_BATCH_SIZE]
+        # embed_texts is a synchronous, CPU-bound sentence-transformers call — run it off the
+        # event loop so a large adventure doesn't stall other concurrent requests/WS connections.
+        embeddings = await asyncio.to_thread(embed_texts, batch)
+        for i, (content, embedding) in enumerate(zip(batch, embeddings)):
+            session.add(
+                AdventureChunk(
+                    game_id=game_id,
+                    chunk_index=batch_start + i,
+                    content=content,
+                    embedding=embedding,
+                )
+            )
+        await session.commit()
+
+    return len(chunks)