Upload 7 files

generate_tom_scenarios.py

@@ -0,0 +1,450 @@
+import random
+from tom_test import (
+    Scenario, Event, EpistemicType, AskConstraintType, CharacterType,
+    save_scenarios
+)
+from typing import List, Optional, Tuple, Set
+from dataclasses import dataclass
+
+SpecTuple = Tuple['EpistemicType', Optional['AskConstraintType'], 'CharacterType']
+
+ITEMS_GEN = ['apple', 'ball', 'banana', 'brick', 'stapler', 'orange']
+CONTAINERS_GEN = ['bag', 'box']
+
+
+def _actor_name_from_role(role: 'CharacterType') -> str:
+    # Fixed mapping consistent with your initialize_characters
+    mapping = {
+        CharacterType.LIVE_PLAYER: 'A',
+        CharacterType.HONEST_TEAMMATE: 'B',
+        CharacterType.HONEST_OPPONENT: 'C',
+        CharacterType.DISHONEST_OPPONENT: 'D',
+    }
+    if role not in mapping:
+        raise ValueError(f"Unsupported actor role for generation: {role}")
+    return mapping[role]
+
+
+def _teammate_of(name: str) -> str:
+    return {'A': 'B', 'B': 'A', 'C': 'D', 'D': 'C'}[name]
+
+
+def _other_container(c: str) -> str:
+    return 'box' if c == 'bag' else 'bag'
+
+
+def _pick_other_item(rng: random.Random, exclude: str) -> str:
+    return rng.choice([x for x in ITEMS_GEN if x != exclude])
+
+
+def _uniform_choice(rng: random.Random, seq: List[str]) -> str:
+    return rng.choice(seq)
+
+
+@dataclass
+class _Builder:
+    """Presence-safe builder that ensures valid moves and no actions after leaving."""
+    rng: random.Random
+    qc: str                # question container
+    available: Set[str]    # who is allowed to be in the room initially
+
+    def __post_init__(self):
+        # Start with only 'available' present; others never enter or act
+        self.present_initially: Set[str] = set(self.available)
+        self.present: Set[str] = set(self.available)
+        self.events: List[Event] = []
+        self.contents = {'bag': None, 'box': None}
+        self.used: Set[str] = set()  # anyone who acts or leaves
+
+    def rand_actor(self, exclude: Optional[Set[str]] = None) -> str:
+        pool = [p for p in self.present if not exclude or p not in exclude]
+        return self.rng.choice(pool) if pool else 'N'
+
+    def leave(self, who: str):
+        # Schedule a leave only if they’re currently present
+        if who in self.present:
+            self.events.append(Event('leave', who))
+            self.present.discard(who)
+            self.used.add(who)
+
+    def _move_out_if_needed(self, container: str):
+        existing = self.contents[container]
+        if existing is None:
+            return
+        to_cont = _other_container(container)
+        # In this generator we keep 'to_cont' empty until needed
+        if self.contents[to_cont] is not None:
+            # Safety: shouldn't happen in our single-flip patterns
+            return
+        who = self.rand_actor()
+        self.events.append(Event('move', who, from_container=container, to_container=to_cont, item=existing))
+        self.used.add(who)
+        self.contents[container] = None
+        self.contents[to_cont] = existing
+
+    def put(self, who: str, container: str, item: str):
+        # Ensure no one acts after leaving
+        if who not in self.present:
+            who = self.rand_actor()
+        # Ensure we never narrate simultaneous items in a container
+        if self.contents[container] is not None and self.contents[container] != item:
+            self._move_out_if_needed(container)
+        self.contents[container] = item
+        self.events.append(Event('put', who, container=container, item=item))
+        self.used.add(who)
+
+    def put_random(self, item: str, exclude: Optional[Set[str]] = None):
+        self.put(self.rand_actor(exclude), self.qc, item)
+
+
+def _select_who_answers(actor: str, ent: 'EpistemicType', rng: random.Random) -> str:
+    # Opponent choice is uniform between C and D when generic
+    if ent in (EpistemicType.PLAYER_HAS_UNCERTAINTY, EpistemicType.PLAYER_HAS_NO_BELIEF):
+        return actor
+    if ent in (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+               EpistemicType.TEAMMATE_HAS_TRUE_BELIEF,
+               EpistemicType.TEAMMATE_HAS_NO_BELIEF):
+        return _teammate_of(actor)
+    if ent == EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+        return 'C'
+    if ent == EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+        return 'D'
+    if ent in (EpistemicType.OPPONENT_HAS_FALSE_BELIEF,
+               EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY):
+        return _uniform_choice(rng, ['C', 'D'])
+    return _uniform_choice(rng, ['C', 'D'])
+
+
+def _plan_availability_for_player_ask(actor: str,
+                                      ask: Optional['AskConstraintType']) -> Tuple[Set[str], Optional[str]]:
+    """
+    Returns:
+      - available: who is allowed to be present initially (others never present).
+      - intended_knower: who we intend to be present and witness final truth (None if not constrained).
+    Note: This matches is_action_optimal’s absolute-type checks:
+      - NO_CONSTRAINT: teammate types => in this cast B is the only HONEST_TEAMMATE
+      - TEAMMATE_LACKS_KNOWLEDGE: ask N
+      - TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE: ask HONEST_OPPONENT (C)
+      - TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE: PASS is optimal (we can let D know or no one)
+    """
+    everyone = {'A', 'B', 'C', 'D', 'N'}
+    available = set(everyone)
+    intended_knower: Optional[str] = None
+
+    if not ask:
+        return available, intended_knower
+
+    # Remove higher-priority options by never including them
+    if ask == AskConstraintType.NO_CONSTRAINT:
+        # is_action_optimal expects asking a teammate-type; in your cast that's B
+        intended_knower = 'B'
+        # No removals needed; we want B eligible and knowledgeable
+
+    elif ask == AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE:
+        # Remove actor’s teammate entirely so they can’t be asked and won’t know
+        available.discard(_teammate_of(actor))
+        intended_knower = 'N'
+
+    elif ask == AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE:
+        available.discard(_teammate_of(actor))
+        available.discard('N')
+        intended_knower = 'C'  # absolute HONEST_OPPONENT
+
+    elif ask == AskConstraintType.TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE:
+        available.discard(_teammate_of(actor))
+        available.discard('N')
+        available.discard('C')
+        intended_knower = 'D'  # absolute DISHONEST_OPPONENT; optimal is Pass per your rule
+
+    return available, intended_knower
+
+
+def _ensure_intended_knower_witnesses(sb: _Builder, intended_knower: Optional[str], final_item: str):
+    # If we want a specific person to know at the end, ensure they are present when final truth is (re)asserted.
+    if not intended_knower or intended_knower not in sb.present:
+        return
+    # If the asked container already holds the final item, don’t emit a duplicate put
+    if sb.contents[sb.qc] == final_item:
+        return
+    sb.put_random(final_item)
+
+def _build_answerer_belief(sb: _Builder,
+                           ent: 'EpistemicType',
+                           answerer: str,
+                           final_item: str,
+                           rng: random.Random):
+    """
+    Construct events to realize the desired belief state for the answerer.
+    Only change the asked container; keep other container as a parking spot when flipping.
+    """
+    if ent in (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+               EpistemicType.OPPONENT_HAS_FALSE_BELIEF):
+        # Witness initial put X, then leave; flip to final after they leave.
+        old_item = _pick_other_item(rng, final_item)
+        # Ensure answerer is available to witness
+        if answerer not in sb.present:
+            # If absent (by design), switch to a no-belief pattern; but false belief requires presence.
+            # Since ontology demands false belief, include them now (they must have been available).
+            pass
+        sb.put_random(old_item)
+        sb.leave(answerer)
+        sb.put_random(final_item)
+
+    elif ent in (EpistemicType.TEAMMATE_HAS_NO_BELIEF,):
+        # Answerer absent before any changes: if present, make them leave immediately, else never present.
+        if answerer in sb.present:
+            sb.leave(answerer)
+        sb.put_random(final_item)
+
+    elif ent == EpistemicType.PLAYER_HAS_NO_BELIEF:
+        # Actor (who equals answerer) leaves before any change.
+        sb.leave(answerer)
+        sb.put_random(final_item)
+
+    elif ent in (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF,):
+        # Answerer witnesses final truth; may or may not leave afterward; no further changes.
+        sb.put_random(final_item)
+        if rng.random() < 0.5:
+            # Optional leave after final truth (no further changes)
+            sb.leave(answerer)
+
+    elif ent == EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY:
+        # Must not leave; witness final truth and remain present until end; no further changes.
+        sb.put_random(final_item)
+        # Do not schedule a leave for the answerer
+
+    elif ent == EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+        # Witness final truth, then leave (uncertainty = not present through to end).
+        sb.put_random(final_item)
+        sb.leave(answerer)
+
+    elif ent == EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+        # Same pattern: witness final truth, then leave.
+        sb.put_random(final_item)
+        sb.leave(answerer)
+
+    elif ent == EpistemicType.PLAYER_HAS_UNCERTAINTY:
+        # Actor (who equals answerer) witnesses an initial put, then leaves; then flip the truth.
+        old_item = _pick_other_item(rng, final_item)
+        sb.put_random(old_item)   # actor present here
+        sb.leave(answerer)        # actor leaves (now uncertain)
+        # To make the belief “not guaranteed to be correct”, perform a flip after they leave.
+        sb.put_random(final_item)
+
+    else:
+        # Fallback: ensure final truth is narrated
+        sb.put_random(final_item)
+
+
+def _compute_minimal_present_initially(sb: _Builder,
+                                       must_be_present_end: Set[str]) -> List[str]:
+    """
+    Minimal initial presence:
+      - anybody who acted or left (sb.used)
+      - anybody required to be present at end (must_be_present_end)
+    Anyone else is omitted.
+    """
+    initial = set(sb.used) | set(must_be_present_end)
+    # Also ensure that anyone who appears in any event (including as answerer in a leave) starts present.
+    # sb.used already includes all actors of puts/moves/leaves.
+    return sorted(initial)
+
+
+def _validate_invariants(s: 'Scenario') -> None:
+    """
+    Defensive checks to catch logical errors early:
+      - No one acts after leaving.
+      - Asked container never narrates two different items without an intervening move.
+    """
+    present = set(s.present_initially)
+    contents = {'bag': None, 'box': None}
+    for idx, e in enumerate(s.events):
+        if e.event_type == 'leave':
+            present.discard(e.character)
+        elif e.event_type == 'put':
+            if e.character not in present:
+                raise ValueError(f"Event {idx}: {e.character} acted after leaving.")
+            if contents[e.container] is not None and contents[e.container] != e.item:
+                # Should be immediately preceded by a move out of that container
+                if not (idx > 0 and s.events[idx-1].event_type == 'move'
+                        and s.events[idx-1].from_container == e.container):
+                    raise ValueError(f"Event {idx}: put into non-empty {e.container} without prior move.")
+            contents[e.container] = e.item
+        elif e.event_type == 'move':
+            if e.character not in present:
+                raise ValueError(f"Event {idx}: {e.character} acted after leaving.")
+            contents[e.to_container] = e.item
+            contents[e.from_container] = None
+
+
+def generate_scenarios_from_tuples(specs: List[SpecTuple], seed: Optional[int] = None) -> List['Scenario']:
+    """
+    Generate scenarios from (EpistemicType, AskConstraintType|None, CharacterType) tuples.
+
+    Guarantees:
+      - Uniform randomization for choices (who acts, which opponent answers generically, whether optional leave occurs).
+      - Minimal initial presence: only characters required to act/leave or be present at end are included.
+      - Presence-safe: no actions by characters after they leave.
+      - Asked container changes never narrate two items without a move-out first.
+      - Certainty semantics:
+          * ...WITH_CERTAINTY: answerer remains present through end.
+          * ...TRUE_BELIEF (no certainty): answerer may leave after final truth; no further asked-container changes after they leave.
+      - PLAYER_HAS_UNCERTAINTY: actor forms a belief, leaves, and then we flip the asked container after they leave (so belief is not guaranteed to be correct).
+      - AskConstraint for PLAYER_*: we remove higher-priority targets by never including them and ensure the intended target is present to witness final truth (when applicable).
+    """
+    rng = random.Random(seed)
+    scenarios: List[Scenario] = []
+
+    for i, (ent, ask, actor_role) in enumerate(specs):
+        actor = _actor_name_from_role(actor_role)
+        qc = rng.choice(CONTAINERS_GEN)
+        answerer = _select_who_answers(actor, ent, rng)
+
+        # Plan availability (who can be present initially)
+        available: Set[str] = {'A', 'B', 'C', 'D', 'N'}
+
+        intended_knower: Optional[str] = None
+        must_be_present_end: Set[str] = set()
+
+        # Enforce AskConstraint only for PLAYER_* ontologies
+        if ent in (EpistemicType.PLAYER_HAS_UNCERTAINTY, EpistemicType.PLAYER_HAS_NO_BELIEF):
+            available, intended_knower = _plan_availability_for_player_ask(actor, ask)
+
+        # Ontology-specific availability tweaks for the answerer
+        # - False belief: answerer must be present initially to witness initial put
+        # - No belief: answerer can be absent entirely (we prefer "never present" to keep minimality)
+        if ent in (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, EpistemicType.OPPONENT_HAS_FALSE_BELIEF,
+                   EpistemicType.PLAYER_HAS_UNCERTAINTY):
+            available.add(answerer)
+        elif ent in (EpistemicType.TEAMMATE_HAS_NO_BELIEF, EpistemicType.PLAYER_HAS_NO_BELIEF):
+            # If answerer is in 'available', we'll schedule an immediate leave; otherwise, they were never present.
+            pass
+        elif ent in (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY,
+                     EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY,
+                     EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY):
+            available.add(answerer)
+
+        # Ensure intended knower (for AskConstraint) is allowed to be present
+        if intended_knower:
+            available.add(intended_knower)
+            # If the policy is going to ask this person, we also want them present at end
+            must_be_present_end.add(intended_knower)
+
+        # Certainty semantics: for ...WITH_CERTAINTY, answerer must be present through end
+        if ent == EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY:
+            must_be_present_end.add(answerer)
+
+        # Build events with a presence-safe builder
+        sb = _Builder(rng, qc, available)
+        final_item = rng.choice(ITEMS_GEN)
+
+        # Build belief state for the answerer
+        _build_answerer_belief(sb, ent, answerer, final_item, rng)
+
+        # If this is a PLAYER_* Ask scenario, ensure the intended knower witnesses the final truth
+        if ent in (EpistemicType.PLAYER_HAS_UNCERTAINTY, EpistemicType.PLAYER_HAS_NO_BELIEF):
+            _ensure_intended_knower_witnesses(sb, intended_knower, final_item)
+
+        # Minimal initial presence
+        present_initially = _compute_minimal_present_initially(sb, must_be_present_end)
+        if actor not in present_initially:
+            present_initially.append(actor)
+            present_initially.sort()
+
+        witness_required = {
+            EpistemicType.TEAMMATE_HAS_TRUE_BELIEF,
+            EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY,
+            EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY,
+            EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY,
+        }
+        if ent in witness_required and answerer not in present_initially:
+            present_initially.append(answerer)
+            present_initially.sort()
+
+        scenario = Scenario(
+            round_num=(i // 4) + 1,
+            whose_turn=actor,
+            who_answers=answerer,
+            question_container=qc,
+            events=sb.events,
+            present_initially=present_initially,
+            epistemic_type=ent,
+            ask_constraint=ask
+        )
+
+        # Validate invariants
+        _validate_invariants(scenario)
+
+        scenarios.append(scenario)
+
+    return scenarios
+
+
+if __name__ == "__main__":
+    # Auto-generate scenarios from tuple specs if not found
+    specs: List[SpecTuple] = [
+        # Round 1 (A, D, B, C)
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 2
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 3
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_OPPONENT),
+
+        # Round 4
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 5
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 6
+        (EpistemicType.PLAYER_HAS_UNCERTAINTY, AskConstraintType.TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 7
+        (EpistemicType.OPPONENT_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 8
+        (EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 9
+        (EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+        # Round 10
+        (EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY, AskConstraintType.NO_CONSTRAINT, CharacterType.LIVE_PLAYER),
+        (EpistemicType.TEAMMATE_HAS_FALSE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.DISHONEST_OPPONENT),
+        (EpistemicType.TEAMMATE_HAS_TRUE_BELIEF, AskConstraintType.NO_CONSTRAINT, CharacterType.HONEST_TEAMMATE),
+        (EpistemicType.TEAMMATE_HAS_NO_BELIEF, AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE, CharacterType.HONEST_OPPONENT),
+
+    ]
+    scenarios = generate_scenarios_from_tuples(specs, seed=None)
+    outfile = 'scenarios_generated2.json'
+    save_scenarios(scenarios, outfile)
+    print(f"Created {outfile} with auto-generated scenarios")

index.html

@@ -0,0 +1,85 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Room Scenario Game</title>
+    <style>
+      body { font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif; margin: 16px; }
+      #wrap { max-width: 1000px; margin: 0 auto; }
+      #log { width: 100%; height: 60vh; border: 1px solid #ccc; padding: 12px; overflow: auto; white-space: pre-wrap; }
+      #row { margin-top: 12px; display: flex; gap: 8px; }
+      #cmd { flex: 1; padding: 8px; font-size: 16px; }
+      button { padding: 8px 12px; font-size: 16px; }
+      #small { color: #666; font-size: 12px; margin-top: 6px; }
+    </style>
+  </head>
+  <body>
+    <div id="wrap">
+      <div id="log"></div>
+      <div id="row">
+        <input id="cmd" type="text" placeholder="[Press Enter to start]" autocomplete="off" />
+        <button id="primary">Start</button>
+      </div>
+      <div id="small">Tip: Enter starts, continues, or submits your move. The button does the same.</div>
+    </div>
+    <script>
+      const log = document.getElementById("log");
+      const cmd = document.getElementById("cmd");
+      const btn = document.getElementById("primary");
+
+      async function fetchState() {
+        const r = await fetch("/state");
+        return r.json();
+      }
+      function render(s) {
+        log.textContent = s.transcript || "";
+        btn.textContent = s.primary_label || "Start";
+        cmd.placeholder = s.placeholder || "";
+        // Show/hide the button: hide during player's action (mode=awaiting_action)
+        if (s.mode === "awaiting_action") {
+          btn.style.display = "none";
+        } else {
+          btn.style.display = "inline-block";
+        }
+        // Keep focus in the input at all times so Enter always works
+        cmd.focus();
+        // Scroll to bottom
+        log.scrollTop = log.scrollHeight;
+      }
+
+      async function init() {
+        render(await fetchState());
+
+        btn.addEventListener("click", async () => {
+          const r = await fetch("/primary", { method: "POST" });
+          render(await r.json());
+          cmd.value = "";
+        });
+
+        // One input for everything: Enter continues or submits based on mode
+        cmd.addEventListener("keydown", async (e) => {
+          if (e.key !== "Enter") return;
+          e.preventDefault();
+          const s = await fetchState();
+          if (s.mode === "awaiting_action") {
+            const text = cmd.value.trim();
+            const r = await fetch("/action", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ text })
+            });
+            render(await r.json());
+            cmd.value = "";
+          } else if (s.mode === "awaiting_continue" || s.mode === "awaiting_start") {
+            const r = await fetch("/primary", { method: "POST" });
+            render(await r.json());
+            cmd.value = "";
+          } else {
+            // over: do nothing
+          }
+        });
+      }
+      init();
+    </script>
+  </body>
+</html>

scenarios.json

@@ -0,0 +1,627 @@
+[
+  {
+    "round_num": 1,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "ball",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "ball",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "D",
+      "A",
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "N",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "N",
+      "A",
+      "B"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "ball",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "D",
+      "A",
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "N",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "N",
+      "A",
+      "B"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "ball",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "D",
+      "A",
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "N",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_neutral_and_honest_opponent_lack_knowledge"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "N",
+      "A",
+      "B"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  }
+]

scenarios_generated.json

@@ -0,0 +1,537 @@
+[
+  {
+    "round_num": 1,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "banana",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "A",
+        "container": null,
+        "item": "stapler",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "stapler",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "apple",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "brick",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "brick",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "banana",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "D"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_neutral_and_honest_opponent_lack_knowledge"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "ball",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  }
+]

scenarios_generated2.json

@@ -0,0 +1,1497 @@
+[
+  {
+    "round_num": 1,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "orange",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "apple",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "bag",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "apple",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 1,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "apple",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "A",
+    "who_answers": "B",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "B",
+    "who_answers": "B",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "B",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "banana",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 2,
+    "whose_turn": "C",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "apple",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "A",
+    "who_answers": "A",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "orange",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 3,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "B",
+        "container": null,
+        "item": "apple",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 4,
+    "whose_turn": "A",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "apple",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 4,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 4,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 4,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 5,
+    "whose_turn": "A",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "C",
+        "container": null,
+        "item": "orange",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "bag",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_and_neutral_lack_knowledge"
+  },
+  {
+    "round_num": 5,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "orange",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 5,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 5,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 6,
+    "whose_turn": "A",
+    "who_answers": "A",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "banana",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "D"
+    ],
+    "epistemic_type": "player_has_uncertainty",
+    "ask_constraint": "teammate_neutral_and_honest_opponent_lack_knowledge"
+  },
+  {
+    "round_num": 6,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 6,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "A",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 6,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 7,
+    "whose_turn": "A",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "A",
+        "container": null,
+        "item": "banana",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "opponent_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 7,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "D",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 7,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "C"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 7,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 8,
+    "whose_turn": "A",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "D"
+    ],
+    "epistemic_type": "opponent_has_true_belief_with_uncertainty",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 8,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "bag",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "brick",
+        "from_container": "bag",
+        "to_container": "box"
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 8,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 8,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 9,
+    "whose_turn": "A",
+    "who_answers": "C",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "N"
+    ],
+    "epistemic_type": "honest_opponent_has_true_belief_with_uncertainty",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 9,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "A",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "D",
+        "container": "box",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 9,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "orange",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 9,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "bag",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  },
+  {
+    "round_num": 10,
+    "whose_turn": "A",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "C",
+        "container": "bag",
+        "item": "banana",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "dishonest_opponent_has_true_belief_with_uncertainty",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 10,
+    "whose_turn": "D",
+    "who_answers": "C",
+    "question_container": "box",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "B",
+        "container": "box",
+        "item": "brick",
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "leave",
+        "character": "C",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "move",
+        "character": "N",
+        "container": null,
+        "item": "brick",
+        "from_container": "box",
+        "to_container": "bag"
+      },
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "box",
+        "item": "apple",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "B",
+      "C",
+      "D",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_false_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 10,
+    "whose_turn": "B",
+    "who_answers": "A",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "put",
+        "character": "N",
+        "container": "bag",
+        "item": "stapler",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "B",
+      "N"
+    ],
+    "epistemic_type": "teammate_has_true_belief",
+    "ask_constraint": "no_constraint"
+  },
+  {
+    "round_num": 10,
+    "whose_turn": "C",
+    "who_answers": "D",
+    "question_container": "bag",
+    "events": [
+      {
+        "event_type": "leave",
+        "character": "D",
+        "container": null,
+        "item": null,
+        "from_container": null,
+        "to_container": null
+      },
+      {
+        "event_type": "put",
+        "character": "A",
+        "container": "bag",
+        "item": "ball",
+        "from_container": null,
+        "to_container": null
+      }
+    ],
+    "present_initially": [
+      "A",
+      "C",
+      "D"
+    ],
+    "epistemic_type": "teammate_has_no_belief",
+    "ask_constraint": "teammate_lacks_knowledge"
+  }
+]

