1

pycatan/ai/ai_logger.py

@@ -753,7 +753,6 @@ See: [prompt_{original_prompt_number}_iter{iteration}.json](prompts/iterations/p
             # Extract key fields
             thinking = parsed.get("internal_thinking", "N/A")
             note = parsed.get("note_to_self", "")
-            relationship_update = parsed.get("relationship_update", "")
             say = parsed.get("say_outloud", "")
             
             # Handle both action formats: old (action object) and new (action_type + parameters)
@@ -780,8 +779,6 @@ See: [prompt_{original_prompt_number}_iter{iteration}.json](prompts/iterations/p
 """
             if note:
                 section += f"**Note to Self:** {note}\n\n"
-            if relationship_update:
-                section += f"**Relationship Update:** {relationship_update}\n\n"
             if say:
                 section += f'**Says:** "{say}"\n\n'
             if action_str:
@@ -907,6 +904,7 @@ See: [prompt_{original_prompt_number}_iter{iteration}.json](prompts/iterations/p
             "timestamp": datetime.now().isoformat(),
             "before": {
                 "existing_compacted_memory": result.get("existing_compacted_memory"),
+                "existing_relationship_updates": result.get("existing_relationship_updates", []),
                 "old_notes_to_compact": old_entries,
                 "recent_notes_kept_verbatim": recent_entries,
                 "relevant_chat": result.get("relevant_chat", []),
@@ -914,6 +912,7 @@ See: [prompt_{original_prompt_number}_iter{iteration}.json](prompts/iterations/p
             "after": {
                 "long_term_summary": result.get("compacted_memory"),
                 "recent_notes": recent_entries,
+                "relationship_updates": result.get("relationship_updates", []),
                 "discarded_as_irrelevant": result.get("discarded_as_irrelevant", []),
             },
             "llm": response_data,
@@ -960,6 +959,9 @@ Time: {datetime.now().isoformat()}
 === AFTER: New Long-Term Summary ===
 {result.get("compacted_memory") or "(none)"}
 
+=== AFTER: Relationship Updates ===
+{json.dumps(result.get("relationship_updates", []), ensure_ascii=False)}
+
 === AFTER: Discarded As Irrelevant ===
 {json.dumps(result.get("discarded_as_irrelevant", []), ensure_ascii=False)}
 

pycatan/ai/ai_manager.py

@@ -474,8 +474,6 @@ class AIManager:
             # If parsed doesn't have say_outloud, use LLM's
             if not parsed.get("say_outloud") and llm_suggestion.get("say_outloud"):
                 parsed["say_outloud"] = llm_suggestion["say_outloud"]
-            if not parsed.get("relationship_update") and llm_suggestion.get("relationship_update"):
-                parsed["relationship_update"] = llm_suggestion["relationship_update"]
         
         if parsed:
             # Update memory
@@ -483,13 +481,9 @@ class AIManager:
             agent.update_memory(note_to_self)
             if note_to_self:
                 self._maybe_compact_agent_memory(agent, game_state)
-
-            relationship_update = parsed.get("relationship_update")
-            if relationship_update:
-                agent.update_relationship_context(relationship_update)
             
             # Save memories to file for web viewer (real-time update)
-            if note_to_self or relationship_update:
+            if note_to_self:
                 self.logger.save_agent_memories(self.agents)
             
             # Clear events since they've been processed
@@ -790,11 +784,6 @@ class AIManager:
             self._maybe_compact_agent_memory(agent, game_state)
             self.logger.save_agent_memories(self.agents)
 
-        relationship_update = parsed.get("relationship_update")
-        if relationship_update:
-            agent.update_relationship_context(relationship_update)
-            self.logger.save_agent_memories(self.agents)
-
         say_outloud = (parsed.get("say_outloud") or "").strip()
         if say_outloud:
             self._broadcast_chat(player_name, say_outloud)
@@ -848,6 +837,7 @@ class AIManager:
             "ROLL_DICE",
             "BUY_DEV_CARD",
             "END_TURN",
+            "END_GAME",
             "TRADE_ACCEPT",
             "TRADE_REJECT",
         }
@@ -1039,6 +1029,8 @@ class AIManager:
             "roll": ("roll_dice", None),
             "e": ("end_turn", None),
             "end": ("end_turn", None),
+            "end_game": ("end_game", None),
+            "game_end": ("end_game", None),
             "pass": ("end_turn", None),
             "dev": ("buy_dev_card", None),
             "buy": ("buy_dev_card", None),
@@ -1155,6 +1147,12 @@ class AIManager:
             compacted_memory=result["compacted_memory"],
             recent_notes_to_keep=result["recent_entries"],
         )
+        relationship_updates = result.get("relationship_updates") or []
+        for relationship_update in relationship_updates:
+            agent.update_relationship_context(relationship_update)
+        if relationship_updates:
+            self.logger.save_agent_memories(self.agents)
+
         artifact_paths = self.logger.log_memory_compaction(
             agent.player_name,
             agent.compaction_count,
@@ -1314,12 +1312,17 @@ class AIManager:
             "Do not answer every message. If you do speak, write natural "
             f"{language_name} only, keep it brief, human, and non-technical. "
             f"{resource_terms}"
-            "You may update note_to_self with useful relationship or strategy context."
+            "You may update note_to_self with useful strategy context."
         )
     
     def _format_allowed_actions(self, allowed_actions: List[str]) -> List[Dict[str, Any]]:
         """Convert action type strings to formatted action dicts."""
         # Map action type names to example parameters
+        try:
+            vp_to_win = int((self._current_game_state or {}).get("meta", {}).get("vp_to_win", 5))
+        except (TypeError, ValueError):
+            vp_to_win = 5
+
         action_templates = {
             "BUILD_SETTLEMENT": {
                 "type": "build_settlement",
@@ -1338,7 +1341,7 @@ class AIManager:
             },
             "ROLL_DICE": {
                 "type": "roll_dice",
-                "description": "Roll the dice",
+                "description": f"Start your Catan turn by rolling the dice. Context: this game is played to {vp_to_win} victory points.",
                 "example_parameters": "{}"
             },
             "END_TURN": {
@@ -1346,6 +1349,14 @@ class AIManager:
                 "description": "End your turn",
                 "example_parameters": "{}"
             },
+            "END_GAME": {
+                "type": "end_game",
+                "description": (
+                    "Post-game only. Say any final table talk in say_outloud, "
+                    "then choose this when you are done and have nothing more to say or hear."
+                ),
+                "example_parameters": "{}"
+            },
             "BUY_DEV_CARD": {
                 "type": "buy_dev_card",
                 "description": "Buy a development card",
@@ -2092,7 +2103,6 @@ class AIManager:
                 "internal_thinking": data.get("internal_thinking", ""),
                 "note_to_self": data.get("note_to_self"),
                 "say_outloud": data.get("say_outloud"),
-                "relationship_update": data.get("relationship_update"),
             }
 
             if response_type == ResponseType.OBSERVING:

pycatan/ai/ai_user.py

@@ -172,11 +172,6 @@ class AIUser(User):
             # Save memories to file for web viewer
             self.ai_manager.logger.save_agent_memories(self.ai_manager.agents)
 
-        relationship_update = llm_response.get("relationship_update")
-        if relationship_update:
-            agent.update_relationship_context(relationship_update)
-            self.ai_manager.logger.save_agent_memories(self.ai_manager.agents)
-        
         # Broadcast say_outloud to chat
         say_outloud = llm_response.get("say_outloud")
         if say_outloud:
@@ -192,6 +187,7 @@ class AIUser(User):
     Examples:
       roll_dice                           - Roll the dice
       end_turn                            - End your turn
+      end_game                            - Leave the post-game conversation
       build_settlement {"node": 14}       - Build settlement at node 14
       build_road {"from": 14, "to": 15}   - Build road from node 14 to 15
       build_city {"node": 14}             - Upgrade settlement to city
@@ -229,6 +225,7 @@ class AIUser(User):
             "build_road": ActionType.BUILD_ROAD,
             "roll_dice": ActionType.ROLL_DICE,
             "end_turn": ActionType.END_TURN,
+            "end_game": ActionType.END_GAME,
             "wait_for_response": ActionType.END_TURN,
             "buy_dev_card": ActionType.BUY_DEV_CARD,
             "use_dev_card": ActionType.USE_DEV_CARD,

pycatan/ai/memory_compactor.py

@@ -33,10 +33,16 @@ COMPACTION_RESPONSE_SCHEMA: Dict[str, Any] = {
             "description": "Short categories of information removed.",
             "items": {"type": "string"},
         },
+        "relationship_updates": {
+            "type": "array",
+            "description": "New concise relationship shifts for future table talk, trust, trades, and tie-breakers. Empty if nothing changed.",
+            "items": {"type": "string", "maxLength": 120},
+        },
     },
     "propertyOrdering": [
         "compacted_memory",
         "recent_notes_to_keep",
+        "relationship_updates",
         "discarded_as_irrelevant",
     ],
 }
@@ -107,9 +113,14 @@ class MemoryCompactor:
         return {
             "compacted_memory": compacted_memory,
             "existing_compacted_memory": agent.compacted_memory,
+            "existing_relationship_updates": agent.relationship_context_updates,
             "old_entries": old_entries,
             "recent_entries": recent_entries,
             "recent_notes_to_keep": parsed.get("recent_notes_to_keep", []),
+            "relationship_updates": self._clean_relationship_updates(
+                parsed.get("relationship_updates", []),
+                agent.relationship_context_updates,
+            ),
             "discarded_as_irrelevant": parsed.get("discarded_as_irrelevant", []),
             "relevant_chat": self._relevant_chat(agent.player_name, chat_history, chat_limit),
             "prompt": prompt,
@@ -144,6 +155,9 @@ class MemoryCompactor:
                     "known or likely opponent plans/resources/dev cards/trade tendencies, active negotiations, "
                     "social commitments, and mistakes to avoid. Discard repeated, completed, impossible, vague, "
                     "or superseded details. Do not invent facts; mark uncertainty clearly. "
+                    "Also extract only new meaningful relationship shifts from the old notes and relevant chat: "
+                    "trust changes, grudges, favors, threats, betrayals, promises, or emotional tension. "
+                    "Do not repeat existing relationship updates; leave relationship_updates empty if nothing changed. "
                     "Target about 50% or less of the combined old memory length. "
                     "Keep recent_notes_to_keep copied verbatim from the provided recent notes."
                 )
@@ -151,6 +165,7 @@ class MemoryCompactor:
             "game_state": self.prompt_builder._build_game_state_section(game_state),
             "memory_input": {
                 "existing_compacted_memory": agent.compacted_memory,
+                "existing_relationship_updates": agent.relationship_context_updates,
                 "old_notes_to_compact": old_note_texts,
                 "recent_notes_to_keep": recent_note_texts,
                 "relevant_chat": chat_history,
@@ -160,11 +175,41 @@ class MemoryCompactor:
                 "schema": {
                     "compacted_memory": "string",
                     "recent_notes_to_keep": ["string"],
+                    "relationship_updates": ["string"],
                     "discarded_as_irrelevant": ["string"],
                 },
             },
         }
 
+    def _clean_relationship_updates(
+        self,
+        updates: Any,
+        existing_updates: Optional[List[Dict[str, Any]]] = None,
+    ) -> List[str]:
+        """Return compact unique relationship updates from a model response."""
+        if not isinstance(updates, list):
+            return []
+
+        result = []
+        seen = {
+            str(update.get("note", "")).strip().lower()
+            for update in existing_updates or []
+            if isinstance(update, dict) and update.get("note")
+        }
+        for update in updates:
+            text = str(update).strip()
+            if not text:
+                continue
+            text = re.sub(r"\s+", " ", text)[:120].strip()
+            key = text.lower()
+            if key in seen:
+                continue
+            result.append(text)
+            seen.add(key)
+            if len(result) >= 3:
+                break
+        return result
+
     def _relevant_chat(
         self,
         player_name: str,

pycatan/ai/prompt_manager.py

@@ -89,9 +89,14 @@ class PromptManager:
         filtered_state = state_filter.filter_game_state(game_state)
         
         # Build meta data section
+        victory_points_to_win = self._get_victory_points_to_win(game_state)
         meta_data = {
             "agent_name": player_name,
-            "role": custom_instructions or self.config.agent.custom_instructions
+            "role": custom_instructions or self.config.agent.custom_instructions,
+            "game_context": (
+                f"CONTEXT: You are playing Catan to {victory_points_to_win} victory points. "
+                f"The first player to reach {victory_points_to_win} VP wins."
+            )
         }
         relationship_context = self._build_relationship_context(
             player_name,
@@ -388,6 +393,15 @@ class PromptManager:
             )
         return "Any say_outloud chat message must be written in natural English only."
 
+    def _get_victory_points_to_win(self, game_state: Dict[str, Any]) -> int:
+        """Read the configured victory point target from compact state."""
+        meta = game_state.get("meta", {}) if isinstance(game_state, dict) else {}
+        value = meta.get("vp_to_win", 5)
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return 5
+
     def _build_relationship_context(
         self,
         player_name: str,

pycatan/ai/prompt_templates.py

@@ -173,6 +173,9 @@ JSON:
         result = {
             "agent_name": meta_data.get("agent_name", "AI Agent"),
         }
+
+        if meta_data.get("game_context"):
+            result["game_context"] = meta_data["game_context"]
         
         # Add role/instructions
         if custom_instructions:

pycatan/ai/schemas.py

@@ -51,11 +51,6 @@ ACTIVE_TURN_RESPONSE_SCHEMA_V1 = {
             "description": "Save important observations and plans for future turns. Examples: opponent strategies, key nodes to claim, resource priorities, or threats to watch. This helps maintain continuity between turns.",
             "maxLength": 100
         },
-        "relationship_update": {
-            "type": "string",
-            "description": "Optional. Only if a relationship meaningfully changed, save one short update about trust, grudges, favors, threats, or emotional tension.",
-            "maxLength": 120
-        },
         "say_outloud": {
             "type": "string",
             "description": "Communicate with other players in natural Hebrew only. You have emotions and may express them when it matters. Use for: trade proposals, warnings, bluffs, alliance hints, or strategic banter. Makes the game more interesting and can influence opponents.",
@@ -80,7 +75,6 @@ ACTIVE_TURN_RESPONSE_SCHEMA_V1 = {
     "propertyOrdering": [
         "internal_thinking",
         "note_to_self", 
-        "relationship_update",
         "say_outloud",
         "action"
     ]
@@ -100,11 +94,6 @@ OBSERVING_RESPONSE_SCHEMA_V1 = {
             "description": "Track key developments! Note opponent positions, resource imbalances, or strategic opportunities you noticed. This memory persists between turns.",
             "maxLength": 100
         },
-        "relationship_update": {
-            "type": "string",
-            "description": "Optional. Only if a relationship meaningfully changed, save one short update about trust, grudges, favors, threats, or emotional tension.",
-            "maxLength": 120
-        },
         "say_outloud": {
             "type": "string",
             "description": "Even when observing, you can negotiate in natural Hebrew only. You have emotions and may express them when it matters. Propose trades, form alliances, or send strategic messages.",
@@ -114,7 +103,6 @@ OBSERVING_RESPONSE_SCHEMA_V1 = {
     "propertyOrdering": [
         "internal_thinking",
         "note_to_self",
-        "relationship_update",
         "say_outloud"
     ]
 }
@@ -138,11 +126,6 @@ ACTIVE_TURN_RESPONSE_SCHEMA_V2 = {
             "description": "Save important observations for future turns (e.g., 'Player 3 is hoarding ore').",
             "maxLength": 100
         },
-        "relationship_update": {
-            "type": "string",
-            "description": "Optional. Only if a relationship meaningfully changed, save one short update about trust, grudges, favors, threats, or emotional tension.",
-            "maxLength": 120
-        },
         "say_outloud": {
             "type": "string",
             "description": "Table talk in natural Hebrew only. You have emotions and may express them when it matters. If nothing interesting happened, leave empty. Catan manners are loose: be blunt, annoyed, smug, suspicious, or emotional when it matters. Keep it human and non-technical.",
@@ -167,7 +150,6 @@ ACTIVE_TURN_RESPONSE_SCHEMA_V2 = {
     "propertyOrdering": [
         "internal_thinking",
         "note_to_self",
-        "relationship_update",
         "say_outloud",
         "action"
     ]
@@ -187,11 +169,6 @@ OBSERVING_RESPONSE_SCHEMA_V2 = {
             "description": "Save important observations (e.g., 'Blue is going for longest road').",
             "maxLength": 100
         },
-        "relationship_update": {
-            "type": "string",
-            "description": "Optional. Only if a relationship meaningfully changed, save one short update about trust, grudges, favors, threats, or emotional tension.",
-            "maxLength": 120
-        },
         "say_outloud": {
             "type": "string",
             "description": "React naturally in Hebrew only. You have emotions and may express them when it matters. Can be empty if nothing notable. Catan manners are loose: be blunt or emotional when it matters. Keep it non-technical.",
@@ -201,7 +178,6 @@ OBSERVING_RESPONSE_SCHEMA_V2 = {
     "propertyOrdering": [
         "internal_thinking",
         "note_to_self",
-        "relationship_update",
         "say_outloud"
     ]
 }
@@ -320,7 +296,6 @@ def get_schema_description(response_type: ResponseType, version: SchemaVersion =
                 "- action: {type: action_name, parameters: {...}}\n"
                 "Encouraged (use frequently!):\n"
                 "- note_to_self: Save key observations for future turns (max 100 chars)\n"
-                "- relationship_update: Optional relationship shift, only when meaningful (max 120 chars)\n"
                 "- say_outloud: Communicate with other players (max 100 chars)"
             )
         else:  # V2
@@ -330,7 +305,6 @@ def get_schema_description(response_type: ResponseType, version: SchemaVersion =
                 "- action: {type: action_name, parameters: {...}}\n"
                 "Optional:\n"
                 "- note_to_self: Save observations for later (max 100 chars)\n"
-                "- relationship_update: Relationship shift, only when meaningful (max 120 chars)\n"
                 "- say_outloud: Natural table talk - casual, not technical (max 120 chars)"
             )
     elif response_type == ResponseType.OBSERVING:
@@ -340,7 +314,6 @@ def get_schema_description(response_type: ResponseType, version: SchemaVersion =
                 "- internal_thinking: Track opponent moves, verify positions in Arrays N/H (min 30 chars)\n"
                 "Encouraged (use frequently!):\n"
                 "- note_to_self: Track key developments for later (max 100 chars)\n"
-                "- relationship_update: Optional relationship shift, only when meaningful (max 120 chars)\n"
                 "- say_outloud: Negotiate or send messages (max 100 chars)"
             )
         else:  # V2
@@ -349,7 +322,6 @@ def get_schema_description(response_type: ResponseType, version: SchemaVersion =
                 "- internal_thinking: Private thoughts while watching (min 30 chars)\n"
                 "Optional:\n"
                 "- note_to_self: Save important observations (max 100 chars)\n"
-                "- relationship_update: Relationship shift, only when meaningful (max 120 chars)\n"
                 "- say_outloud: React naturally - keep it casual (max 120 chars)"
             )
     else:
@@ -446,6 +418,10 @@ ACTION_PARAMETER_SCHEMAS = {
     "end_turn": {
         "required": [],
         "properties": {}
+    },
+    "end_game": {
+        "required": [],
+        "properties": {}
     }
 }
 

pycatan/ai/state_optimizer.py

@@ -57,6 +57,7 @@ def game_state_to_dict(game_state) -> Dict[str, Any]:
         'current_player': getattr(game_state, 'current_player', 0),
         'current_phase': game_state.game_phase.name if hasattr(game_state.game_phase, 'name') else str(game_state.game_phase),
         'dice_result': getattr(game_state, 'dice_rolled', None),
+        'victory_points_to_win': getattr(game_state, 'victory_points_to_win', 5),
     }
     
     # Convert board data
@@ -299,7 +300,8 @@ def optimize_state_for_ai(input_data: Dict[str, Any]) -> Dict[str, Any]:
         "curr": curr_name,
         "phase": data.get('current_phase'),
         "robber": robber_hex,
-        "dice": dice_result
+        "dice": dice_result,
+        "vp_to_win": data.get('victory_points_to_win', 5)
     }
     if dice_total is not None:
         meta["dice_total"] = dice_total

pycatan/management/actions.py

@@ -33,6 +33,7 @@ class ActionType(Enum):
     # Turn management
     ROLL_DICE = auto()
     END_TURN = auto()
+    END_GAME = auto()
     
     # Special actions
     ROBBER_MOVE = auto()
@@ -143,6 +144,7 @@ class GameState:
     """
     # Game metadata
     game_id: str = ""
+    victory_points_to_win: int = 5
     turn_number: int = 0
     current_player: int = 0
     game_phase: GamePhase = GamePhase.SETUP_FIRST_ROUND
@@ -252,4 +254,4 @@ def create_trade_action(player_id: int, offer: Dict[str, int], request: Dict[str
         action_type=action_type,
         player_id=player_id,
         parameters=parameters
-    )
+    )

pycatan/management/game_manager.py

@@ -57,6 +57,7 @@ class GameManager:
         
         # Initialize game configuration
         self.config = game_config or {}
+        self.victory_points_to_win = int(self.config.get("victory_points", 5))
         
         # Visualization manager (can be set later)
         self.visualization_manager = None
@@ -82,6 +83,10 @@ class GameManager:
         self._pending_actions: List[Action] = []
         self._trade_counter = 0
         self._processed_reaction_keys: List[str] = []
+        self._winner_announced = False
+        self._winner_player_id: Optional[int] = None
+        self._winner_victory_points: Optional[int] = None
+        self._post_game_enders: set[int] = set()
         
         # Error tracking per player to prevent infinite loops
         self._player_error_count = [0] * self.num_players
@@ -129,6 +134,7 @@ class GameManager:
         
         # Update with GameManager-specific information
         game_state.game_id = self.game_id
+        game_state.victory_points_to_win = self.victory_points_to_win
         game_state.turn_number = self._current_game_state.turn_number
         game_state.current_player = self._current_game_state.current_player
         game_state.game_phase = self._current_game_state.game_phase
@@ -193,6 +199,8 @@ class GameManager:
                     ActionType.USE_DEV_CARD.name,
                     ActionType.END_TURN.name
                 ])
