Phase 1: Improve session generation continuity

Enhanced auto-generate next session with:
✨ Increase context from 3 to 5 previous sessions
✨ Extract continuity points (NPCs, hooks, locations, decisions)
✨ Add mandatory continuity requirements to AI prompt
✨ Enhanced prompt with core principles and checklist
✨ Emphasize cause-and-effect and player agency
✨ NPC memory and consequences tracking

Improvements:
- NPCs are automatically detected and tracked
- Unresolved hooks are identified and required to address
- Player decisions must have consequences
- Tone and pacing consistency emphasized
- Callbacks to earlier sessions enforced

Result: Sessions feel like natural progression instead of disconnected episodes

src/agents/campaign_agent.py

@@ -731,12 +731,14 @@ Format:
         current_session_num = len(session_events) + 1
         last_session = session_events[-1] if session_events else None
 
-        # Get session notes from previous sessions (last 2-3 sessions for context)
+        # Get session notes from previous sessions (last 5 sessions for better context)
         all_session_notes = self.get_session_notes(campaign_id)
-        recent_notes = all_session_notes[:3] if all_session_notes else []
+        recent_notes = all_session_notes[:5] if all_session_notes else []
 
         # Build session notes context
         notes_context = ""
+        continuity_requirements = []
+
         if recent_notes:
             notes_context = "\n**PREVIOUS SESSION NOTES:**\n\n"
             for note in reversed(recent_notes):  # Chronological order
@@ -747,6 +749,11 @@ Format:
                     truncated_notes += "\n... (notes truncated)"
                 notes_context += f"{truncated_notes}\n\n"
 
+            # Extract continuity requirements from most recent session
+            if recent_notes:
+                last_note = recent_notes[0]  # Most recent
+                continuity_requirements = self._extract_continuity_points(last_note.notes)
+
         # Build last session context
         if not notes_context:
             if last_session:
@@ -756,37 +763,52 @@ Format:
         else:
             last_session_info = notes_context
 
-        # Build context for AI
-        prompt = f"""You are an expert Dungeon Master planning the next D&D 5e session.
-
-**Campaign:** {campaign.name}
-**Theme:** {campaign.theme}
-**Setting:** {campaign.setting}
-**Current Arc:** {campaign.current_arc}
-**Party Size:** {campaign.party_size}
-**Session Number:** {current_session_num}
+        # Build continuity section
+        continuity_section = ""
+        if continuity_requirements:
+            continuity_section = "\n**🎯 CONTINUITY REQUIREMENTS (You MUST address these):**\n"
+            for i, req in enumerate(continuity_requirements, 1):
+                continuity_section += f"{i}. {req}\n"
+            continuity_section += "\n**MANDATORY:** Reference AT LEAST 2-3 of the above elements in Session {current_session_num}.\n"
 
-**Main Conflict:** {campaign.main_conflict}
-
-**Key Factions:** {', '.join(campaign.key_factions) if campaign.key_factions else 'None yet'}
+        # Build context for AI
+        prompt = f"""You are an expert Dungeon Master planning Session {current_session_num} of "{campaign.name}".
 
-**Major Villains:** {', '.join(campaign.major_villains) if campaign.major_villains else 'None yet'}
+**CAMPAIGN OVERVIEW:**
+• **Theme:** {campaign.theme}
+• **Setting:** {campaign.setting}
+• **Current Story Arc:** {campaign.current_arc}
+• **Party Size:** {campaign.party_size} adventurers
+• **Main Conflict:** {campaign.main_conflict}
+• **Key Factions:** {', '.join(campaign.key_factions) if campaign.key_factions else 'None established yet'}
+• **Major Villains:** {', '.join(campaign.major_villains) if campaign.major_villains else 'None revealed yet'}
 
 {last_session_info}
 
-**Campaign Notes:**
+**Campaign DM Notes:**
 {campaign.notes[:1000] if campaign.notes else 'No additional notes'}
 
+{continuity_section}
+
 ---
 