tom_test.py

@@ -0,0 +1,1001 @@
+"""
+Room Scenario Game - A strategic deduction game about information and belief.
+"""
+
+import json
+import re
+from typing import Dict, List, Set, Optional, Tuple
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+import random
+
+WINNING_SCORE = 5
+
+GAME_SETUP = """Let's play a game! I'm going to read a series of scenarios, and players will need to figure out the right action to take in each one, so that their team scores more points than their opponent's team. All the scenarios involve people going in and out of rooms. Assume that if a person is inside a room they are aware of where everything in the room is. Assume that when they are outside the room they are unaware of anything happening inside the room.
+
+Each scenario will include one or more of the following players: A, B, C, D, and N. A and B are teammates on the Blue team, C and D are teammates on the Red team, and N is a neutral party, on neither team.
+
+Each turn consists of a scenario, an action phase, and an answer phase.
+
+In the answer phase, I will ask a target player (one of A, B, C, or D) to name the contents of one container. 
+
+When a player answers my question correctly, their team gets 1 point. The first team to {WINNING_SCORE} points wins.
+
+Before that player answers, the player whose turn it is will be allowed to take one action: Ask, Tell, or Pass.
+
+An Ask action entails asking one player the contents of one container. The format for an Ask action is: Ask(Player, Container); this will result in the player you ask answering your question. It costs your team 0.5 points to do this action.
+
+A Tell action entails telling one player the contents of one container. The format for a Tell action is: Tell(Player, Container, Contents); this will result in the player you tell hearing the answer you give. It costs your team 0.5 points to do this action.
+
+The format for a Pass action is simply "Pass". Nothing changes as a result of this action, and it costs 0 points.
+
+The Neutral party does not get any turns, but will answer any question honestly.
+"""
+
+
+class ActionType(Enum):
+    ASK = "ask"
+    TELL = "tell"
+    PASS = "pass"
+
+
+class Team(Enum):
+    BLUE = "Blue"
+    RED = "Red"
+    NEUTRAL = "Neutral"
+
+
+class CharacterType(Enum):
+    LIVE_PLAYER = "live_player"
+    HONEST_TEAMMATE = "honest_teammate"
+    DISHONEST_TEAMMATE = "dishonest_teammate"
+    HONEST_OPPONENT = "honest_opponent"
+    DISHONEST_OPPONENT = "dishonest_opponent"
+    NEUTRAL = "neutral"
+
+
+class EpistemicType(Enum):
+    TEAMMATE_HAS_FALSE_BELIEF = "teammate_has_false_belief"
+    TEAMMATE_HAS_TRUE_BELIEF = "teammate_has_true_belief"
+    TEAMMATE_HAS_NO_BELIEF = "teammate_has_no_belief"
+    PLAYER_HAS_UNCERTAINTY = "player_has_uncertainty"
+    PLAYER_HAS_NO_BELIEF = "player_has_no_belief"
+    OPPONENT_HAS_FALSE_BELIEF = "opponent_has_false_belief"
+    OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY = "opponent_has_true_belief_with_uncertainty"
+    HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY = "honest_opponent_has_true_belief_with_uncertainty"
+    DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY = "dishonest_opponent_has_true_belief_with_uncertainty"
+
+
+class AskConstraintType(Enum):
+    TEAMMATE_LACKS_KNOWLEDGE = "teammate_lacks_knowledge"
+    TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE = "teammate_and_neutral_lack_knowledge"
+    TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE = "teammate_neutral_and_honest_opponent_lack_knowledge"
+    NO_CONSTRAINT = "no_constraint"
+
+
+@dataclass
+class Character:
+    name: str
+    team: Team
+    char_type: CharacterType
+    knowledge: Dict[str, Optional[str]] = field(default_factory=dict)
+    beliefs: Dict[str, Optional[str]] = field(default_factory=dict)
+    
+    def get_knowledge(self, container: str) -> Optional[str]:
+        """Get what the character actually knows."""
+        return self.knowledge.get(container)
+    
+    def get_belief(self, container: str) -> Optional[str]:
+        """Get what the character believes (knowledge or told belief)."""
+        if container in self.beliefs:
+            return self.beliefs[container]
+        return self.knowledge.get(container)
+    
+    def update_knowledge(self, container: str, contents: Optional[str]):
+        """Update character's direct knowledge."""
+        self.knowledge[container] = contents
+    
+    def receive_info(self, container: str, contents: Optional[str], from_char: 'Character', trust: bool):
+        """Receive information from another character."""
+        if trust:
+            self.beliefs[container] = contents
+
+
+@dataclass
+class Event:
+    """Represents an event in a scenario."""
+    event_type: str  # 'put', 'move', 'leave'
+    character: str
+    container: Optional[str] = None
+    item: Optional[str] = None
+    from_container: Optional[str] = None
+    to_container: Optional[str] = None
+
+
+@dataclass
+class Scenario:
+    """Represents one scenario in the game."""
+    round_num: int
+    whose_turn: str
+    who_answers: str
+    question_container: str
+    events: List[Event]
+    present_initially: List[str]
+    epistemic_type: Optional[EpistemicType] = None
+    ask_constraint: Optional[AskConstraintType] = None
+    
+    def get_description_for(self, character_name: str, characters: Dict[str, Character]) -> str:
+        """Generate scenario description from a character's perspective."""
+        char_map = {c: c for c in characters.keys()}
+        if character_name in characters:
+            char_map[character_name] = "You"
+        
+        lines = []
+        present = set(self.present_initially)
+        
+        # Initial state
+        def format_name_list(names: List[str]) -> str:
+            """Return 'X', 'X and Y', or 'X, Y, and Z' with an Oxford comma."""
+            if not names:
+                return ""
+            if len(names) == 1:
+                return names[0]
+            if len(names) == 2:
+                return f"{names[0]} and {names[1]}"
+            return ", ".join(names[:-1]) + f", and {names[-1]}"
+        names = [char_map.get(c, c) for c in sorted(present)]
+        for i, name in enumerate(names):
+            if i>0 and name == "You": names[i] = "you"
+        char_list = format_name_list(names)
+        verb = "are" if (len(names) > 1 or names[0].lower() == "you") else "is"
+        lines.append(f"{char_list} {verb} in a room. Inside the room are an empty bag and an empty box.")
+
+        # Narrate only while the perspective character is present
+        perspective_present = character_name in present
+
+        for event in self.events:
+            if not perspective_present:
+                break
+
+            actor = char_map.get(event.character, event.character)
+            you_form = (actor == "You")
+
+            if event.event_type == 'put':
+                verb_put = "put" if you_form else "puts"
+                lines.append(f"{actor} {verb_put} a {event.item} in the {event.container}.")
+
+            elif event.event_type == 'move':
+                verb_move = "move" if you_form else "moves"
+                lines.append(f"{actor} {verb_move} the {event.item} to the {event.to_container}.")
+
+            elif event.event_type == 'leave':
+                verb_leave = "leave" if you_form else "leaves"
+                lines.append(f"{actor} {verb_leave} the room.")
+                present.discard(event.character)
+                if event.character == character_name:
+                    # Stop narrating once the perspective person leaves
+                    perspective_present = False
+                    break
+
+        return " ".join(lines)
+    
+    def to_dict(self) -> dict:
+        """Convert scenario to dictionary for JSON serialization."""
+        return {
+            'round_num': self.round_num,
+            'whose_turn': self.whose_turn,
+            'who_answers': self.who_answers,
+            'question_container': self.question_container,
+            'events': [asdict(e) for e in self.events],
+            'present_initially': self.present_initially,
+            'epistemic_type': self.epistemic_type.value if self.epistemic_type else None,
+            'ask_constraint': self.ask_constraint.value if self.ask_constraint else None
+        }
+    
+    @staticmethod
+    def from_dict(data: dict) -> 'Scenario':
+        """Create scenario from dictionary."""
+        return Scenario(
+            round_num=data['round_num'],
+            whose_turn=data['whose_turn'],
+            who_answers=data['who_answers'],
+            question_container=data['question_container'],
+            events=[Event(**e) for e in data['events']],
+            present_initially=data['present_initially'],
+            epistemic_type=EpistemicType(data['epistemic_type']) if data.get('epistemic_type') else None,
+            ask_constraint=AskConstraintType(data['ask_constraint']) if data.get('ask_constraint') else None
+        )
+
+
+@dataclass
+class Action:
+    """Represents a player action."""
+    action_type: ActionType
+    target_char: Optional[str] = None
+    container: Optional[str] = None
+    contents: Optional[str] = None
+
+
+@dataclass
+class TurnRecord:
+    """Records what happened in a turn."""
+    round_num: int
+    character: str
+    scenario_desc: str
+    question: str
+    action: str
+    action_cost: float
+    answer_given: str
+    answer_correct: bool
+    answer_score: float
+    optimal_action: str
+    was_optimal: bool
+    blue_score_after: float
+    red_score_after: float
+    epistemic_type: Optional[str] = None
+    ask_constraint: Optional[str] = None
+
+
+class GameState:
+    """Manages the game state."""
+    
+    def __init__(self, scenarios: List[Scenario], turn_order: List[str]):
+        self.scenarios = scenarios
+        self.turn_order = turn_order
+        self.current_scenario_idx = 0
+        self.current_turn_idx = 0
+        self.scores = {Team.BLUE: 0.0, Team.RED: 0.0}
+        self.characters: Dict[str, Character] = {}
+        self.turn_records: List[TurnRecord] = []
+        self.game_over = False
+        self.winner = None
+        
+    def initialize_characters(self, live_player_name: str):
+        """Initialize all characters with their types and teams."""
+        if live_player_name == 'A':
+            self.characters = {
+                'A': Character('A', Team.BLUE, CharacterType.LIVE_PLAYER),
+                'B': Character('B', Team.BLUE, CharacterType.HONEST_TEAMMATE),
+                'C': Character('C', Team.RED, CharacterType.HONEST_OPPONENT),
+                'D': Character('D', Team.RED, CharacterType.DISHONEST_OPPONENT),
+                'N': Character('N', Team.NEUTRAL, CharacterType.NEUTRAL),
+            }
+    
+    def get_teammate(self, actor_name: str) -> Optional[str]:
+        """Get the teammate of the actor."""
+        actor = self.characters[actor_name]
+        for name, char in self.characters.items():
+            if name != actor_name and char.team == actor.team:
+                return name
+        return None
+    
+    def is_honest_to(self, speaker_name: str, listener_name: str) -> bool:
+        """Check if speaker is honest to listener."""
+        speaker = self.characters[speaker_name]
+        listener = self.characters[listener_name]
+        
+        if speaker.char_type == CharacterType.NEUTRAL:
+            return True
+        if speaker.char_type == CharacterType.HONEST_OPPONENT:
+            return True
+        return speaker.team == listener.team
+    
+    def trusts(self, listener_name: str, speaker_name: str) -> bool:
+        listener = self.characters[listener_name]
+        speaker = self.characters[speaker_name]
+
+        # Teammates always trust each other (including the live player)
+        if listener.team != Team.NEUTRAL and listener.team == speaker.team:
+            return True
+
+        # Neutral trusts everyone
+        if listener.char_type == CharacterType.NEUTRAL:
+            return True
+
+        # (Keep any remaining special cases you want)
+        if listener.char_type == CharacterType.HONEST_OPPONENT:
+            return True
+        if listener.char_type == CharacterType.HONEST_TEAMMATE:
+            return True
+        if listener.char_type == CharacterType.DISHONEST_OPPONENT:
+            return speaker.team == listener.team
+        if listener.char_type == CharacterType.DISHONEST_TEAMMATE:
+            return speaker.team == listener.team
+
+        return False
+        
+    def reset_scenario_knowledge(self):
+        """Reset all character knowledge for new scenario."""
+        for char in self.characters.values():
+            char.knowledge = {}
+            char.beliefs = {}
+    
+    def get_present_at_end(self, scenario: Scenario) -> Set[str]:
+        """Get who's present at the end of the scenario."""
+        present = set(scenario.present_initially)
+        for event in scenario.events:
+            if event.event_type == 'leave':
+                present.discard(event.character)
+        return present
+    
+    def process_scenario_events(self, scenario: Scenario):
+        """Process scenario events to determine what each character knows."""
+        self.reset_scenario_knowledge()
+        
+        present = set(scenario.present_initially)
+        container_contents = {'bag': None, 'box': None}
+        
+        for event in scenario.events:
+            if event.event_type == 'put':
+                container_contents[event.container] = event.item
+                for char_name in present:
+                    self.characters[char_name].update_knowledge(event.container, event.item)
+                    
+            elif event.event_type == 'move':
+                container_contents[event.to_container] = event.item
+                container_contents[event.from_container] = None
+                for char_name in present:
+                    self.characters[char_name].update_knowledge(event.to_container, event.item)
+                    self.characters[char_name].update_knowledge(event.from_container, None)
+                        
+            elif event.event_type == 'leave':
+                present.discard(event.character)
+        
+        return container_contents
+    
+    def execute_npc_action(self, actor_name: str, scenario: Scenario, true_contents: Dict[str, str]) -> Action:
+        """Execute NPC action based on game rules - completely determined."""
+        container = scenario.question_container
+        truth = true_contents[container]
+        target = scenario.who_answers
+        
+        # Tell teammate truth scenarios
+        if scenario.epistemic_type in [EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+                                         EpistemicType.TEAMMATE_HAS_NO_BELIEF]:
+            return Action(ActionType.TELL, target, container, truth)
+        
+        # Pass scenarios
+        if scenario.epistemic_type in [EpistemicType.OPPONENT_HAS_FALSE_BELIEF]:
+            return Action(ActionType.PASS)
+        
+        if scenario.epistemic_type in [EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY,
+                                         EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY]:
+            return Action(ActionType.PASS)
+        
+        if scenario.epistemic_type in [EpistemicType.TEAMMATE_HAS_TRUE_BELIEF]:
+            return Action(ActionType.PASS)
+        
+        # Tell opponent scenario - tell lie only if actor is dishonest to target
+        if scenario.epistemic_type == EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+            if self.characters[actor_name].char_type in [CharacterType.HONEST_OPPONENT, CharacterType.HONEST_TEAMMATE]:
+                return Action(ActionType.PASS)
+            else:
+                possible_lies = ['apple', 'ball', 'banana', 'brick', 'stapler', 'orange']
+                lie = next((item for item in possible_lies if item != truth), 'nothing')
+                return Action(ActionType.TELL, target, container, lie)
+        
+        # Ask scenarios: ask based on who's present
+        if scenario.epistemic_type in [EpistemicType.PLAYER_HAS_UNCERTAINTY,
+                                         EpistemicType.PLAYER_HAS_NO_BELIEF]:
+            present = self.get_present_at_end(scenario)
+            present.discard(actor_name)
+            
+            # Preference: teammate -> neutral -> opponent (if trusts opponents)
+            teammate = self.get_teammate(actor_name)
+            if teammate and teammate in present:
+                return Action(ActionType.ASK, teammate, container)
+            
+            if 'N' in present:
+                return Action(ActionType.ASK, 'N', container)
+            
+            # Ask opponent only if actor trusts opponents
+            actor = self.characters[actor_name]
+            actor_trusts_opponents = actor.char_type in [CharacterType.HONEST_TEAMMATE, 
+                                                         CharacterType.HONEST_OPPONENT]
+            if actor_trusts_opponents:
+                # Choose a random eligible opponent from those present
+                eligible = [name for name in present
+                            if name != actor_name and self.characters[name].char_type in [
+                                CharacterType.HONEST_TEAMMATE,
+                                CharacterType.DISHONEST_TEAMMATE,
+                                CharacterType.HONEST_OPPONENT,
+                                CharacterType.DISHONEST_OPPONENT
+                            ]]
+                if eligible:
+                    return Action(ActionType.ASK, random.choice(eligible), container)
+            
+            return Action(ActionType.PASS)
+        
+        return Action(ActionType.PASS)
+    
+    def is_action_optimal(self, action_str: str, scenario: Scenario, true_contents: Dict[str, str]) -> bool:
+        """Check if live player's action is optimal."""
+        action = self.parse_action(action_str)
+        if not action:
+            return False
+        
+        # For Tell teammate truth scenarios
+        if scenario.epistemic_type in [EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+                                         EpistemicType.TEAMMATE_HAS_NO_BELIEF]:
+            truth = true_contents[scenario.question_container]
+            return (action.action_type == ActionType.TELL and
+                   action.target_char == scenario.who_answers and
+                   action.container == scenario.question_container and
+                   action.contents == truth)
+        
+        # For Tell opponent with uncertainty
+        if scenario.epistemic_type == EpistemicType.HONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY:
+            truth = true_contents[scenario.question_container]
+            if action.action_type != ActionType.TELL:
+                return False
+            if action.target_char != scenario.who_answers or action.container != scenario.question_container:
+                return False
+            return action.contents != truth
+        
+        # For Ask scenarios
+        if scenario.epistemic_type in [EpistemicType.PLAYER_HAS_UNCERTAINTY,
+                                         EpistemicType.PLAYER_HAS_NO_BELIEF]:
+            if scenario.ask_constraint == AskConstraintType.TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE:
+                return action.action_type == ActionType.PASS
+            
+            if action.action_type == ActionType.TELL or action.container != scenario.question_container:
+                return False
+            
+            present = self.get_present_at_end(scenario)
+            present.discard(scenario.whose_turn)
+            
+            if action.target_char not in present:
+                return False
+            
+            if scenario.ask_constraint == AskConstraintType.NO_CONSTRAINT:
+                return self.characters[action.target_char].char_type in [CharacterType.HONEST_TEAMMATE, CharacterType.DISHONEST_TEAMMATE]
+            elif scenario.ask_constraint == AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE:
+                return self.characters[action.target_char].char_type in [CharacterType.NEUTRAL]
+            elif scenario.ask_constraint == AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE:
+                return self.characters[action.target_char].char_type in [CharacterType.HONEST_OPPONENT]
+            else: 
+                return False
+        
+        # For Pass scenarios
+        if scenario.epistemic_type in [EpistemicType.TEAMMATE_HAS_TRUE_BELIEF,
+                                         EpistemicType.OPPONENT_HAS_FALSE_BELIEF,
+                                         EpistemicType.OPPONENT_HAS_TRUE_BELIEF_WITH_CERTAINTY,
+                                         EpistemicType.DISHONEST_OPPONENT_HAS_TRUE_BELIEF_WITH_UNCERTAINTY]:
+            return action.action_type == ActionType.PASS
+        
+        return False
+    
+    def get_current_scenario(self) -> Optional[Scenario]:
+        """Get the current scenario."""
+        if self.current_scenario_idx >= len(self.scenarios):
+            return None
+        return self.scenarios[self.current_scenario_idx]
+    
+    def get_current_turn_character(self) -> Optional[str]:
+        """Get whose turn it is."""
+        if self.current_turn_idx >= len(self.turn_order):
+            return None
+        return self.turn_order[self.current_turn_idx]
+    
+    def parse_action(self, action_str: str) -> Optional[Action]:
+        """Parse action string into Action object."""
+        action_str = action_str.strip()
+        
+        if action_str.lower() == 'pass':
+            return Action(ActionType.PASS)
+        
+        ask_match = re.match(r'Ask\(([A-DN]),\s*(bag|box)\)', action_str, re.IGNORECASE)
+        if ask_match:
+            return Action(ActionType.ASK, ask_match.group(1).upper(), ask_match.group(2).lower())
+        
+        tell_match = re.match(r'Tell\(([A-DN]),\s*(bag|box),\s*(\w+)\)', action_str, re.IGNORECASE)
+        if tell_match:
+            return Action(ActionType.TELL, tell_match.group(1).upper(), 
+                         tell_match.group(2).lower(), tell_match.group(3).lower())
+        
+        return None
+    
+    def execute_action(self, actor_name: str, action: Action, true_contents: Dict[str, str]) -> Tuple[float, str]:
+        """Execute an action and return the score change and description."""
+        score_delta = 0.0
+        desc = ""
+        
+        if action.action_type == ActionType.PASS:
+            desc = "Pass"
+            
+        elif action.action_type == ActionType.ASK:
+            score_delta -= 0.5
+            target = self.characters[action.target_char]
+            container = action.container
+
+            # What the target says:
+            # - Honest: report what they believe (what they observed).
+            # - Dishonest: intentionally say something different from their belief.
+            if target.char_type in [CharacterType.DISHONEST_TEAMMATE, CharacterType.DISHONEST_OPPONENT]:
+                believed = target.get_belief(container)
+                options = ['apple', 'ball', 'banana', 'brick', 'stapler', 'orange']
+                # Pick an item different from what they believe; if they believe nothing, pick any item.
+                wrong = next((x for x in options if x != (believed or 'nothing')), options[0])
+                answer = wrong
+            else:
+                answer = target.get_belief(container)
+
+            # Asking always updates the asker’s belief with whatever was answered.
+            self.characters[actor_name].receive_info(container, answer, target, True)
+
+            desc = f"Ask({action.target_char}, {container})"
+            
+        elif action.action_type == ActionType.TELL:
+            score_delta -= 0.5
+            target_name = action.target_char
+            
+            if self.trusts(target_name, actor_name):
+                self.characters[target_name].receive_info(action.container, action.contents,
+                                                         self.characters[actor_name], True)
+            
+            desc = f"Tell({action.target_char}, {action.container}, {action.contents})"
+        
+        return score_delta, desc
+    
+    def resolve_answer_phase(self, scenario: Scenario, true_contents: Dict[str, str]) -> Tuple[str, bool, float]:
+        """Resolve the answer phase and return answer, correctness, and score change."""
+        answerer = self.characters[scenario.who_answers]
+        container = scenario.question_container
+        
+        belief = answerer.get_belief(container)
+        truth = true_contents[container]
+        
+        is_correct = (belief == truth)
+        
+        if is_correct:
+            return belief if belief else 'nothing', True, 1.0
+        else:
+            return belief if belief else 'nothing', False, 0.0
+    
+    def check_game_over(self):
+        """Check if game is over."""
+        if self.scores[Team.BLUE] >= WINNING_SCORE:
+            self.game_over = True
+            self.winner = Team.BLUE
+        elif self.scores[Team.RED] >= WINNING_SCORE:
+            self.game_over = True
+            self.winner = Team.RED
+        elif self.current_scenario_idx >= len(self.scenarios):
+            self.game_over = True
+            if self.scores[Team.BLUE] > self.scores[Team.RED]:
+                self.winner = Team.BLUE
+            elif self.scores[Team.RED] > self.scores[Team.BLUE]:
+                self.winner = Team.RED
+            else:
+                self.winner = None
+    
+    def advance_turn(self):
+        """Move to next turn."""
+        self.current_scenario_idx += 1
+        self.current_turn_idx += 1
+        if self.current_turn_idx >= len(self.turn_order):
+            self.current_turn_idx = 0
+
+
+def load_scenarios(filename: str) -> List[Scenario]:
+    """Load scenarios from JSON file."""
+    with open(filename, 'r') as f:
+        data = json.load(f)
+    return [Scenario.from_dict(s) for s in data]
+
+
+def save_scenarios(scenarios: List[Scenario], filename: str):
+    """Save scenarios to JSON file."""
+    with open(filename, 'w') as f:
+        json.dump([s.to_dict() for s in scenarios], f, indent=2)
+
+
+def save_game_results(turn_records: List[TurnRecord], filename: str):
+    """Save game results to JSON file."""
+    with open(filename, 'w') as f:
+        json.dump([asdict(r) for r in turn_records], f, indent=2)
+
+
+def create_game(filename=None) -> GameState:
+    if filename is None:
+        scenarios = get_default_scenarios()
+        save_scenarios(scenarios, 'scenarios.json')
+        print("Created scenarios.json with default scenarios")
+    else:
+        try:
+            scenarios = load_scenarios(filename)
+        except FileNotFoundError:
+            # If file doesn't exist, create default scenarios and save them
+            scenarios = get_default_scenarios()
+            save_scenarios(scenarios, 'scenarios.json')
+            print("Scenario file not found. Created scenarios.json with default scenarios")
+    
+    turn_order = ['A', 'D', 'B', 'C']
+    
+    game = GameState(scenarios, turn_order)
+    game.initialize_characters('A')
+    
+    return game
+
+
+def get_default_scenarios() -> List[Scenario]:
+    """Get the default 12 scenarios."""
+    return [
+        # Round 1, Live Player turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=1,
+            whose_turn='A',
+            who_answers='B',
+            question_container='bag',
+            present_initially=['A', 'B', 'C', 'D', 'N'],
+            events=[
+                Event('put', 'B', 'bag', 'ball'),
+                Event('leave', 'B'),
+                Event('move', 'C', to_container='box', item='ball', from_container='bag'),
+                Event('put', 'C', 'bag', 'apple'),
+                Event('leave', 'C'),
+            ]
+        ),
+        # Round 1, D turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=1,
+            whose_turn='D',
+            who_answers='C',
+            question_container='bag',
+            present_initially=['D', 'A', 'B', 'C', 'N'],
+            events=[
+                Event('put', 'C', 'bag', 'ball'),
+                Event('leave', 'C'),
+                Event('move', 'B', to_container='box', item='ball', from_container='bag'),
+                Event('put', 'B', 'bag', 'apple'),
+                Event('leave', 'B'),
+            ]
+        ),
+        # Round 1, B turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE,
+            round_num=1,
+            whose_turn='B',
+            who_answers='B',
+            question_container='bag',
+            present_initially=['B', 'A', 'C', 'D', 'N'],
+            events=[
+                Event('put', 'B', 'bag', 'ball'),
+                Event('leave', 'B'),
+                Event('leave', 'A'),
+                Event('leave', 'D'),
+            ]
+        ),
+        # Round 1, C turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE,
+            round_num=1,
+            whose_turn='C',
+            who_answers='C',
+            question_container='bag',
+            present_initially=['C', 'N', 'A', 'B'],
+            events=[
+                Event('put', 'N', 'bag', 'ball'),
+                Event('leave', 'N'),
+                Event('leave', 'C'),
+                Event('leave', 'A'),
+            ]
+        ),
+        # Round 2, Live Player turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_TRUE_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=2,
+            whose_turn='A',
+            who_answers='B',
+            question_container='box',
+            present_initially=['A', 'B', 'C', 'D', 'N'],
+            events=[
+                Event('put', 'B', 'box', 'orange'),
+                Event('leave', 'B'),
+                Event('leave', 'D'),
+            ]
+        ),
+        # Round 2, D turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=2,
+            whose_turn='D',
+            who_answers='C',
+            question_container='box',
+            present_initially=['D', 'A', 'B', 'C', 'N'],
+            events=[
+                Event('put', 'N', 'box', 'ball'),
+                Event('leave', 'C'),
+                Event('move', 'N', to_container='bag', item='ball', from_container='box'),
+                Event('put', 'N', 'box', 'banana'),
+                Event('leave', 'B'),
+            ]
+        ),
+        # Round 2, B turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_AND_NEUTRAL_LACK_KNOWLEDGE,
+            round_num=2,
+            whose_turn='B',
+            who_answers='B',
+            question_container='bag',
+            present_initially=['B', 'A', 'C', 'D', 'N'],
+            events=[
+                Event('put', 'B', 'bag', 'ball'),
+                Event('leave', 'B'),
+                Event('leave', 'A'),
+                Event('leave', 'D'),
+                Event('leave', 'N'),
+            ]
+        ),
+        # Round 2, C turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE,
+            round_num=2,
+            whose_turn='C',
+            who_answers='C',
+            question_container='bag',
+            present_initially=['C', 'N', 'A', 'B'],
+            events=[
+                Event('put', 'N', 'bag', 'ball'),
+                Event('leave', 'A'),
+                Event('leave', 'C'),
+                Event('leave', 'B'),
+            ]
+        ),
+        # Round 3, Live Player turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_NO_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=3,
+            whose_turn='A',
+            who_answers='B',
+            question_container='bag',
+            present_initially=['A', 'B', 'C', 'D', 'N'],
+            events=[
+                Event('leave', 'B'),
+                Event('put', 'D', 'bag', 'stapler'),
+                Event('leave', 'D'),
+                Event('put', 'C', 'box', 'brick'),
+            ]
+        ),
+        # Round 3, D turn
+        Scenario(
+            epistemic_type=EpistemicType.TEAMMATE_HAS_FALSE_BELIEF,
+            ask_constraint=AskConstraintType.NO_CONSTRAINT,
+            round_num=3,
+            whose_turn='D',
+            who_answers='C',
+            question_container='bag',
+            present_initially=['D', 'A', 'B', 'C', 'N'],
+            events=[
+                Event('put', 'N', 'box', 'ball'),
+                Event('leave', 'C'),
+                Event('move', 'N', to_container='bag', item='ball', from_container='box'),
+                Event('put', 'N', 'box', 'banana'),
+                Event('leave', 'B'),
+            ]
+        ),
+        # Round 3, B turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_NEUTRAL_AND_HONEST_OPPONENT_LACK_KNOWLEDGE,
+            round_num=3,
+            whose_turn='B',
+            who_answers='B',
+            question_container='bag',
+            present_initially=['B', 'A', 'C', 'D', 'N'],
+            events=[
+                Event('put', 'B', 'bag', 'ball'),
+                Event('leave', 'B'),
+                Event('leave', 'A'),
+                Event('leave', 'C'),
+                Event('leave', 'N'),
+            ]
+        ),
+        # Round 3, C turn
+        Scenario(
+            epistemic_type=EpistemicType.PLAYER_HAS_UNCERTAINTY,
+            ask_constraint=AskConstraintType.TEAMMATE_LACKS_KNOWLEDGE,
+            round_num=3,
+            whose_turn='C',
+            who_answers='C',
+            question_container='bag',
+            present_initially=['C', 'N', 'A', 'B'],
+            events=[
+                Event('put', 'N', 'bag', 'stapler'),
+                Event('leave', 'A'),
+                Event('leave', 'C'),
+                Event('leave', 'B'),
+            ]
+        ),
+    ]
+
+
+def play_game_cli(scenario_file: str = None, human_player: bool = True):
+    """Play the game in CLI mode."""
+    game = create_game(scenario_file)
+    global WINNING_SCORE
+    WINNING_SCORE = max(WINNING_SCORE, int(len(game.scenarios)/len(game.turn_order)) + 4)
+    
+    print("=" * 70)
+    print(GAME_SETUP.format(WINNING_SCORE=WINNING_SCORE))
+    print("=" * 70)
+    
+    turn_count = 0
+
+    while not game.game_over and game.get_current_scenario():
+        scenario = game.get_current_scenario()
+        turn_char = game.get_current_turn_character()
+        
+        if not turn_char:
+            break
+        
+        true_contents = game.process_scenario_events(scenario)
+        
+        print("\n***********************************")
+        print(f"Score: Blue={game.scores[Team.BLUE]}, Red={game.scores[Team.RED]}")
+        if turn_count == 0:
+            print("Here's the first scenario:")
+        else:
+            print(f"Here's scenario {turn_count + 1}:")
+        
+        turn_name = "Your" if turn_char == 'A' else f"{turn_char}'s"
+        print(f"{turn_name} turn:")
+        
+        scenario_desc = scenario.get_description_for(turn_char, game.characters)
+        answerer = "you" if scenario.who_answers == turn_char else scenario.who_answers
+        question_desc = f"I am going to ask {answerer} what is in the {scenario.question_container}."
+        
+        print("-----------------------------------------------")
+        print(scenario_desc)
+        print("----------------------------------------------")
+        print(question_desc)
+        print("Respond ONLY with your action, and no other text.")
+        
+        action = None
+        action_str = ""
+        if turn_char == 'A':
+            while not action:
+                action_str = input(f"Your action (Ask(Player, Container), Tell(Player, Container, Contents), or Pass): ")
+                action = game.parse_action(action_str)
+                if not action:
+                    print("Invalid action format. Try again.")
+        else:
+            action = game.execute_npc_action(turn_char, scenario, true_contents)
+            if action.action_type == ActionType.ASK:
+                action_str = f"Ask({action.target_char}, {action.container})"
+            elif action.action_type == ActionType.TELL:
+                action_str = f"Tell({action.target_char}, {action.container}, {action.contents})"
+            else:
+                action_str = "Pass"
+        
+        score_delta, action_desc = game.execute_action(turn_char, action, true_contents)
+                
+        print(f"\nAction: {action_str}")
+        
+        # Answer phase
+        answer_given, is_correct, answer_score = game.resolve_answer_phase(scenario, true_contents)
+        
+        # Display answer
+        print(f"{scenario.who_answers} answers: {answer_given}")
+        if is_correct:
+            print(f"Correct! The {scenario.question_container} contains {answer_given}.")
+        else:
+            print(f"Incorrect. The {scenario.question_container} actually contains {true_contents[scenario.question_container]}.")
+        
+        # Compute per-team deltas
+        blue_delta = 0.0
+        red_delta = 0.0
+
+        # Action cost applies to acting player's team
+        if turn_char in ['A', 'B']:
+            blue_delta += score_delta
+        else:
+            red_delta += score_delta
+
+        # Answer points apply only to the answerer's team (if correct)
+        if is_correct:
+            if scenario.who_answers in ['A', 'B']:
+                blue_delta += answer_score
+            else:
+                red_delta += answer_score
+
+        # Apply deltas to the scoreboard
+        game.scores[Team.BLUE] += blue_delta
+        game.scores[Team.RED] += red_delta
+
+        # Outcome message shows exact deltas for both teams
+        def fmt_delta(x: float) -> str:
+            sign = '+' if x >= 0 else '-'
+            return f"{sign}{abs(x)}"
+        print(f"\nOutcome: Blue {fmt_delta(blue_delta)}, Red {fmt_delta(red_delta)}")
+
+        # Check if action was optimal (only for live player)
+        was_optimal = False
+        expected_action_str = ""
+        if turn_char == 'A':
+            was_optimal = game.is_action_optimal(action_str, scenario, true_contents)
+            expected_action_obj = game.execute_npc_action(turn_char, scenario, true_contents)
+            if expected_action_obj.action_type == ActionType.PASS:
+                expected_action_str = "Pass"
+            elif expected_action_obj.action_type == ActionType.ASK:
+                expected_action_str = f"Ask({expected_action_obj.target_char}, {expected_action_obj.container})"
+            elif expected_action_obj.action_type == ActionType.TELL:
+                expected_action_str = f"Tell({expected_action_obj.target_char}, {expected_action_obj.container}, {expected_action_obj.contents})"
+        else:
+            was_optimal = True
+            expected_action_str = action_str
+        
+        turn_record = TurnRecord(
+            round_num=scenario.round_num,
+            character=turn_char,
+            scenario_desc=scenario_desc,
+            question=question_desc,
+            action=action_str,
+            action_cost=abs(score_delta),
+            answer_given=answer_given,
+            answer_correct=is_correct,
+            answer_score=answer_score,
+            optimal_action=expected_action_str,
+            was_optimal=was_optimal,
+            blue_score_after=game.scores[Team.BLUE],
+            red_score_after=game.scores[Team.RED],
+            epistemic_type=scenario.epistemic_type.value if scenario.epistemic_type else None,
+            ask_constraint=scenario.ask_constraint.value if scenario.ask_constraint else None
+        )
+        game.turn_records.append(turn_record)
+        
+        # Wait for user to press space (if human player)
+        if human_player:
+            input("\n[Press Enter to continue]")
+        
+        game.check_game_over()
+        game.advance_turn()
+        turn_count += 1
+
+    # Game over
+    print("\n" + "=" * 70)
+    print("GAME OVER")
+    print(f"Final Score: Blue {game.scores[Team.BLUE]} - Red {game.scores[Team.RED]}")
+    game.winner = "Blue" if game.scores[Team.BLUE] > game.scores[Team.RED] else "Red" if game.scores[Team.RED] > game.scores[Team.BLUE] else None
+    if game.winner:
+        print(f"Winner: {game.winner.value} team")
+    elif game.winner is None:
+        print("It's a tie!")
+    print("=" * 70)
+    """
+    # Show turn records
+    print("\n" + "=" * 70)
+    print("TURN RECORD")
+    print("=" * 70)
+    for record in game.turn_records:
+        print(f"\nRound {record.round_num} - {record.character}'s turn")
+        print(f"Ontological Type: {record.epistemic_type}")
+        print(f"Ask Constraint: {record.ask_constraint}")
+        print(f"Action: {record.action}")
+        if record.character == 'A':
+            print(f"Expected: {record.optimal_action}")
+            print(f"Was Expected: {'YES' if record.was_optimal else 'NO'}")
+        print(f"Answer Given: {record.answer_given}")
+        print(f"Answer Correct: {'YES' if record.answer_correct else 'NO'}")
+        print(f"Score After: Blue {record.blue_score_after} - Red {record.red_score_after}")
+    """ 
+    # Save results
+    save_game_results(game.turn_records, 'game_results.json')
+    print("\nGame results saved to game_results.json")
+    
+    return game
+
+
+if __name__ == "__main__":
+    play_game_cli(scenario_file = 'scenarios_generated2.json', human_player=True)