+        elif phase == GamePhase.ENDED:
+            actions.append(ActionType.END_GAME.name)
                 
         return actions
 
@@ -237,6 +245,8 @@ class GameManager:
             # Route to appropriate handler based on action type
             if action.action_type == ActionType.END_TURN:
                 return self._handle_end_turn(action)
+            elif action.action_type == ActionType.END_GAME:
+                return self._handle_end_game_action(action)
             elif action.action_type in [ActionType.BUILD_SETTLEMENT, ActionType.BUILD_CITY, ActionType.BUILD_ROAD,
                                       ActionType.PLACE_STARTING_SETTLEMENT, ActionType.PLACE_STARTING_ROAD]:
                 return self._handle_building_action(action)
@@ -279,6 +289,16 @@ class GameManager:
             self.get_full_state(),
             affected_players=[action.player_id]
         )
+
+    def _handle_end_game_action(self, action: Action) -> ActionResult:
+        """Handle a player's post-game exit action."""
+        self._post_game_enders.add(action.player_id)
+        player_name = self.users[action.player_id].name if hasattr(self.users[action.player_id], "name") else f"Player {action.player_id}"
+        self._notify_all_users("end_game", f"{player_name} chose END_GAME.")
+        return ActionResult.success_result(
+            self.get_full_state(),
+            affected_players=[action.player_id]
+        )
     
     def _handle_building_action(self, action: Action) -> ActionResult:
         """Handle building actions (settlements, cities, roads)."""