-Based on what happened in the previous sessions (see session notes above), generate a complete
-session plan for Session {current_session_num} that:
+**YOUR MISSION:** Create Session {current_session_num} that feels like a natural, organic continuation of the story.
 
-1. Builds on player choices and consequences documented in previous session notes
-2. Follows up on narrative threads mentioned in the notes
-3. Responds to how players engaged with NPCs and locations
-4. Incorporates improvised content that worked well
-5. Addresses unresolved plot hooks from the notes
+**CORE PRINCIPLES:**
+1. **Cause and Effect:** Player choices from previous sessions MUST have visible consequences
+2. **NPC Memory:** NPCs remember what players did - allies help, enemies retaliate, neutrals react
+3. **Narrative Threads:** Pick up unresolved hooks from previous sessions - don't let them disappear
+4. **Callbacks:** Reference earlier events to show the campaign has continuity and memory
+5. **Player Agency:** Respond to HOW players solved problems, not just THAT they solved them
+6. **Tone Consistency:** Match the established campaign tone - don't suddenly shift genre
+7. **Escalation:** Stakes should feel appropriate to campaign progression
+
+**SESSION DESIGN CHECKLIST:**
+✓ Does this session respond to player choices from last time?
+✓ Have I included at least one recurring NPC?
+✓ Do consequences feel earned and logical?
+✓ Will players recognize this flows from their actions?
+✓ Have I advanced an active plot thread?
 
 Include:
 
@@ -830,6 +852,61 @@ CLIFFHANGER: [cliffhanger sentence]
 
         return session_data
 
+    def _extract_continuity_points(self, session_notes: str) -> list[str]:
+        """
+        Extract key continuity points from session notes that should be
+        referenced in the next session.
+
+        Returns:
+            List of continuity requirements
+        """
+        continuity = []
+
+        # Extract NPCs mentioned (simple pattern matching)
+        import re
+
+        # Look for proper nouns (capitalized words that appear multiple times)
+        words = session_notes.split()
+        capitalized = [w.strip('.,!?:;') for w in words if w and w[0].isupper() and len(w) > 2]
+        npc_candidates = [w for w in capitalized if capitalized.count(w) >= 2]
+        if npc_candidates:
+            unique_npcs = list(set(npc_candidates))[:5]  # Top 5
+            continuity.append(f"NPCs to remember: {', '.join(unique_npcs)}")
+
+        # Look for unresolved elements (keywords indicating future hooks)
+        unresolved_keywords = ['next time', 'later', 'tomorrow', 'unfinished', 'interrupted',
+                              'escaped', 'fled', 'promised', 'agreed to', 'will return',
+                              'warned', 'threatened', 'mysterious']
+        unresolved_sentences = []
+        for sentence in session_notes.split('.'):
+            if any(keyword in sentence.lower() for keyword in unresolved_keywords):
+                unresolved_sentences.append(sentence.strip())
+
+        if unresolved_sentences:
+            continuity.append(f"Unresolved hooks: {' | '.join(unresolved_sentences[:3])}")
+
+        # Look for locations mentioned
+        location_keywords = ['traveled to', 'arrived at', 'went to', 'heading to', 'in the', 'at the']
+        locations = []
+        for sentence in session_notes.split('.'):
+            for keyword in location_keywords:
+                if keyword in sentence.lower():
+                    locations.append(sentence.strip())
+                    break
+        if locations:
+            continuity.append(f"Recent locations: {' | '.join(locations[:3])}")
+
+        # Look for player decisions or consequences
+        decision_keywords = ['decided to', 'chose to', 'agreed to', 'refused to', 'killed', 'saved', 'helped']
+        decisions = []
+        for sentence in session_notes.split('.'):
+            if any(keyword in sentence.lower() for keyword in decision_keywords):
+                decisions.append(sentence.strip())
+        if decisions:
+            continuity.append(f"Player decisions needing consequences: {' | '.join(decisions[:3])}")
+
+        return continuity
+
     def _parse_session_generation(self, ai_response: str) -> dict:
         """Parse AI response for session generation"""
         parsed = {}