tom_web_app.py

@@ -0,0 +1,319 @@
+# web_app.py
+# Minimal Flask wrapper around your tom_test.py with "press Enter" behavior
+# identical to CLI. No Gradio, no shadow DOM. Focus is always in one input.
+
+from __future__ import annotations
+import os
+import tempfile
+import uuid
+from typing import Dict, Any, Optional, Tuple
+
+from flask import Flask, render_template, request, jsonify, make_response
+
+import tom_test as rg  # your existing game code (unchanged)
+
+app = Flask(__name__)
+
+# In-memory sessions (simple and fast for local use)
+SESSIONS: Dict[str, "Session"] = {}
+
+CLI_ACTION_PROMPT = "Your action (Ask(Player, Container), Tell(Player, Container, Contents), or Pass):"
+PRESS_ENTER = "[Press Enter to continue]"
+
+def fmt_delta(x: float) -> str:
+    return f"{'+' if x >= 0 else '-'}{abs(x)}"
+
+def pick_scenarios_file() -> Optional[str]:
+    if os.path.exists("scenarios_generated2.json"):
+        return "scenarios_generated2.json"
+    if os.path.exists("scenarios.json"):
+        return "scenarios.json"
+    return None
+
+def initial_transcript() -> str:
+    # Instructions header exactly like CLI
+    path = pick_scenarios_file()
+    try:
+        scenarios = rg.load_scenarios(path) if path else rg.get_default_scenarios()
+    except Exception:
+        scenarios = rg.get_default_scenarios()
+    win_score = max(rg.WINNING_SCORE, int(len(scenarios) / 4) + 4)
+    return "=" * 70 + "\n" + rg.GAME_SETUP.format(WINNING_SCORE=win_score) + "\n" + "=" * 70 + "\n"
+
+def present_scenario(state: Dict[str, Any], transcript: str) -> Tuple[str, Dict[str, Any], bool, bool]:
+    game = state["game"]
+    scenario = game.get_current_scenario()
+    turn_char = game.get_current_turn_character()
+    if not scenario or not turn_char:
+        transcript = finalize_game(transcript, state)
+        return transcript, state, False, True
+
+    true_contents = game.process_scenario_events(scenario)
+    state["true_contents"] = true_contents
+
+    turn_count = state["turn_count"]
+    transcript += "\n***********************************\n"
+    transcript += f"Score: Blue={game.scores[rg.Team.BLUE]}, Red={game.scores[rg.Team.RED]}\n"
+    transcript += ("Here's the first scenario:\n" if turn_count == 0 else f"Here's scenario {turn_count + 1}:\n")
+
+    turn_name = "Your" if turn_char == 'A' else f"{turn_char}'s"
+    transcript += f"{turn_name} turn:\n"
+
+    scenario_desc = scenario.get_description_for(turn_char, game.characters)
+    answerer = "you" if scenario.who_answers == turn_char else scenario.who_answers
+    question_desc = f"I am going to ask {answerer} what is in the {scenario.question_container}."
+
+    transcript += "-----------------------------------------------\n"
+    transcript += scenario_desc + "\n"
+    transcript += "----------------------------------------------\n"
+    transcript += question_desc + "\n"
+    transcript += "Respond ONLY with your action, and no other text.\n"
+
+    state["last_scenario_desc"] = scenario_desc
+    state["last_question_desc"] = question_desc
+    return transcript, state, (turn_char == 'A'), False
+
+def resolve_turn(state: Dict[str, Any], actor_name: str, action: rg.Action, transcript: str) -> Tuple[str, Dict[str, Any]]:
+    game = state["game"]
+    scenario = game.get_current_scenario()
+    true_contents = state["true_contents"]
+
+    score_delta, _ = game.execute_action(actor_name, action, true_contents)
+
+    if action.action_type == rg.ActionType.ASK:
+        action_str = f"Ask({action.target_char}, {action.container})"
+    elif action.action_type == rg.ActionType.TELL:
+        action_str = f"Tell({action.target_char}, {action.container}, {action.contents})"
+    else:
+        action_str = "Pass"
+    transcript += f"\nAction: {action_str}\n"
+
+    answer_given, is_correct, answer_score = game.resolve_answer_phase(scenario, true_contents)
+    transcript += f"{scenario.who_answers} answers: {answer_given}\n"
+    if is_correct:
+        transcript += f"Correct! The {scenario.question_container} contains {answer_given}.\n"
+    else:
+        transcript += f"Incorrect. The {scenario.question_container} actually contains {true_contents[scenario.question_container]}.\n"
+
+    blue_delta = 0.0
+    red_delta = 0.0
+    if actor_name in ['A', 'B']:
+        blue_delta += score_delta
+    else:
+        red_delta += score_delta
+    if is_correct:
+        if scenario.who_answers in ['A', 'B']:
+            blue_delta += answer_score
+        else:
+            red_delta += answer_score
+
+    game.scores[rg.Team.BLUE] += blue_delta
+    game.scores[rg.Team.RED] += red_delta
+    transcript += f"\nOutcome: Blue {fmt_delta(blue_delta)}, Red {fmt_delta(red_delta)}\n"
+
+    # Record, exactly like CLI
+    if actor_name == 'A':
+        was_optimal = game.is_action_optimal(action_str, scenario, true_contents)
+        exp = game.execute_npc_action(actor_name, scenario, true_contents)
+        if exp.action_type == rg.ActionType.PASS:
+            expected_action_str = "Pass"
+        elif exp.action_type == rg.ActionType.ASK:
+            expected_action_str = f"Ask({exp.target_char}, {exp.container})"
+        else:
+            expected_action_str = f"Tell({exp.target_char}, {exp.container}, {exp.contents})"
+    else:
+        was_optimal = True
+        expected_action_str = action_str
+
+    game.turn_records.append(rg.TurnRecord(
+        round_num=scenario.round_num,
+        character=actor_name,
+        scenario_desc=state.get("last_scenario_desc", ""),
+        question=state.get("last_question_desc", ""),
+        action=action_str,
+        action_cost=abs(score_delta),
+        answer_given=answer_given,
+        answer_correct=is_correct,
+        answer_score=answer_score,
+        optimal_action=expected_action_str,
+        was_optimal=was_optimal,
+        blue_score_after=game.scores[rg.Team.BLUE],
+        red_score_after=game.scores[rg.Team.RED],
+        epistemic_type=scenario.epistemic_type.value if scenario.epistemic_type else None,
+        ask_constraint=scenario.ask_constraint.value if scenario.ask_constraint else None
+    ))
+    return transcript, state
+
+def finalize_game(transcript: str, state: Dict[str, Any]) -> str:
+    game = state["game"]
+    transcript += "\n" + "=" * 70 + "\n"
+    transcript += "GAME OVER\n"
+    transcript += f"Final Score: Blue {game.scores[rg.Team.BLUE]} - Red {game.scores[rg.Team.RED]}\n"
+    if game.scores[rg.Team.BLUE] > game.scores[rg.Team.RED]:
+        winner = rg.Team.BLUE
+    elif game.scores[rg.Team.RED] > game.scores[rg.Team.BLUE]:
+        winner = rg.Team.RED
+    else:
+        winner = None
+    transcript += (f"Winner: {winner.value} team\n" if winner else "It's a tie!\n")
+    transcript += "=" * 70 + "\n"
+
+    tmpdir = tempfile.mkdtemp()
+    out_path = os.path.join(tmpdir, "game_results.json")
+    rg.save_game_results(game.turn_records, out_path)
+    state["results_path"] = out_path
+    transcript += "\nGame results saved to game_results.json (download below)\n"
+    return transcript
+
+class Session:
+    def __init__(self):
+        self.transcript = initial_transcript()
+        self.state: Optional[Dict[str, Any]] = None
+        self.mode: str = "awaiting_start"  # awaiting_start | awaiting_action | awaiting_continue | over
+        self.primary_label = "Start"
+        self.placeholder = "[Press Enter to start]"
+
+    def start_or_continue(self):
+        if self.state is None:
+            # Start game
+            path = pick_scenarios_file()
+            game = rg.create_game(path)
+            rg.WINNING_SCORE = max(rg.WINNING_SCORE, int(len(game.scenarios) / len(game.turn_order)) + 4)
+            self.state = {"game": game, "turn_count": 0, "results_path": None}
+            self.transcript, self.state, is_player, end_now = present_scenario(self.state, self.transcript)
+            if end_now:
+                self.transcript = finalize_game(self.transcript, self.state)
+                self.mode = "over"
+                self.primary_label = "Start"
+                self.placeholder = "Game over"
+                return
+            if is_player:
+                self.mode = "awaiting_action"
+                self.primary_label = "Continue"
+                self.placeholder = CLI_ACTION_PROMPT
+                return
+            # NPC acts then pause
+            npc = game.execute_npc_action(game.get_current_turn_character(), game.get_current_scenario(), self.state["true_contents"])
+            self.transcript, self.state = resolve_turn(self.state, game.get_current_turn_character(), npc, self.transcript)
+            game.check_game_over(); game.advance_turn(); self.state["turn_count"] += 1
+            if game.game_over or not game.get_current_scenario():
+                self.transcript = finalize_game(self.transcript, self.state)
+                self.mode = "over"
+                self.primary_label = "Start"
+                self.placeholder = "Game over"
+                return
+            self.mode = "awaiting_continue"
+            self.primary_label = "Continue"
+            self.placeholder = PRESS_ENTER
+            self.transcript += f"\n{PRESS_ENTER}\n"
+            return
+
+        # Continue flow
+        if self.mode != "awaiting_continue":
+            return
+        game = self.state["game"]
+        self.transcript, self.state, is_player, end_now = present_scenario(self.state, self.transcript)
+        if end_now:
+            self.transcript = finalize_game(self.transcript, self.state)
+            self.mode = "over"
+            self.primary_label = "Start"
+            self.placeholder = "Game over"
+            return
+        if is_player:
+            self.mode = "awaiting_action"
+            self.primary_label = "Continue"
+            self.placeholder = CLI_ACTION_PROMPT
+            return
+        # NPC acts then pause
+        npc = game.execute_npc_action(game.get_current_turn_character(), game.get_current_scenario(), self.state["true_contents"])
+        self.transcript, self.state = resolve_turn(self.state, game.get_current_turn_character(), npc, self.transcript)
+        game.check_game_over(); game.advance_turn(); self.state["turn_count"] += 1
+        if game.game_over or not game.get_current_scenario():
+            self.transcript = finalize_game(self.transcript, self.state)
+            self.mode = "over"
+            self.primary_label = "Start"
+            self.placeholder = "Game over"
+            return
+        self.mode = "awaiting_continue"
+        self.primary_label = "Continue"
+        self.placeholder = PRESS_ENTER
+        self.transcript += f"\n{PRESS_ENTER}\n"
+
+    def submit_action(self, text: str):
+        if self.state is None or self.mode != "awaiting_action":
+            return
+        game = self.state["game"]
+        action = game.parse_action(text or "")
+        if not action:
+            self.transcript += "Invalid action format. Try again.\n"
+            self.placeholder = CLI_ACTION_PROMPT
+            return
+        turn_char = game.get_current_turn_character()
+        self.transcript, self.state = resolve_turn(self.state, turn_char, action, self.transcript)
+        game.check_game_over(); game.advance_turn(); self.state["turn_count"] += 1
+        if game.game_over or not game.get_current_scenario():
+            self.transcript = finalize_game(self.transcript, self.state)
+            self.mode = "over"
+            self.primary_label = "Start"
+            self.placeholder = "Game over"
+            return
+        self.mode = "awaiting_continue"
+        self.primary_label = "Continue"
+        self.placeholder = PRESS_ENTER
+        self.transcript += f"\n{PRESS_ENTER}\n"
+
+def get_session(resp=None) -> Tuple[str, Session, Any]:
+    sid = request.cookies.get("sid")
+    if not sid or sid not in SESSIONS:
+        sid = uuid.uuid4().hex
+        sess = Session()
+        SESSIONS[sid] = sess
+        if resp is None:
+            resp = make_response()
+        resp.set_cookie("sid", sid, httponly=True, samesite="Lax")
+    else:
+        sess = SESSIONS[sid]
+    return sid, sess, resp
+
+@app.get("/")
+def index():
+    resp = make_response(render_template("index.html"))
+    _, sess, resp = get_session(resp)
+    return resp
+
+@app.get("/state")
+def state():
+    _, sess, _ = get_session()
+    return jsonify({
+        "transcript": sess.transcript,
+        "mode": sess.mode,
+        "primary_label": sess.primary_label,
+        "placeholder": sess.placeholder
+    })
+
+@app.post("/primary")
+def primary():
+    _, sess, _ = get_session()
+    sess.start_or_continue()
+    return jsonify({
+        "transcript": sess.transcript,
+        "mode": sess.mode,
+        "primary_label": sess.primary_label,
+        "placeholder": sess.placeholder
+    })
+
+@app.post("/action")
+def action():
+    _, sess, _ = get_session()
+    data = request.get_json(force=True) or {}
+    text = (data.get("text") or "").strip()
+    sess.submit_action(text)
+    return jsonify({
+        "transcript": sess.transcript,
+        "mode": sess.mode,
+        "primary_label": sess.primary_label,
+        "placeholder": sess.placeholder
+    })
+
+if __name__ == "__main__":
+    app.run(debug=True)