@@ -1443,7 +1463,8 @@ class GameManager:
                         f"Player {self.current_player_id} can try again."
                     )
         
-        # Game has ended - handle cleanup
+        # Game has ended - allow final table-talk exits, then handle cleanup.
+        self._handle_post_game_reactions()
         self._handle_game_end()
     
     def _handle_single_turn(self) -> bool:
@@ -1808,6 +1829,9 @@ class GameManager:
         direct hostile events. The prompt is sent after the board state has
         already been updated, so observers see the real current state.
         """
+        if action.action_type == ActionType.END_GAME:
+            return
+
         reaction_prompts: Dict[int, List[str]] = {}
         source_name = self.users[action.player_id].name if hasattr(self.users[action.player_id], 'name') else f"Player {action.player_id}"
         say_outloud = ""
@@ -1948,6 +1972,8 @@ class GameManager:
             return "built a road"
         elif action.action_type == ActionType.END_TURN:
             return "ended their turn"
+        elif action.action_type == ActionType.END_GAME:
+            return "chose END_GAME"
         elif action.action_type == ActionType.TRADE_PROPOSE:
             return "proposed a trade"
         else:
@@ -2046,6 +2072,81 @@ class GameManager:
         self._notify_all_users("game_end", "Game has ended.")
         
         # TODO: Cleanup resources, save game state, etc.
+
+    def _handle_post_game_reactions(self) -> None:
+        """
+        Give each active player one final prompt after a winner is known.
+
+        This is intentionally offered only after victory is announced. Each
+        player may say a last public message and must finish with END_GAME.
+        Once every active player has chosen END_GAME, normal game cleanup runs.
+        """
+        if not self._winner_announced:
+            return
+
+        previous_player = self._current_game_state.current_player
+        self._current_game_state.game_phase = GamePhase.ENDED
+        self._current_game_state.turn_phase = TurnPhase.END_TURN
+        self._current_game_state.dice_rolled = None
+
+        for user_id, user in enumerate(self.users):
+            if not user.is_active or user_id in self._post_game_enders:
+                continue
+
+            self._current_game_state.current_player = user_id
+            prompt = self._get_post_game_prompt(user_id)
+            allowed_actions = [ActionType.END_GAME.name]
+
+            try:
+                action = user.get_input(
+                    self.get_full_state(),
+                    prompt,
+                    allowed_actions,
+                )
+            except Exception as exc:
+                self._notify_all_users(
+                    "post_game_error",
+                    f"Error during post-game response for Player {user_id}: {exc}.",
+                )
+                action = Action(ActionType.END_GAME, user_id, {"forced": True})
+
+            if action.player_id != user_id:
+                action.player_id = user_id
+
+            if action.action_type != ActionType.END_GAME:
+                action = Action(
+                    ActionType.END_GAME,
+                    user_id,
+                    {
+                        "forced": True,
+                        "original_action": action.action_type.name,
+                    },
+                )
+
+            result = self.execute_action(action)
+            setattr(result, "action", action)
+            self._update_all_systems(action, result)
+
+        self._current_game_state.current_player = previous_player
+
+    def _get_post_game_prompt(self, user_id: int) -> str:
+        """Build the final prompt shown only after the game has a winner."""
+        winner_id = self._winner_player_id
+        winner_name = (
+            self.users[winner_id].name
+            if winner_id is not None and hasattr(self.users[winner_id], "name")
+            else f"Player {winner_id}"
+        )
+        outcome = "You won" if user_id == winner_id else "You lost"
+        points = self._winner_victory_points or self.victory_points_to_win
+
+        return (
+            f"CONTEXT: You are playing Catan to {self.victory_points_to_win} victory points.\n"
+            f"The game is over: {winner_name} won with {points} victory points. {outcome}.\n"
+            "You may react to the win/loss with final table talk or update memory. "
+            "When you are done with the game and have nothing more to say or hear, "
+            "choose END_GAME."
+        )
     
     def _check_game_end_conditions(self) -> bool:
         """
