Add orchestrator for managing deliberation flow and speaker selection

app.py

@@ -23,6 +23,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 from core.game_state import GameState, GamePhase, DeliberationTurn
 from core.models import JurorConfig
 from core.conviction import calculate_conviction_change
+from core.orchestrator import OrchestratorAgent, TurnManager
 from case_db import CaseLoader, CriminalCase
 from agents import load_juror_configs, JurorAgent
 from ui.components import render_jury_box, render_vote_tally
@@ -33,15 +34,20 @@ CSS_PATH = Path(__file__).parent / "ui" / "static" / "styles.css"
 
 
 class JuryDeliberation:
-    """Main game orchestrator."""
+    """Main game orchestrator - delegates to OrchestratorAgent."""
 
     def __init__(self):
         self.case_loader = CaseLoader()
         self.juror_configs = load_juror_configs()
         self.juror_agents: dict[str, JurorAgent] = {}
-        self.game_state: GameState | None = None
+        self.orchestrator: OrchestratorAgent | None = None
         self.current_case: CriminalCase | None = None
 
+    @property
+    def game_state(self) -> GameState | None:
+        """Get game state from orchestrator."""
+        return self.orchestrator.game_state if self.orchestrator else None
+
     def initialize_game(self, case_id: str | None = None) -> tuple[str, str, str, list]:
         """Initialize a new game.
 
@@ -55,7 +61,6 @@ class JuryDeliberation:
             self.current_case = self.case_loader.get_random_case()
 
         if not self.current_case:
-            # Use a default case if none found
             return (
                 "No cases available. Please add case files to case_db/cases/",
                 "",
@@ -63,27 +68,25 @@ class JuryDeliberation:
                 []
             )
 
-        # Initialize game state
-        self.game_state = GameState(
-            case_id=self.current_case.case_id,
-            phase=GamePhase.PRESENTATION,
-        )
-
         # Initialize juror agents (skip player seat 7)
         self.juror_agents = {}
         for config in self.juror_configs:
             if config.archetype != "player":
                 try:
                     agent = JurorAgent(config)
-                    # Set initial conviction
-                    conviction = agent.set_initial_conviction(self.current_case)
-                    # Set initial vote
-                    self.game_state.votes[config.juror_id] = agent.get_vote()
-                    self.game_state.conviction_scores[config.juror_id] = conviction
+                    agent.set_initial_conviction(self.current_case)
                     self.juror_agents[config.juror_id] = agent
                 except Exception as e:
                     print(f"Warning: Failed to initialize {config.name}: {e}")
 
+        # Create orchestrator with agents
+        self.orchestrator = OrchestratorAgent(
+            juror_configs=self.juror_configs,
+            juror_agents=self.juror_agents,
+            case=self.current_case
+        )
+        self.orchestrator.state.phase = GamePhase.PRESENTATION
+
         # Format case info
         case_summary = f"""## {self.current_case.title}
 
@@ -96,7 +99,6 @@ class JuryDeliberation:
 {self.current_case.summary}
 """
 
-        # Format evidence
         evidence_html = f"""### Evidence
 
 {self.current_case.get_evidence_summary()}