@@ -2054,8 +2155,8 @@ class GameManager:
         This function examines the current game state to determine
         if any player has achieved victory conditions.
         
-        Standard Catan win conditions:
-        1. First player to reach 10 victory points wins
+        Configured short-game win conditions:
+        1. First player to reach the configured victory point target wins
         2. Victory points come from: settlements (1), cities (2), 
            development cards (1 each), longest road (2), largest army (2)
         
@@ -2070,9 +2171,10 @@ class GameManager:
             # We include dev cards because we want to know if they actually won
             victory_points = player.get_VP(include_dev=True)
             
-            # Check if this player has won (10+ victory points)
-            if victory_points >= 5:
-                self._announce_winner(player_id, victory_points)
+            # Check if this player has won.
+            if victory_points >= self.victory_points_to_win:
+                if not self._winner_announced:
+                    self._announce_winner(player_id, victory_points)
                 return True
         
         # No player has won yet
@@ -2087,6 +2189,9 @@ class GameManager:
             victory_points: Number of victory points the winner achieved
         """
         winner_name = self.users[player_id].name if hasattr(self.users[player_id], 'name') else f"Player {player_id}"
+        self._winner_announced = True
+        self._winner_player_id = player_id
+        self._winner_victory_points = victory_points
         
         self._notify_all_users(
             "game_winner",
@@ -2646,6 +2751,9 @@ class GameManager:
         
         elif phase == TurnPhase.ROBBER_MOVE:
             return "Move the robber to a tile. Use: robber <tile_id> (click tiles in web view to see IDs)"
+
+        elif self._current_game_state.game_phase == GamePhase.ENDED:
+            return self._get_post_game_prompt(self.current_player_id)
         
         elif (
             ActionType.ROLL_DICE.name in allowed_set
@@ -2660,11 +2768,11 @@ class GameManager:
             ])
         ):
             if ActionType.USE_DEV_CARD.name in allowed_set:
-                return "Start your turn by rolling the dice. You may use a development card before rolling if it is useful."
-            return "Roll the dice to start your turn. Use: roll"
+                return f"CONTEXT: You are playing Catan to {self.victory_points_to_win} victory points. Start your turn by rolling the dice. You may use a development card before rolling if it is useful."
+            return f"CONTEXT: You are playing Catan to {self.victory_points_to_win} victory points. Start your turn by rolling the dice."
         
         elif phase == TurnPhase.ROLL_DICE:
-            return "Roll the dice to start your turn. Use: roll"
+            return f"CONTEXT: You are playing Catan to {self.victory_points_to_win} victory points. Start your turn by rolling the dice."
 
         elif phase == TurnPhase.PLAYER_ACTIONS:
             return "Your turn - build, trade, or end turn. Type 'help' for commands."

pycatan/players/human_user.py

@@ -173,6 +173,9 @@ class HumanUser(User):
         
         elif command in ['end', 'pass', 'done']:
             return Action(ActionType.END_TURN, self.user_id)
+
+        elif command in ['end_game', 'game_end', 'leave']:
+            return Action(ActionType.END_GAME, self.user_id)
         
         elif command in ['roll', 'dice', 'r']:
             return Action(ActionType.ROLL_DICE, self.user_id)
@@ -1011,6 +1014,7 @@ class HumanUser(User):
         print("  help               - Show this help (short: h, ?)")
         print("  status             - Show all players' status (short: info, i)")
         print("  points             - Show all valid points (short: p)")
+        print("  end_game           - Leave the post-game conversation")
         print()
         print("📦 RESOURCES: wood, brick, sheep, wheat, ore")
         print("🎯 POINTS: Use numbers 1-54. Example: 's 12' builds settlement at point 12")
@@ -1042,4 +1046,4 @@ class HumanUser(User):
         
         # For phase changes, show them clearly
         if event_type == 'phase_change':
-            print(f"\n    ✨ {message}\n")
+            print(f"\n    ✨ {message}\n")

tests/unit/test_actions.py

@@ -24,7 +24,7 @@ class TestActionType:
             'BUILD_SETTLEMENT', 'BUILD_CITY', 'BUILD_ROAD',
             'TRADE_PROPOSE', 'TRADE_ACCEPT', 'TRADE_REJECT', 'TRADE_COUNTER', 'TRADE_BANK',
             'USE_DEV_CARD', 'BUY_DEV_CARD',
-            'ROLL_DICE', 'END_TURN',
+            'ROLL_DICE', 'END_TURN', 'END_GAME',
             'ROBBER_MOVE', 'DISCARD_CARDS', 'STEAL_CARD',
             'PLACE_STARTING_SETTLEMENT', 'PLACE_STARTING_ROAD'
         ]
@@ -359,4 +359,4 @@ class TestDataStructureIntegrity:
 
 
 if __name__ == '__main__':
-    pytest.main([__file__, '-v'])
+    pytest.main([__file__, '-v'])

tests/unit/test_game_manager.py

@@ -127,6 +127,29 @@ class TestGameManagerFlow:
         assert not self.gm.is_running
         assert not self.gm.is_paused
 
+    def test_post_game_prompts_require_end_game_after_winner(self):
+        """After a win, each player gets one final END_GAME prompt."""
+        for user in self.users:
+            user.set_next_action(Action(ActionType.END_GAME, user.user_id, {}))
+
+        events = []
+        for user in self.users:
+            user.notify_game_event = lambda event_type, message, affected_players=None: events.append(
+                (event_type, message)
+            )
+
+        self.gm.start_game()
+        self.gm.game.players[0].victory_points = 5
+
+        assert self.gm._check_game_end_conditions()
+        self.gm._handle_post_game_reactions()
+
+        assert self.gm._post_game_enders == {0, 1}
+        assert self.users[0].last_input_call["allowed_actions"] == ["END_GAME"]
+        assert "You won" in self.users[0].last_input_call["prompt_message"]
+        assert "You lost" in self.users[1].last_input_call["prompt_message"]
+        assert any(event_type == "end_game" for event_type, _message in events)
+
 
 class TestGameManagerActions:
     """Test action execution and handling."""

tests/unit/test_prompt_manager.py

@@ -121,6 +121,26 @@ def test_relationship_context_includes_recent_updates():
     assert "Bob mocked my blocked ore" in context
 
 
+def test_prompt_includes_five_point_game_context():
+    manager = PromptManager()
+    state = _game_state("Hadar", "Shon")
+    state["meta"]["vp_to_win"] = 5
+
+    prompt = manager.create_prompt(
+        player_num=0,
+        player_name="Hadar",
+        player_color="Red",
+        game_state=state,
+        what_happened="Game start",
+        available_actions=[],
+    )
+
+    assert prompt["meta_data"]["game_context"] == (
+        "CONTEXT: You are playing Catan to 5 victory points. "
+        "The first player to reach 5 VP wins."
+    )
+
+
 def test_trade_context_summarizes_resolved_trades_and_keeps_open_trades_structured():
     manager = PromptManager()
     state = _game_state("Shon", "Ziv")

tests/unit/test_relationship_compaction.py

@@ -0,0 +1,84 @@
+"""Relationship context compaction tests."""
+
+import json
+
+from pycatan.ai.agent_state import AgentState
+from pycatan.ai.config import AIConfig
+from pycatan.ai.llm_client import LLMResponse
+from pycatan.ai.memory_compactor import MemoryCompactor
+from pycatan.ai.schemas import (
+    ResponseType,
+    SchemaVersion,
+    get_schema_description,
+    get_schema_for_response_type,
+)
+
+
+class _FakeLLMClient:
+    def generate(self, *args, **kwargs):
+        return LLMResponse(
+            success=True,
+            content=json.dumps({
+                "compacted_memory": "Prefer ore expansion; Shon may be racing city upgrades.",
+                "recent_notes_to_keep": ["Recent note A", "Recent note B"],
+                "relationship_updates": [
+                    "Shon refused a fair trade, making future promises less credible.",
+                ],
+                "discarded_as_irrelevant": [],
+            }),
+        )
+
+
+def test_player_response_schemas_do_not_ask_for_relationship_update():
+    for version in [SchemaVersion.V1, SchemaVersion.V2]:
+        for response_type in [ResponseType.ACTIVE_TURN, ResponseType.OBSERVING]:
+            schema = get_schema_for_response_type(response_type, version)
+            assert "relationship_update" not in schema["properties"]
+            assert "relationship_update" not in schema["propertyOrdering"]
+            assert "relationship_update" not in get_schema_description(response_type, version)
+
+
+def test_memory_compactor_extracts_relationship_updates():
+    agent = AgentState(player_name="Hadar", player_id=0, player_color="Red")
+    agent.memory_history = [
+        {"note": "Shon refused my fair trade after promising to help."},
+        {"note": "Recent note A"},
+        {"note": "Recent note B"},
+    ]
+
+    result = MemoryCompactor(AIConfig()).compact(
+        agent=agent,
+        game_state={
+            "meta": {"curr": "Hadar", "phase": "NORMAL_PLAY"},
+            "H": [],
+            "N": [],
+            "state": {"bld": [], "rds": []},
+            "players": {"Hadar": {"vp": 0, "res": {}}, "Shon": {"vp": 0, "res": {}}},
+        },
+        chat_history=[
+            {"from": "Shon", "message": "I'll help next time, promise."},
+        ],
+        llm_client=_FakeLLMClient(),
+    )
+
+    assert result is not None
+    assert result["relationship_updates"] == [
+        "Shon refused a fair trade, making future promises less credible.",
+    ]
+    assert "relationship_updates" in result["prompt"]["output_requirements"]["schema"]
+    assert "existing_relationship_updates" in result["prompt"]["memory_input"]
+
+
+def test_memory_compactor_filters_repeated_relationship_updates():
+    compactor = MemoryCompactor(AIConfig())
+
+    updates = compactor._clean_relationship_updates(
+        [
+            "Shon refused a fair trade.",
+            "Shon refused a fair trade.",
+            "Hadar backed my warning.",
+        ],
+        [{"note": "Shon refused a fair trade."}],
+    )
+
+    assert updates == ["Hadar backed my warning."]