@@ -106,32 +108,20 @@ class JuryDeliberation:
 {self.current_case.get_witness_summary()}
 """
 
-        # Render jury box
         jury_html = render_jury_box(self.juror_configs, self.game_state)
 
-        # Initial chat with judge introduction
         chat_history = [
-            {"role": "assistant", "content": f"**\u2696\uFE0F Judge:** Members of the jury, you are here today to determine the fate of the defendant in the case of {self.current_case.title}. Please review the evidence carefully and deliberate with your fellow jurors. The burden of proof lies with the prosecution."}
+            {"role": "assistant", "content": f"**⚖️ Judge:** Members of the jury, you are here today to determine the fate of the defendant in the case of {self.current_case.title}. Please review the evidence carefully and deliberate with your fellow jurors. The burden of proof lies with the prosecution."}
         ]
 
         return case_summary, evidence_html, jury_html, chat_history
 
     def select_player_side(self, side: str) -> tuple[str, str, list]:
-        """Player selects prosecution or defense side.
-
-        Returns:
-            Tuple of (vote_tally_html, jury_html, chat_history_update)
-        """
-        if not self.game_state:
+        """Player selects prosecution or defense side."""
+        if not self.orchestrator:
             return "", "", []
 
-        self.game_state.player_side = side
-        self.game_state.phase = GamePhase.DELIBERATION
-
-        # Set player's vote based on side
-        player_vote = "guilty" if side == "prosecute" else "not_guilty"
-        self.game_state.votes["juror_7"] = player_vote
-        self.game_state.conviction_scores["juror_7"] = 0.8 if side == "prosecute" else 0.2
+        self.orchestrator.set_player_side(side)
 
         vote_html = render_vote_tally(self.game_state)
         jury_html = render_jury_box(self.juror_configs, self.game_state)
@@ -142,69 +132,33 @@ class JuryDeliberation:
         return vote_html, jury_html, chat_update
 
     async def run_deliberation_round(self) -> tuple[str, str, list[dict]]:
-        """Run a single round of AI juror deliberation.
-
-        Returns:
-            Tuple of (vote_html, jury_html, new_chat_messages)
-        """
-        if not self.game_state or not self.current_case:
+        """Run a single round of AI juror deliberation using fair speaker queue."""
+        if not self.orchestrator or not self.current_case:
             return "", "", []
 
-        self.game_state.round_number += 1
         new_messages = []
 
-        # Select 1-3 random speakers (excluding player)
-        available_jurors = [
-            jid for jid in self.juror_agents.keys()
-            if jid != "juror_7"
-        ]
-        num_speakers = random.randint(1, min(3, len(available_jurors)))
-        speakers = random.sample(available_jurors, num_speakers)
+        # Use orchestrator's fair speaker selection
+        results = await self.orchestrator.run_deliberation_round()
 
-        # Each speaker makes an argument
-        for speaker_id in speakers:
-            agent = self.juror_agents[speaker_id]
-            config = next(c for c in self.juror_configs if c.juror_id == speaker_id)
+        # Format results for chat
+        for result in results:
+            turn = result.turn
+            config = next(c for c in self.juror_configs if c.juror_id == turn.speaker_id)
 
-            try:
-                # Generate argument
-                turn = await agent.generate_argument(self.current_case, self.game_state)
+            # Speaker's argument
+            new_messages.append(
+                {"role": "assistant", "content": f"**{config.emoji} {config.name}:** {turn.content}"}
+            )
 
-                # Add to chat
+            # Vote changes
+            for juror_id, old_vote, new_vote in result.vote_changes:
+                other_config = next(c for c in self.juror_configs if c.juror_id == juror_id)
+                vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
                 new_messages.append(
-                    {"role": "assistant", "content": f"**{config.emoji} {config.name}:** {turn.content}"}
+                    {"role": "assistant", "content": f"*{other_config.emoji} {other_config.name} changes their vote to {vote_text}*"}
                 )
 
-                # Other jurors react
-                for other_id, other_agent in self.juror_agents.items():
-                    if other_id != speaker_id:
-                        # Calculate impact based on archetype compatibility
-                        base_impact = random.uniform(-0.15, 0.15)
-                        impact = calculate_conviction_change(
-                            other_agent.config,
-                            other_agent.memory,
-                            turn,
-                            base_impact=base_impact
-                        )
-                        other_agent.receive_argument(turn, impact)
-
-                        # Update vote if conviction changed significantly
-                        new_vote = other_agent.get_vote()
-                        if self.game_state.votes.get(other_id) != new_vote:
-                            self.game_state.votes[other_id] = new_vote
-                            vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
-                            other_config = next(c for c in self.juror_configs if c.juror_id == other_id)
-                            new_messages.append(
-                                {"role": "assistant", "content": f"*{other_config.emoji} {other_config.name} changes their vote to {vote_text}*"}
-                            )
-
-                # Log turn
-                self.game_state.deliberation_log.append(turn)
-
-            except Exception as e:
-                print(f"Error in deliberation for {speaker_id}: {e}")
-
-        # Update displays
         vote_html = render_vote_tally(self.game_state)
         jury_html = render_jury_box(self.juror_configs, self.game_state)
 
@@ -215,22 +169,16 @@ class JuryDeliberation:
         strategy: str,
         custom_text: str | None = None
     ) -> tuple[str, str, list[tuple]]:
-        """Process player's argument.
-
-        Returns:
-            Tuple of (vote_html, jury_html, new_chat_messages)
-        """
-        if not self.game_state or not self.current_case:
+        """Process player's argument using orchestrator."""
+        if not self.orchestrator or not self.current_case:
             return "", "", []
 
-        # Get player config
         player_config = next(c for c in self.juror_configs if c.archetype == "player")
 
         # Create argument content
         if custom_text:
             content = custom_text
         else:
-            # Generate content based on strategy
             strategy_templates = {
                 "Challenge Evidence": "I'd like to point out some issues with the evidence presented...",
                 "Question Witness Credibility": "Can we really trust the witness testimony here?",
@@ -240,41 +188,19 @@ class JuryDeliberation:
             }
             content = strategy_templates.get(strategy, "I have some concerns about this case...")
 
-        # Create turn
-        turn = DeliberationTurn(
-            round_number=self.game_state.round_number,
-            speaker_id="juror_7",
-            speaker_name="You",
-            argument_type=strategy.lower().replace(" ", "_"),
-            content=content,
-        )
+        # Use orchestrator to process
+        argument_type = strategy.lower().replace(" ", "_")
+        result = self.orchestrator.process_player_argument(content, argument_type)
 
         new_messages = [{"role": "user", "content": f"**{player_config.emoji} You:** {content}"}]
 
-        # AI jurors react
-        for juror_id, agent in self.juror_agents.items():
-            base_impact = random.uniform(-0.1, 0.1)
-            # Player arguments have moderate base influence
-            base_impact *= 1.2
-            impact = calculate_conviction_change(
-                agent.config,
-                agent.memory,
-                turn,
-                base_impact=base_impact
+        # Vote changes
+        for juror_id, old_vote, new_vote in result.vote_changes:
+            config = next(c for c in self.juror_configs if c.juror_id == juror_id)
+            vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
+            new_messages.append(
+                {"role": "assistant", "content": f"*{config.emoji} {config.name} changes their vote to {vote_text}*"}
             )
-            agent.receive_argument(turn, impact)
-
-            # Check for vote changes
-            new_vote = agent.get_vote()
-            if self.game_state.votes.get(juror_id) != new_vote:
-                self.game_state.votes[juror_id] = new_vote
-                config = next(c for c in self.juror_configs if c.juror_id == juror_id)
-                vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
-                new_messages.append(
-                    {"role": "assistant", "content": f"*{config.emoji} {config.name} changes their vote to {vote_text}*"}
-                )
-
-        self.game_state.deliberation_log.append(turn)
 
         vote_html = render_vote_tally(self.game_state)
         jury_html = render_jury_box(self.juror_configs, self.game_state)

core/__init__.py

@@ -11,6 +11,12 @@ from .models import (
     ArgumentMemory,
 )
 from .conviction import calculate_conviction_change, check_vote_flip
+from .orchestrator import (
+    OrchestratorAgent,
+    TurnManager,
+    TurnResult,
+    SpeakerWeight,
+)
 
 __all__ = [
     "GameState",
@@ -21,4 +27,8 @@ __all__ = [
     "ArgumentMemory",
     "calculate_conviction_change",
     "check_vote_flip",
+    "OrchestratorAgent",
+    "TurnManager",
+    "TurnResult",
+    "SpeakerWeight",
 ]

core/orchestrator.py

@@ -0,0 +1,486 @@
+"""Orchestrator for 12 Angry Agents deliberation.
+
+Handles turn management, speaker selection, and deliberation flow.
+"""
+
+import random
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from core.game_state import GameState, DeliberationTurn, GamePhase
+from core.models import JurorConfig, JurorMemory
+from core.conviction import calculate_conviction_change
+
+if TYPE_CHECKING:
+    from agents.base_juror import JurorAgent
+    from case_db.models import CriminalCase
+
+
+@dataclass
+class SpeakerWeight:
+    """Weight information for speaker selection."""
+    juror_id: str
+    weight: float
+    reason: str  # Why this weight was assigned
+
+
+@dataclass
+class TurnResult:
+    """Result of a single turn in deliberation."""
+    turn: DeliberationTurn
+    conviction_changes: dict[str, float]  # juror_id -> delta
+    vote_changes: list[tuple[str, str, str]]  # (juror_id, old_vote, new_vote)
+
+
+class TurnManager:
+    """Manages fair speaker selection with weighted queue.
+
+    Selection priorities:
+    1. Jurors "on the fence" (conviction 0.35-0.65) - most interesting
+    2. Jurors who haven't spoken recently - fairness
+    3. Jurors with high influence - they drive conversation
+    4. Some randomness to keep things unpredictable
+    """
+
+    # Weights for different factors
+    ON_FENCE_BONUS = 2.0       # Bonus for jurors near 0.5 conviction
+    RECENCY_PENALTY = 0.3     # Multiplier for recent speakers
+    INFLUENCE_WEIGHT = 1.5    # How much influence affects selection
+    RANDOM_FACTOR = 0.3       # Random noise to add variety
+
+    # Track how many rounds before a juror can be "prioritized" again
+    RECENCY_WINDOW = 2
+
+    def __init__(self):
+        self.speaker_history: list[list[str]] = []  # Per-round speaker lists
+
+    def select_speakers(
+        self,
+        game_state: GameState,
+        juror_configs: list[JurorConfig],
+        juror_memories: dict[str, JurorMemory],
+        num_speakers: int = None,
+        exclude_player: bool = True
+    ) -> list[str]:
+        """Select speakers for the next round using weighted selection.
+
+        Args:
+            game_state: Current game state
+            juror_configs: All juror configurations
+            juror_memories: Memory state for each juror
+            num_speakers: Number of speakers (1-4, random if None)
+            exclude_player: Whether to exclude player from selection
+
+        Returns:
+            List of juror_ids selected to speak
+        """
+        # Determine number of speakers
+        if num_speakers is None:
+            num_speakers = random.randint(1, 3)
+
+        # Get eligible jurors
+        eligible = [
+            c for c in juror_configs
+            if not (exclude_player and c.is_player())
+        ]
+
+        if not eligible:
+            return []
+
+        # Calculate weights for each juror
+        weights = self._calculate_weights(
+            eligible,
+            juror_memories,
+            game_state.round_number
+        )
+
+        # Select speakers using weighted random selection
+        selected = self._weighted_select(weights, min(num_speakers, len(eligible)))
+
+        # Record this round's speakers
+        self.speaker_history.append(selected)
+
+        # Update game state speaking queue
+        game_state.speaking_queue = selected
+
+        return selected
+
+    def _calculate_weights(
+        self,
+        configs: list[JurorConfig],
+        memories: dict[str, JurorMemory],
+        current_round: int
+    ) -> list[SpeakerWeight]:
+        """Calculate selection weight for each juror."""
+        weights = []
+
+        for config in configs:
+            jid = config.juror_id
+            memory = memories.get(jid)
+
+            # Base weight from influence
+            base_weight = 0.5 + (config.influence * self.INFLUENCE_WEIGHT)
+
+            # On-the-fence bonus (conviction between 0.35-0.65)
+            if memory:
+                conviction = memory.current_conviction
+                fence_distance = abs(conviction - 0.5)
+                if fence_distance < 0.15:  # Very on the fence
+                    fence_bonus = self.ON_FENCE_BONUS * (1 - fence_distance / 0.15)
+                else:
+                    fence_bonus = 0.0
+            else:
+                fence_bonus = 0.0
+
+            # Recency penalty - spoke recently?
+            recency_multiplier = 1.0
+            reason_parts = []
+
+            for rounds_ago, speakers in enumerate(reversed(self.speaker_history[-self.RECENCY_WINDOW:])):
+                if jid in speakers:
+                    # More recent = bigger penalty
+                    penalty = self.RECENCY_PENALTY ** (rounds_ago + 1)
+                    recency_multiplier *= penalty
+                    reason_parts.append(f"spoke {rounds_ago + 1} rounds ago")
+                    break
+
+            # Volatility bonus - volatile jurors speak more
+            volatility_bonus = config.volatility * 0.5
+
+            # Calculate final weight
+            weight = (base_weight + fence_bonus + volatility_bonus) * recency_multiplier
+
+            # Add some randomness
+            weight += random.uniform(0, self.RANDOM_FACTOR)
+
+            # Build reason string
+            reasons = []
+            if fence_bonus > 0:
+                reasons.append(f"on fence (+{fence_bonus:.2f})")
+            if recency_multiplier < 1.0:
+                reasons.append(f"recent speaker (x{recency_multiplier:.2f})")
+            if config.influence > 0.6:
+                reasons.append(f"high influence")
+            if config.volatility > 0.6:
+                reasons.append(f"volatile")
+
+            weights.append(SpeakerWeight(
+                juror_id=jid,
+                weight=max(0.1, weight),  # Minimum weight to ensure everyone has a chance
+                reason=", ".join(reasons) if reasons else "baseline"
+            ))
+
+        return weights
+
+    def _weighted_select(
+        self,
+        weights: list[SpeakerWeight],
+        count: int
+    ) -> list[str]:
+        """Select jurors using weighted random selection without replacement."""
+        selected = []
+        remaining = list(weights)
+
+        for _ in range(count):
+            if not remaining:
+                break
+
+            # Calculate total weight
+            total = sum(w.weight for w in remaining)
+            if total <= 0:
+                break
+
+            # Random selection
+            r = random.uniform(0, total)
+            cumulative = 0
+
+            for i, w in enumerate(remaining):
+                cumulative += w.weight
+                if r <= cumulative:
+                    selected.append(w.juror_id)
+                    remaining.pop(i)
+                    break
+
+        return selected
+
+    def get_speaker_weights_debug(
+        self,
+        configs: list[JurorConfig],
+        memories: dict[str, JurorMemory],
+        current_round: int
+    ) -> list[SpeakerWeight]:
+        """Get weights for debugging/display purposes."""
+        return self._calculate_weights(configs, memories, current_round)
+
+    def reset(self):
+        """Reset speaker history for new game."""
+        self.speaker_history = []
+
+
+class OrchestratorAgent:
+    """Master agent that coordinates the deliberation.
+
+    Handles:
+    - Game phase transitions
+    - Turn management and speaker selection
+    - Processing arguments and reactions
+    - Vote tracking and stability detection
+    """
+
+    def __init__(
+        self,
+        juror_configs: list[JurorConfig],
+        juror_agents: dict[str, "JurorAgent"],
+        case: "CriminalCase"
+    ):
+        self.juror_configs = juror_configs
+        self.juror_agents = juror_agents
+        self.case = case
+        self.turn_manager = TurnManager()
+
+        # Initialize game state
+        self.state = GameState(case_id=case.case_id)
+
+        # Initialize votes and convictions from agents
+        for jid, agent in juror_agents.items():
+            self.state.votes[jid] = agent.get_vote()
+            self.state.conviction_scores[jid] = agent.memory.current_conviction
+
+    @property
+    def game_state(self) -> GameState:
+        """Get current game state."""
+        return self.state
+
+    def get_juror_memories(self) -> dict[str, JurorMemory]:
+        """Get memory state for all jurors."""
+        return {jid: agent.memory for jid, agent in self.juror_agents.items()}
+
+    async def run_deliberation_round(
+        self,
+        num_speakers: int = None
+    ) -> list[TurnResult]:
+        """Run a single round of deliberation.
+
+        Args:
+            num_speakers: Number of AI speakers this round (random 1-3 if None)
+
+        Returns:
+            List of TurnResult for each speaker
+        """
+        self.state.round_number += 1
+        results = []
+
+        # Record vote snapshot at start of round
+        votes_at_start = dict(self.state.votes)
+
+        # Select speakers using fair queue
+        speakers = self.turn_manager.select_speakers(
+            self.state,
+            self.juror_configs,
+            self.get_juror_memories(),
+            num_speakers=num_speakers,
+            exclude_player=True
+        )
+
+        # Process each speaker
+        for speaker_id in speakers:
+            result = await self._process_speaker_turn(speaker_id)
+            if result:
+                results.append(result)
+
+        # Check for vote stability
+        if self.state.votes == votes_at_start:
+            self.state.rounds_without_change += 1
+        else:
+            self.state.rounds_without_change = 0
+
+        return results
+
+    async def _process_speaker_turn(self, speaker_id: str) -> TurnResult | None:
+        """Process a single speaker's turn.
+
+        Args:
+            speaker_id: ID of the speaking juror
+
+        Returns:
+            TurnResult with argument and impacts, or None on error
+        """
+        agent = self.juror_agents.get(speaker_id)
+        if not agent:
+            return None
+
+        try:
+            # Generate argument
+            turn = await agent.generate_argument(self.case, self.state)
+
+            # Process reactions from other jurors
+            conviction_changes = {}
+            vote_changes = []
+
+            for other_id, other_agent in self.juror_agents.items():
+                if other_id == speaker_id:
+                    continue
+
+                # Calculate conviction change
+                old_vote = self.state.votes.get(other_id)
+                old_conviction = other_agent.memory.current_conviction
+
+                # Base impact with some randomness
+                base_impact = random.uniform(-0.15, 0.15)
+
+                # Calculate actual impact
+                delta = calculate_conviction_change(
+                    other_agent.config,
+                    other_agent.memory,
+                    turn,
+                    base_impact=base_impact
+                )
+
+                # Apply to agent
+                other_agent.receive_argument(turn, delta)
+                conviction_changes[other_id] = delta
+
+                # Record in turn impact
+                turn.impact[other_id] = delta
+
+                # Check for vote change
+                new_vote = other_agent.get_vote()
+                if old_vote != new_vote:
+                    self.state.votes[other_id] = new_vote
+                    vote_changes.append((other_id, old_vote, new_vote))
+
+                # Update conviction in game state
+                self.state.conviction_scores[other_id] = other_agent.memory.current_conviction
+
+            # Log the turn
+            self.state.deliberation_log.append(turn)
+
+            return TurnResult(
+                turn=turn,
+                conviction_changes=conviction_changes,
+                vote_changes=vote_changes
+            )
+
+        except Exception as e:
+            print(f"Error processing turn for {speaker_id}: {e}")
+            return None
+
+    def process_player_argument(
+        self,
+        content: str,
+        argument_type: str,
+        target_id: str | None = None
+    ) -> TurnResult:
+        """Process an argument from the human player.
+
+        Args:
+            content: The argument text
+            argument_type: Type of argument (e.g., "challenge_evidence")
+            target_id: Optional specific juror being addressed
+
+        Returns:
+            TurnResult with impacts
+        """
+        # Create turn
+        turn = DeliberationTurn(
+            round_number=self.state.round_number,
+            speaker_id="juror_7",
+            speaker_name="You",
+            argument_type=argument_type,
+            content=content,
+            target_id=target_id
+        )
+
+        # Process reactions
+        conviction_changes = {}
+        vote_changes = []
+
+        for juror_id, agent in self.juror_agents.items():
+            old_vote = self.state.votes.get(juror_id)
+
+            # Player arguments have slightly higher base impact
+            base_impact = random.uniform(-0.1, 0.1) * 1.2
+
+            # Bonus if targeting this specific juror
+            if target_id == juror_id:
+                base_impact *= 1.5
+
+            delta = calculate_conviction_change(
+                agent.config,
+                agent.memory,
+                turn,
+                base_impact=base_impact
+            )
+
+            agent.receive_argument(turn, delta)
+            conviction_changes[juror_id] = delta
+            turn.impact[juror_id] = delta
+
+            # Check vote change
+            new_vote = agent.get_vote()
+            if old_vote != new_vote:
+                self.state.votes[juror_id] = new_vote
+                vote_changes.append((juror_id, old_vote, new_vote))
+
+            self.state.conviction_scores[juror_id] = agent.memory.current_conviction
+
+        self.state.deliberation_log.append(turn)
+
+        return TurnResult(
+            turn=turn,
+            conviction_changes=conviction_changes,
+            vote_changes=vote_changes
+        )
+
+    def set_player_side(self, side: str) -> None:
+        """Set the player's chosen side.
+
+        Args:
+            side: "prosecute" or "defend"
+        """
+        self.state.player_side = side
+        self.state.phase = GamePhase.DELIBERATION
+
+        # Set player vote
+        player_vote = "guilty" if side == "prosecute" else "not_guilty"
+        self.state.votes["juror_7"] = player_vote
+        self.state.conviction_scores["juror_7"] = 0.8 if side == "prosecute" else 0.2
+
+    def check_should_end(self) -> bool:
+        """Check if deliberation should end."""
+        return self.state.should_end_deliberation()
+
+    def get_verdict(self) -> dict:
+        """Get the final verdict information."""
+        guilty, not_guilty = self.state.get_vote_tally()
+
+        if self.state.is_unanimous():
+            verdict = "GUILTY" if guilty == 12 else "NOT GUILTY"
+            unanimous = True
+        else:
+            verdict = "HUNG JURY"
+            unanimous = False
+
+        return {
+            "verdict": verdict,
+            "unanimous": unanimous,
+            "guilty_count": guilty,
+            "not_guilty_count": not_guilty,
+            "rounds": self.state.round_number,
+            "ended_by": self._get_end_reason()
+        }
+
+    def _get_end_reason(self) -> str:
+        """Get the reason deliberation ended."""
+        if self.state.is_unanimous():
+            return "unanimous_verdict"
+        elif self.state.rounds_without_change >= self.state.stability_threshold:
+            return "votes_stabilized"
+        elif self.state.round_number >= self.state.max_rounds:
+            return "max_rounds_reached"
+        return "unknown"
+
+    def reset(self) -> None:
+        """Reset for a new game."""
+        self.turn_manager.reset()
+        self.state = GameState(case_id=self.case.case_id if self.case else "")