Upload folder using huggingface_hub

README.md

@@ -1,6 +1,6 @@
 ---
-title: Kantbench Environment Server
-emoji: 🕹️
+title: KantBench Environment Server
+emoji: 🎮
 colorFrom: green
 colorTo: yellow
 sdk: docker
@@ -10,245 +10,85 @@ tags:
   - openenv
 ---
 
-# Kantbench Environment
+# KantBench: 90+ Game Theory Environments for LLM Training
 
-A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
+A comprehensive game theory environment for training and evaluating LLM strategic reasoning via OpenEnv. Supports GRPO/DPO training with the environment as a reward oracle.
 
-## Quick Start
-
-The simplest way to use the Kantbench environment is through the `KantbenchEnv` class:
-
-```python
-from KantBench import KantbenchAction, KantbenchEnv
-
-try:
-    # Create environment from Docker image
-    KantBenchenv = KantbenchEnv.from_docker_image("KantBench-env:latest")
-
-    # Reset
-    result = KantBenchenv.reset()
-    print(f"Reset: {result.observation.echoed_message}")
-
-    # Send multiple messages
-    messages = ["Hello, World!", "Testing echo", "Final message"]
-
-    for msg in messages:
-        result = KantBenchenv.step(KantbenchAction(message=msg))
-        print(f"Sent: '{msg}'")
-        print(f"  → Echoed: '{result.observation.echoed_message}'")
-        print(f"  → Length: {result.observation.message_length}")
-        print(f"  → Reward: {result.reward}")
-
-finally:
-    # Always clean up
-    KantBenchenv.close()
-```
-
-That's it! The `KantbenchEnv.from_docker_image()` method handles:
-- Starting the Docker container
-- Waiting for the server to be ready
-- Connecting to the environment
-- Container cleanup when you call `close()`
-
-## Building the Docker Image
-
-Before using the environment, you need to build the Docker image:
-
-```bash
-# From project root
-docker build -t KantBench-env:latest -f server/Dockerfile .
-```
-
-## Deploying to Hugging Face Spaces
+## Games (90+)
 
-You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
+| Category | Examples | Count |
+|---|---|---|
+| **Classic Matrix** | Prisoner's Dilemma, Stag Hunt, Hawk-Dove, Battle of the Sexes | 20+ |
+| **Economic/Market** | Cournot, Bertrand, Hotelling, Nash Demand, Double Auction | 23 |
+| **Information & Signaling** | Beer-Quiche, Spence Signaling, Bayesian Persuasion, Moral Hazard | 21 |
+| **Cooperative & Repeated** | Shapley Allocation, Stable Matching, Discounted PD, Stochastic PD | 23 |
+| **Auctions & Contests** | First-Price, Vickrey, All-Pay, Colonel Blotto, Tullock Contest | 10+ |
+| **Sequential** | Ultimatum, Trust, Centipede, Stackelberg, Dictator | 6 |
 
-```bash
-# From the environment directory (where openenv.yaml is located)
-openenv push
-
-# Or specify options
-openenv push --namespace my-org --private
-```
-
-The `openenv push` command will:
-1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
-2. Prepare a custom build for Hugging Face Docker space (enables web interface)
-3. Upload to Hugging Face (ensuring you're logged in)
-
-### Prerequisites
-
-- Authenticate with Hugging Face: The command will prompt for login if not already authenticated
-
-### Options
-
-- `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
-- `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
-- `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
-- `--private`: Deploy the space as private (default: public)
-
-### Examples
-
-```bash
-# Push to your personal namespace (defaults to username/env-name from openenv.yaml)
-openenv push
-
-# Push to a specific repository
-openenv push --repo-id my-org/my-env
-
-# Push with a custom base image
-openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
-
-# Push as a private space
-openenv push --private
-
-# Combine options
-openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
-```
+## Opponent Strategies (17)
 
-After deployment, your space will be available at:
-`https://huggingface.co/spaces/<repo-id>`
+`random`, `always_cooperate`, `always_defect`, `tit_for_tat`, `tit_for_two_tats`, `grudger`, `pavlov`, `suspicious_tit_for_tat`, `generous_tit_for_tat`, `adaptive`, `mixed`, `ultimatum_fair`, `ultimatum_low`, `trust_fair`, `trust_generous`, `public_goods_fair`, `public_goods_free_rider`
 
-The deployed space includes:
-- **Web Interface** at `/web` - Interactive UI for exploring the environment
-- **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
-- **Health Check** at `/health` - Container health monitoring
-- **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
-
-## Environment Details
-
-### Action
-**KantbenchAction**: Contains a single field
-- `message` (str) - The message to echo back
-
-### Observation
-**KantbenchObservation**: Contains the echo response and metadata
-- `echoed_message` (str) - The message echoed back
-- `message_length` (int) - Length of the message
-- `reward` (float) - Reward based on message length (length × 0.1)
-- `done` (bool) - Always False for echo environment
-- `metadata` (dict) - Additional info like step count
-
-### Reward
-The reward is calculated as: `message_length × 0.1`
-- "Hi" → reward: 0.2
-- "Hello, World!" → reward: 1.3
-- Empty message → reward: 0.0
-
-## Advanced Usage
-
-### Connecting to an Existing Server
-
-If you already have a Kantbench environment server running, you can connect directly:
+## Quick Start
 
 ```python
-from KantBench import KantbenchEnv
-
-# Connect to existing server
-KantBenchenv = KantbenchEnv(base_url="<ENV_HTTP_URL_HERE>")
-
-# Use as normal
-result = KantBenchenv.reset()
-result = KantBenchenv.step(KantbenchAction(message="Hello!"))
+from KantBench import KantBenchAction, KantBenchEnv
+
+with KantBenchEnv(base_url="https://openenv-community-kantbench.hf.space") as env:
+    # Reset with a specific game and opponent strategy
+    result = env.reset(game="prisoners_dilemma", strategy="tit_for_tat")
+    print(f"Game: {result.observation.game_name}")
+    print(f"Moves: {result.observation.available_moves}")
+
+    # Play rounds until done
+    while not result.done:
+        result = env.step(KantBenchAction(move="cooperate"))
+        print(f"Round {result.observation.round_number}: "
+              f"you={result.observation.your_move}, "
+              f"opp={result.observation.opponent_move}, "
+              f"payoff={result.observation.your_payoff}")
+
+    print(f"Final score: {result.observation.cumulative_score}")
 ```
 
-Note: When connecting to an existing server, `KantBenchenv.close()` will NOT stop the server.
-
-### Using the Context Manager
-
-The client supports context manager usage for automatic connection management:
+## Reset Parameters
 
 ```python
-from KantBench import KantbenchAction, KantbenchEnv
-
-# Connect with context manager (auto-connects and closes)
-with KantbenchEnv(base_url="http://localhost:8000") as env:
-    result = env.reset()
-    print(f"Reset: {result.observation.echoed_message}")
-    # Multiple steps with low latency
-    for msg in ["Hello", "World", "!"]:
-        result = env.step(KantbenchAction(message=msg))
-        print(f"Echoed: {result.observation.echoed_message}")
-```
+# Specific game and strategy
+result = env.reset(game="stag_hunt", strategy="grudger")
 
-The client uses WebSocket connections for:
-- **Lower latency**: No HTTP connection overhead per request
-- **Persistent session**: Server maintains your environment state
-- **Efficient for episodes**: Better for many sequential steps
-
-### Concurrent WebSocket Sessions
-
-The server supports multiple concurrent WebSocket connections. To enable this,
-modify `server/app.py` to use factory mode:
-
-```python
-# In server/app.py - use factory mode for concurrent sessions
-app = create_app(
-    KantbenchEnvironment,  # Pass class, not instance
-    KantbenchAction,
-    KantbenchObservation,
-    max_concurrent_envs=4,  # Allow 4 concurrent sessions
-)
+# Random game and strategy (default)
+result = env.reset()
 ```
 
-Then multiple clients can connect simultaneously:
+## API Endpoints
 
-```python
-from KantBench import KantbenchAction, KantbenchEnv
-from concurrent.futures import ThreadPoolExecutor
-
-def run_episode(client_id: int):
-    with KantbenchEnv(base_url="http://localhost:8000") as env:
-        result = env.reset()
-        for i in range(10):
-            result = env.step(KantbenchAction(message=f"Client {client_id}, step {i}"))
-        return client_id, result.observation.message_length
-
-# Run 4 episodes concurrently
-with ThreadPoolExecutor(max_workers=4) as executor:
-    results = list(executor.map(run_episode, range(4)))
-```
+- **Web Interface** at `/web` — Interactive UI for exploring the environment
+- **API Docs** at `/docs` — Full OpenAPI/Swagger interface
+- **Health Check** at `/health` — Container health monitoring
+- **WebSocket** at `/ws` — Persistent session endpoint
 
-## Development & Testing
-
-### Direct Environment Testing
+## Environment Details
 
-Test the environment logic directly without starting the HTTP server:
+### Action
 
-```bash
-# From the server directory
-python3 server/KantBench_environment.py
-```
+**KantBenchAction**: Single field
+- `move` (str) — Your move (e.g. `"cooperate"`, `"defect"`, `"hawk"`, `"produce_5"`)
 
-This verifies that:
-- Environment resets correctly
-- Step executes actions properly
-- State tracking works
-- Rewards are calculated correctly
+### Observation
 
-### Running Locally
+**KantBenchObservation**: Full round result and episode state
+- `game_name`, `game_description` — Current game info
+- `available_moves` — Valid moves for this game
+- `your_move`, `opponent_move` — Moves played this round
+- `your_payoff`, `opponent_payoff` — Payoffs this round
+- `cumulative_score` — Your total score
+- `round_number`, `max_rounds` — Episode progress
+- `opponent_strategy` — Opponent strategy name
+- `history` — Full round-by-round history
 
-Run the server locally for development:
+## Deployment
 
 ```bash
-uvicorn server.app:app --reload
-```
-
-## Project Structure
-
-```
-KantBench/
-├── .dockerignore         # Docker build exclusions
-├── __init__.py            # Module exports
-├── README.md              # This file
-├── openenv.yaml           # OpenEnv manifest
-├── pyproject.toml         # Project metadata and dependencies
-├── uv.lock                # Locked dependencies (generated)
-├── client.py              # KantbenchEnv client
-├── models.py              # Action and Observation models
-└── server/
-    ├── __init__.py        # Server module exports
-    ├── KantBench_environment.py  # Core environment logic
-    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
-    └── Dockerfile         # Container image definition
+python spaces/kant/deploy.py
 ```

__init__.py

@@ -1,16 +1,10 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
+"""KantBench Environment — 90+ game theory games for LLM training."""
 
-"""Kantbench Environment."""
-
-from .client import KantbenchEnv
-from .models import KantbenchAction, KantbenchObservation
+from .client import KantBenchEnv
+from .models import KantBenchAction, KantBenchObservation
 
 __all__ = [
-    "KantbenchAction",
-    "KantbenchObservation",
-    "KantbenchEnv",
+    "KantBenchAction",
+    "KantBenchObservation",
+    "KantBenchEnv",
 ]

client.py

@@ -1,10 +1,4 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Kantbench Environment Client."""
+"""KantBench Environment Client."""
 
 from typing import Dict
 
@@ -12,69 +6,54 @@ from openenv.core.client_types import StepResult
 from openenv.core.env_server.types import State
 from openenv.core import EnvClient
 
-from .models import KantbenchAction, KantbenchObservation
+from .models import KantBenchAction, KantBenchObservation
 
 
-class KantbenchEnv(
-    EnvClient[KantbenchAction, KantbenchObservation]
+class KantBenchEnv(
+    EnvClient[KantBenchAction, KantBenchObservation]
 ):
     """
-    Client for the Kantbench Environment.
+    Client for the KantBench game theory environment.
 
-    This client maintains a persistent WebSocket connection to the environment server,
-    enabling efficient multi-step interactions with lower latency.
-    Each client instance has its own dedicated environment session on the server.
+    Maintains a persistent WebSocket connection to the environment server.
+    Each client instance has its own dedicated environment session.
 
     Example:
-        >>> # Connect to a running server
-        >>> with KantbenchEnv(base_url="http://localhost:8000") as client:
+        >>> with KantBenchEnv(base_url="http://localhost:8000") as client:
         ...     result = client.reset()
-        ...     print(result.observation.echoed_message)
+        ...     print(result.observation.game_name)
+        ...     print(result.observation.available_moves)
         ...
-        ...     result = client.step(KantbenchAction(message="Hello!"))
-        ...     print(result.observation.echoed_message)
+        ...     result = client.step(KantBenchAction(move="cooperate"))
+        ...     print(result.observation.your_payoff)
 
-    Example with Docker:
-        >>> # Automatically start container and connect
-        >>> client = KantbenchEnv.from_docker_image("KantBench-env:latest")
-        >>> try:
+    Example with HF Space:
+        >>> with KantBenchEnv(base_url="https://openenv-community-kantbench.hf.space") as client:
         ...     result = client.reset()
-        ...     result = client.step(KantbenchAction(message="Test"))
-        ... finally:
-        ...     client.close()
+        ...     result = client.step(KantBenchAction(move="cooperate"))
     """
 
-    def _step_payload(self, action: KantbenchAction) -> Dict:
-        """
-        Convert KantbenchAction to JSON payload for step message.
-
-        Args:
-            action: KantbenchAction instance
-
-        Returns:
-            Dictionary representation suitable for JSON encoding
-        """
-        return {
-            "message": action.message,
-        }
-
-    def _parse_result(self, payload: Dict) -> StepResult[KantbenchObservation]:
-        """
-        Parse server response into StepResult[KantbenchObservation].
+    def _step_payload(self, action: KantBenchAction) -> Dict:
+        return {"move": action.move}
 
-        Args:
-            payload: JSON response data from server
-
-        Returns:
-            StepResult with KantbenchObservation
-        """
+    def _parse_result(self, payload: Dict) -> StepResult[KantBenchObservation]:
         obs_data = payload.get("observation", {})
-        observation = KantbenchObservation(
-            echoed_message=obs_data.get("echoed_message", ""),
-            message_length=obs_data.get("message_length", 0),
+        observation = KantBenchObservation(
+            game_name=obs_data.get("game_name", ""),
+            game_description=obs_data.get("game_description", ""),
+            available_moves=obs_data.get("available_moves", []),
+            your_move=obs_data.get("your_move", ""),
+            opponent_move=obs_data.get("opponent_move", ""),
+            your_payoff=obs_data.get("your_payoff", 0.0),
+            opponent_payoff=obs_data.get("opponent_payoff", 0.0),
+            cumulative_score=obs_data.get("cumulative_score", 0.0),
+            round_number=obs_data.get("round_number", 0),
+            max_rounds=obs_data.get("max_rounds", 10),
+            opponent_strategy=obs_data.get("opponent_strategy", ""),
+            history=obs_data.get("history", []),
             done=payload.get("done", False),
             reward=payload.get("reward"),
-            metadata=obs_data.get("metadata", {}),
+            message=obs_data.get("message", ""),
         )
 
         return StepResult(
@@ -84,15 +63,6 @@ class KantbenchEnv(
         )
 
     def _parse_state(self, payload: Dict) -> State:
-        """
-        Parse server response into State object.
-
-        Args:
-            payload: JSON response from state request
-
-        Returns:
-            State object with episode_id and step_count
-        """
         return State(
             episode_id=payload.get("episode_id"),
             step_count=payload.get("step_count", 0),

common/__init__.py

@@ -0,0 +1 @@
+"""Shared game infrastructure: game definitions, strategies, and extensions."""

common/games.py

@@ -0,0 +1,298 @@
+"""Game configuration registry and payoff computation for KantBench."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from constant_definitions.game_constants import (
+    DEFAULT_ZERO_FLOAT,
+    DEFAULT_ZERO_INT,
+    # Prisoner's Dilemma
+    PD_CC_PAYOFF,
+    PD_CD_PAYOFF,
+    PD_DC_PAYOFF,
+    PD_DD_PAYOFF,
+    # Stag Hunt
+    SH_SS_PAYOFF,
+    SH_SH_PAYOFF,
+    SH_HS_PAYOFF,
+    SH_HH_PAYOFF,
+    # Hawk-Dove
+    HD_HH_PAYOFF,
+    HD_HD_PAYOFF,
+    HD_DH_PAYOFF,
+    HD_DD_PAYOFF,
+    # Ultimatum
+    ULTIMATUM_POT,
+    # Trust
+    TRUST_MULTIPLIER,
+    TRUST_ENDOWMENT,
+    # Public Goods
+    PG_MULTIPLIER_NUMERATOR,
+    PG_MULTIPLIER_DENOMINATOR,
+    PG_ENDOWMENT,
+    PG_DEFAULT_NUM_PLAYERS,
+    # Round counts
+    DEFAULT_NUM_ROUNDS,
+    SINGLE_SHOT_ROUNDS,
+)
+
+# ---------------------------------------------------------------------------
+# GameConfig dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class GameConfig:
+    """Immutable specification for a single game type."""
+
+    name: str
+    description: str
+    actions: list[str]
+    game_type: str  # "matrix" | "ultimatum" | "trust" | "public_goods"
+    default_rounds: int
+    payoff_fn: Callable[[str, str], tuple[float, float]]
+
+
+# ---------------------------------------------------------------------------
+# Matrix-game payoff helpers
+# ---------------------------------------------------------------------------
+
+_PD_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(PD_CC_PAYOFF), float(PD_CC_PAYOFF)),
+    ("cooperate", "defect"):    (float(PD_CD_PAYOFF), float(PD_DC_PAYOFF)),
+    ("defect", "cooperate"):    (float(PD_DC_PAYOFF), float(PD_CD_PAYOFF)),
+    ("defect", "defect"):       (float(PD_DD_PAYOFF), float(PD_DD_PAYOFF)),
+}
+
+_SH_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("stag", "stag"): (float(SH_SS_PAYOFF), float(SH_SS_PAYOFF)),
+    ("stag", "hare"): (float(SH_SH_PAYOFF), float(SH_HS_PAYOFF)),
+    ("hare", "stag"): (float(SH_HS_PAYOFF), float(SH_SH_PAYOFF)),
+    ("hare", "hare"): (float(SH_HH_PAYOFF), float(SH_HH_PAYOFF)),
+}
+
+_HD_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("hawk", "hawk"): (float(HD_HH_PAYOFF), float(HD_HH_PAYOFF)),
+    ("hawk", "dove"): (float(HD_HD_PAYOFF), float(HD_DH_PAYOFF)),
+    ("dove", "hawk"): (float(HD_DH_PAYOFF), float(HD_HD_PAYOFF)),
+    ("dove", "dove"): (float(HD_DD_PAYOFF), float(HD_DD_PAYOFF)),
+}
+
+
+def _matrix_payoff_fn(
+    matrix: dict[tuple[str, str], tuple[float, float]],
+) -> Callable[[str, str], tuple[float, float]]:
+    """Return a payoff function backed by a pre-built matrix dict."""
+
+    def _payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+        return matrix[(player_action, opponent_action)]
+
+    return _payoff
+
+
+# ---------------------------------------------------------------------------
+# Computed payoff functions
+# ---------------------------------------------------------------------------
+
+
+def _parse_action_amount(action: str) -> int:
+    """Extract the integer suffix from an action string like 'offer_5'."""
+    parts = action.rsplit("_", maxsplit=SINGLE_SHOT_ROUNDS)
+    return int(parts[SINGLE_SHOT_ROUNDS])
+
+
+def _ultimatum_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Compute Ultimatum Game payoffs.
+
+    The player chooses an offer amount; the opponent accepts or rejects.
+    """
+    offer = _parse_action_amount(player_action)
+
+    if opponent_action == "reject":
+        return (DEFAULT_ZERO_FLOAT, DEFAULT_ZERO_FLOAT)
+
+    # accepted
+    player_payoff = float(ULTIMATUM_POT - offer)
+    opponent_payoff = float(offer)
+    return (player_payoff, opponent_payoff)
+
+
+def _trust_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Compute Trust Game payoffs.
+
+    The player invests X from their endowment. The opponent receives
+    X * multiplier and returns Y of that amount.
+    """
+    investment = _parse_action_amount(player_action)
+    returned = _parse_action_amount(opponent_action)
+
+    player_payoff = float(TRUST_ENDOWMENT - investment + returned)
+    opponent_payoff = float(investment * TRUST_MULTIPLIER - returned)
+    return (player_payoff, opponent_payoff)
+
+
+def _public_goods_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Compute Public Goods Game payoffs.
+
+    Each participant contributes from their endowment. The total pot is
+    multiplied by (numerator / denominator) then split equally among all
+    participants.
+    """
+    player_contrib = _parse_action_amount(player_action)
+    opponent_contrib = _parse_action_amount(opponent_action)
+
+    total_contributions = player_contrib + opponent_contrib
+    multiplied_pot = (
+        total_contributions * PG_MULTIPLIER_NUMERATOR / PG_MULTIPLIER_DENOMINATOR
+    )
+    share = multiplied_pot / PG_DEFAULT_NUM_PLAYERS
+
+    player_payoff = float(PG_ENDOWMENT - player_contrib) + share
+    opponent_payoff = float(PG_ENDOWMENT - opponent_contrib) + share
+    return (player_payoff, opponent_payoff)
+
+
+# ---------------------------------------------------------------------------
+# Action lists for computed games
+# ---------------------------------------------------------------------------
+
+_ULTIMATUM_OFFERS: list[str] = [
+    f"offer_{i}" for i in range(ULTIMATUM_POT + SINGLE_SHOT_ROUNDS)
+]
+
+_TRUST_INVESTMENTS: list[str] = [
+    f"invest_{i}" for i in range(TRUST_ENDOWMENT + SINGLE_SHOT_ROUNDS)
+]
+
+_PG_CONTRIBUTIONS: list[str] = [
+    f"contribute_{i}" for i in range(PG_ENDOWMENT + SINGLE_SHOT_ROUNDS)
+]
+
+
+# ---------------------------------------------------------------------------
+# Game registry
+# ---------------------------------------------------------------------------
+
+GAMES: dict[str, GameConfig] = {
+    "prisoners_dilemma": GameConfig(
+        name="Prisoner's Dilemma",
+        description=(
+            "Two players simultaneously choose to cooperate or defect. "
+            "Mutual cooperation yields a moderate reward, mutual defection "
+            "yields a low reward, and unilateral defection tempts with the "
+            "highest individual payoff at the other player's expense."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_PD_MATRIX),
+    ),
+    "stag_hunt": GameConfig(
+        name="Stag Hunt",
+        description=(
+            "Two players choose between hunting stag (risky but rewarding "
+            "if both participate) or hunting hare (safe but less rewarding). "
+            "Coordination on stag yields the highest joint payoff."
+        ),
+        actions=["stag", "hare"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_SH_MATRIX),
+    ),
+    "hawk_dove": GameConfig(
+        name="Hawk-Dove",
+        description=(
+            "Two players choose between aggressive (hawk) and passive (dove) "
+            "strategies over a shared resource. Two hawks suffer mutual harm; "
+            "a hawk facing a dove claims the resource; two doves share it."
+        ),
+        actions=["hawk", "dove"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_HD_MATRIX),
+    ),
+    "ultimatum": GameConfig(
+        name="Ultimatum Game",
+        description=(
+            "The proposer offers a split of a fixed pot. The responder "
+            "either accepts (both receive their shares) or rejects "
+            "(both receive nothing)."
+        ),
+        actions=_ULTIMATUM_OFFERS,
+        game_type="ultimatum",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_ultimatum_payoff,
+    ),
+    "trust": GameConfig(
+        name="Trust Game",
+        description=(
+            "The investor sends part of an endowment; the amount is "
+            "multiplied and given to the trustee, who then decides how "
+            "much to return."
+        ),
+        actions=_TRUST_INVESTMENTS,
+        game_type="trust",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_trust_payoff,
+    ),
+    "public_goods": GameConfig(
+        name="Public Goods Game",
+        description=(
+            "Each participant decides how much of their endowment to "
+            "contribute to a common pool. The pool is multiplied and "
+            "distributed equally, creating tension between individual "
+            "free-riding and collective benefit."
+        ),
+        actions=_PG_CONTRIBUTIONS,
+        game_type="public_goods",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_public_goods_payoff,
+    ),
+}
+
+
+def get_game(name: str) -> GameConfig:
+    """Retrieve a GameConfig by its registry key.
+
+    Args:
+        name: Key in the GAMES registry (e.g. ``"prisoners_dilemma"``).
+
+    Returns:
+        The corresponding :class:`GameConfig` instance.
+
+    Raises:
+        KeyError: If *name* is not present in the registry.
+    """
+    return GAMES[name]
+
+
+def _load_extensions() -> None:
+    """Import extension modules that register additional games."""
+    import importlib
+    for mod in [
+        "common.games_ext.matrix_games", "common.games_ext.sequential",
+        "common.games_ext.auction", "common.games_ext.nplayer",
+        "common.games_ext.generated", "common.games_info.signaling",
+        "common.games_info.contracts", "common.games_info.communication",
+        "common.games_info.bayesian", "common.games_info.network",
+        "common.games_market.oligopoly", "common.games_market.contests",
+        "common.games_market.classic", "common.games_market.generated_v2",
+        "common.games_market.advanced", "common.games_coop.cooperative",
+        "common.games_coop.dynamic", "common.games_coop.pd_variants",
+        "common.games_coop.infinite", "common.games_coop.stochastic",
+    ]:
+        try:
+            importlib.import_module(mod)
+        except ImportError:
+            pass
+
+
+_load_extensions()
+
+from common.games_meta.dynamic import (  # noqa: E402,F401
+    create_matrix_game, create_symmetric_game, create_custom_game,
+)

common/games_coop/cooperative.py

@@ -0,0 +1,169 @@
+"""Cooperative game theory and social choice games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.cooperative_constants import (
+    SHAPLEY_GRAND_COALITION_VALUE, SHAPLEY_SINGLE_VALUE,
+    SHAPLEY_MAX_CLAIM,
+    CORE_POT,
+    WV_QUOTA, WV_PLAYER_WEIGHT, WV_OPPONENT_WEIGHT,
+    WV_PASS_BENEFIT, WV_FAIL_PAYOFF, WV_OPPOSITION_BONUS,
+    SM_TOP_MATCH_PAYOFF, SM_MID_MATCH_PAYOFF, SM_LOW_MATCH_PAYOFF,
+    MV_POSITION_RANGE, MV_DISTANCE_COST,
+    AV_PREFERRED_WIN, AV_ACCEPTABLE_WIN, AV_DISLIKED_WIN,
+    AV_NUM_CANDIDATES,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+_ZERO_F = float()
+
+
+# -- Shapley Value Allocation --
+def _shapley_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each proposes a claim. Compatible claims split; else disagreement."""
+    c_p = int(pa.rsplit("_", _ONE)[_ONE])
+    c_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if c_p + c_o <= SHAPLEY_GRAND_COALITION_VALUE:
+        return (float(c_p), float(c_o))
+    return (float(SHAPLEY_SINGLE_VALUE), float(SHAPLEY_SINGLE_VALUE))
+
+
+_SHAPLEY_ACTS = [f"claim_{i}" for i in range(SHAPLEY_MAX_CLAIM + _ONE)]
+
+
+# -- Core / Divide-the-Dollar --
+def _core_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each proposes how much they want. If feasible, they get it."""
+    d_p = int(pa.rsplit("_", _ONE)[_ONE])
+    d_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if d_p + d_o <= CORE_POT:
+        return (float(d_p), float(d_o))
+    return (_ZERO_F, _ZERO_F)
+
+
+_CORE_ACTS = [f"claim_{i}" for i in range(CORE_POT + _ONE)]
+
+
+# -- Weighted Voting --
+def _weighted_voting_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Players vote yes or no; proposal passes if weighted votes meet quota."""
+    p_yes = pa == "vote_yes"
+    o_yes = oa == "vote_yes"
+    total_weight = int()
+    if p_yes:
+        total_weight += WV_PLAYER_WEIGHT
+    if o_yes:
+        total_weight += WV_OPPONENT_WEIGHT
+    passes = total_weight >= WV_QUOTA
+    if passes:
+        return (float(WV_PASS_BENEFIT), float(WV_PASS_BENEFIT))
+    p_pay = float(WV_OPPOSITION_BONUS) if not p_yes else float(WV_FAIL_PAYOFF)
+    o_pay = float(WV_OPPOSITION_BONUS) if not o_yes else float(WV_FAIL_PAYOFF)
+    return (p_pay, o_pay)
+
+
+# -- Stable Matching (preference revelation) --
+_SM_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("rank_abc", "rank_abc"): (float(SM_TOP_MATCH_PAYOFF), float(SM_TOP_MATCH_PAYOFF)),
+    ("rank_abc", "rank_bac"): (float(SM_MID_MATCH_PAYOFF), float(SM_TOP_MATCH_PAYOFF)),
+    ("rank_abc", "rank_cab"): (float(SM_LOW_MATCH_PAYOFF), float(SM_MID_MATCH_PAYOFF)),
+    ("rank_bac", "rank_abc"): (float(SM_TOP_MATCH_PAYOFF), float(SM_MID_MATCH_PAYOFF)),
+    ("rank_bac", "rank_bac"): (float(SM_MID_MATCH_PAYOFF), float(SM_MID_MATCH_PAYOFF)),
+    ("rank_bac", "rank_cab"): (float(SM_LOW_MATCH_PAYOFF), float(SM_LOW_MATCH_PAYOFF)),
+    ("rank_cab", "rank_abc"): (float(SM_MID_MATCH_PAYOFF), float(SM_LOW_MATCH_PAYOFF)),
+    ("rank_cab", "rank_bac"): (float(SM_LOW_MATCH_PAYOFF), float(SM_LOW_MATCH_PAYOFF)),
+    ("rank_cab", "rank_cab"): (float(SM_TOP_MATCH_PAYOFF), float(SM_TOP_MATCH_PAYOFF)),
+}
+
+
+# -- Median Voter --
+def _median_voter_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each picks a policy position; outcome is the median."""
+    pos_p = int(pa.rsplit("_", _ONE)[_ONE])
+    pos_o = int(oa.rsplit("_", _ONE)[_ONE])
+    median = (pos_p + pos_o) // _TWO
+    p_pay = float(-MV_DISTANCE_COST * abs(pos_p - median))
+    o_pay = float(-MV_DISTANCE_COST * abs(pos_o - median))
+    return (p_pay, o_pay)
+
+
+_MV_ACTS = [f"position_{i}" for i in range(MV_POSITION_RANGE + _ONE)]
+
+
+# -- Approval Voting --
+def _approval_voting_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each approves a candidate. Candidate with most approvals wins."""
+    if pa == oa:
+        return (float(AV_PREFERRED_WIN), float(AV_PREFERRED_WIN))
+    return (float(AV_DISLIKED_WIN), float(AV_DISLIKED_WIN))
+
+
+_AV_ACTS = [f"approve_{chr(ord('a') + i)}" for i in range(AV_NUM_CANDIDATES)]
+
+COOPERATIVE_GAMES: dict[str, GameConfig] = {
+    "shapley_allocation": GameConfig(
+        name="Shapley Value Allocation",
+        description=(
+            "Players claim shares of a coalition surplus. If claims are "
+            "compatible, each receives their claim; otherwise both receive "
+            "only their standalone value. Tests fair division reasoning."
+        ),
+        actions=_SHAPLEY_ACTS, game_type="shapley",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_shapley_payoff,
+    ),
+    "core_divide_dollar": GameConfig(
+        name="Core / Divide-the-Dollar",
+        description=(
+            "Players simultaneously claim shares of a pot. If total "
+            "claims are feasible, each gets their share; otherwise "
+            "both get nothing. Tests coalition stability reasoning."
+        ),
+        actions=_CORE_ACTS, game_type="core",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_core_payoff,
+    ),
+    "weighted_voting": GameConfig(
+        name="Weighted Voting Game",
+        description=(
+            "Players with different voting weights decide yes or no on "
+            "a proposal. The proposal passes if the weighted total meets "
+            "a quota. Tests understanding of pivotal power dynamics."
+        ),
+        actions=["vote_yes", "vote_no"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_weighted_voting_payoff,
+    ),
+    "stable_matching": GameConfig(
+        name="Stable Matching",
+        description=(
+            "Players report preference rankings over potential partners. "
+            "The matching outcome depends on reported preferences. Tests "
+            "whether agents report truthfully or strategically manipulate."
+        ),
+        actions=["rank_abc", "rank_bac", "rank_cab"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_SM_MATRIX),
+    ),
+    "median_voter": GameConfig(
+        name="Median Voter Game",
+        description=(
+            "Players choose policy positions on a line. The implemented "
+            "policy is the median. Each player's payoff decreases with "
+            "distance from the outcome. Tests strategic positioning."
+        ),
+        actions=_MV_ACTS, game_type="median_voter",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_median_voter_payoff,
+    ),
+    "approval_voting": GameConfig(
+        name="Approval Voting",
+        description=(
+            "Players approve one candidate from a set. The candidate "
+            "with the most approvals wins. Tests strategic vs sincere "
+            "voting behavior and preference aggregation."
+        ),
+        actions=_AV_ACTS, game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_approval_voting_payoff,
+    ),
+}
+
+GAMES.update(COOPERATIVE_GAMES)

common/games_coop/dynamic.py

@@ -0,0 +1,162 @@
+"""Dynamic, behavioral, and repeated games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.dynamic_constants import (
+    BR_PATIENCE_REWARD, BR_EARLY_WITHDRAW, BR_BANK_FAIL_PAYOFF,
+    GSH_STAG_PAYOFF, GSH_HARE_PAYOFF, GSH_STAG_ALONE_PAYOFF,
+    BC_MAX_NUMBER, BC_TARGET_FRACTION_NUM, BC_TARGET_FRACTION_DEN,
+    BC_WIN_PAYOFF, BC_LOSE_PAYOFF, BC_TIE_PAYOFF,
+    HDB_RESOURCE_VALUE, HDB_FIGHT_COST, HDB_SHARE_DIVISOR,
+)
+from constant_definitions.game_constants import (
+    PD_CC_PAYOFF, PD_CD_PAYOFF, PD_DC_PAYOFF, PD_DD_PAYOFF,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+_ZERO_F = float()
+
+
+# -- Bank Run (Diamond-Dybvig) --
+_BR_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("wait", "wait"):         (float(BR_PATIENCE_REWARD), float(BR_PATIENCE_REWARD)),
+    ("wait", "withdraw"):     (float(BR_BANK_FAIL_PAYOFF), float(BR_EARLY_WITHDRAW)),
+    ("withdraw", "wait"):     (float(BR_EARLY_WITHDRAW), float(BR_BANK_FAIL_PAYOFF)),
+    ("withdraw", "withdraw"): (float(BR_BANK_FAIL_PAYOFF), float(BR_BANK_FAIL_PAYOFF)),
+}
+
+
+# -- Global Stag Hunt (higher stakes variant) --
+_GSH_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("stag", "stag"):   (float(GSH_STAG_PAYOFF), float(GSH_STAG_PAYOFF)),
+    ("stag", "hare"):   (float(GSH_STAG_ALONE_PAYOFF), float(GSH_HARE_PAYOFF)),
+    ("hare", "stag"):   (float(GSH_HARE_PAYOFF), float(GSH_STAG_ALONE_PAYOFF)),
+    ("hare", "hare"):   (float(GSH_HARE_PAYOFF), float(GSH_HARE_PAYOFF)),
+}
+
+
+# -- Beauty Contest (p-Guessing Game) --
+def _beauty_contest_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each picks a number. Closest to p * average wins."""
+    n_p = int(pa.rsplit("_", _ONE)[_ONE])
+    n_o = int(oa.rsplit("_", _ONE)[_ONE])
+    avg = float(n_p + n_o) / _TWO
+    target = avg * BC_TARGET_FRACTION_NUM / BC_TARGET_FRACTION_DEN
+    dist_p = abs(float(n_p) - target)
+    dist_o = abs(float(n_o) - target)
+    if dist_p < dist_o:
+        return (float(BC_WIN_PAYOFF), float(BC_LOSE_PAYOFF))
+    if dist_o < dist_p:
+        return (float(BC_LOSE_PAYOFF), float(BC_WIN_PAYOFF))
+    return (float(BC_TIE_PAYOFF), float(BC_TIE_PAYOFF))
+
+
+_BC_ACTS = [f"guess_{i}" for i in range(BC_MAX_NUMBER + _ONE)]
+
+
+# -- Hawk-Dove-Bourgeois --
+_V = float(HDB_RESOURCE_VALUE)
+_C = float(HDB_FIGHT_COST)
+_S = _V / float(HDB_SHARE_DIVISOR)
+_HDB_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("hawk", "hawk"):       ((_V - _C) / _TWO, (_V - _C) / _TWO),
+    ("hawk", "dove"):       (_V, _ZERO_F),
+    ("hawk", "bourgeois"):  (_V / _TWO, (_V - _C) / (float(_TWO) * _TWO)),
+    ("dove", "hawk"):       (_ZERO_F, _V),
+    ("dove", "dove"):       (_S, _S),
+    ("dove", "bourgeois"):  (_S / _TWO, _S + _V / (float(_TWO) * _TWO)),
+    ("bourgeois", "hawk"):  ((_V - _C) / (float(_TWO) * _TWO), _V / _TWO),
+    ("bourgeois", "dove"):  (_S + _V / (float(_TWO) * _TWO), _S / _TWO),
+    ("bourgeois", "bourgeois"): (_S, _S),
+}
+
+
+# -- Finitely Repeated PD (same payoffs, explicit short horizon) --
+_FPD_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(PD_CC_PAYOFF), float(PD_CC_PAYOFF)),
+    ("cooperate", "defect"):    (float(PD_CD_PAYOFF), float(PD_DC_PAYOFF)),
+    ("defect", "cooperate"):    (float(PD_DC_PAYOFF), float(PD_CD_PAYOFF)),
+    ("defect", "defect"):       (float(PD_DD_PAYOFF), float(PD_DD_PAYOFF)),
+}
+
+_FIVE = _TWO + _TWO + _ONE
+_MARKOV_ROUNDS = _FIVE + _FIVE + _FIVE
+
+DYNAMIC_GAMES: dict[str, GameConfig] = {
+    "bank_run": GameConfig(
+        name="Bank Run (Diamond-Dybvig)",
+        description=(
+            "Depositors simultaneously decide whether to withdraw early. "
+            "If both wait, the bank survives and both earn a premium. If "
+            "both withdraw, the bank fails. Models coordination failure "
+            "in financial systems."
+        ),
+        actions=["wait", "withdraw"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_BR_MATRIX),
+    ),
+    "global_stag_hunt": GameConfig(
+        name="Global Stag Hunt",
+        description=(
+            "A higher-stakes Stag Hunt modeling coordination under "
+            "uncertainty. Both hunting stag yields a large payoff but "
+            "hunting stag alone yields nothing. Models bank runs, "
+            "currency attacks, and regime change dynamics."
+        ),
+        actions=["stag", "hare"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_GSH_MATRIX),
+    ),
+    "beauty_contest": GameConfig(
+        name="Keynesian Beauty Contest",
+        description=(
+            "Each player picks a number. The winner is closest to a "
+            "target fraction of the average. Tests depth of strategic "
+            "reasoning and level-k thinking. The unique Nash equilibrium "
+            "is zero, reached through iterated elimination."
+        ),
+        actions=_BC_ACTS, game_type="beauty_contest",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_beauty_contest_payoff,
+    ),
+    "hawk_dove_bourgeois": GameConfig(
+        name="Hawk-Dove-Bourgeois",
+        description=(
+            "Extended Hawk-Dove with a Bourgeois strategy that plays "
+            "Hawk when incumbent and Dove when intruder. The Bourgeois "
+            "strategy is an evolutionarily stable strategy. Tests "
+            "reasoning about ownership conventions."
+        ),
+        actions=["hawk", "dove", "bourgeois"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_HDB_MATRIX),
+    ),
+    "finitely_repeated_pd": GameConfig(
+        name="Finitely Repeated Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma played for a known finite number of "
+            "rounds. Backward induction predicts mutual defection in "
+            "every round, yet cooperation often emerges experimentally. "
+            "Tests backward induction versus cooperation heuristics."
+        ),
+        actions=["cooperate", "defect"], game_type="matrix",
+        default_rounds=_FIVE,
+        payoff_fn=_matrix_payoff_fn(_FPD_MATRIX),
+    ),
+    "markov_game": GameConfig(
+        name="Markov Decision Game",
+        description=(
+            "A repeated game where the payoff structure shifts based on "
+            "recent history. Players must adapt strategies to changing "
+            "incentives. Tests dynamic programming and Markov-perfect "
+            "equilibrium reasoning over multiple rounds."
+        ),
+        actions=["cooperate", "defect"], game_type="matrix",
+        default_rounds=_MARKOV_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_FPD_MATRIX),
+    ),
+}
+
+GAMES.update(DYNAMIC_GAMES)

common/games_coop/infinite.py

@@ -0,0 +1,72 @@
+"""Infinite-horizon and continuous games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS
+from constant_definitions.var.infinite_constants import (
+    CPD_BENEFIT_NUMERATOR, CPD_COST_NUMERATOR, CPD_DENOMINATOR,
+    CPD_MAX_LEVEL,
+    DPD_TEMPTATION, DPD_REWARD, DPD_PUNISHMENT, DPD_SUCKER,
+    DPD_DEFAULT_ROUNDS,
+)
+
+_ONE = int(bool(True))
+
+
+# -- Continuous PD (variable contribution levels) --
+def _continuous_pd_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each player chooses a cooperation level. Higher = costlier but benefits opponent."""
+    lvl_p = int(pa.rsplit("_", _ONE)[_ONE])
+    lvl_o = int(oa.rsplit("_", _ONE)[_ONE])
+    p_pay = float(lvl_o * CPD_BENEFIT_NUMERATOR) / CPD_DENOMINATOR
+    p_pay -= float(lvl_p * CPD_COST_NUMERATOR) / CPD_DENOMINATOR
+    o_pay = float(lvl_p * CPD_BENEFIT_NUMERATOR) / CPD_DENOMINATOR
+    o_pay -= float(lvl_o * CPD_COST_NUMERATOR) / CPD_DENOMINATOR
+    return (p_pay, o_pay)
+
+
+_CPD_ACTS = [f"level_{i}" for i in range(CPD_MAX_LEVEL + _ONE)]
+
+
+# -- Discounted PD (high-stakes, long-horizon) --
+_DPD_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(DPD_REWARD), float(DPD_REWARD)),
+    ("cooperate", "defect"):    (float(DPD_SUCKER), float(DPD_TEMPTATION)),
+    ("defect", "cooperate"):    (float(DPD_TEMPTATION), float(DPD_SUCKER)),
+    ("defect", "defect"):       (float(DPD_PUNISHMENT), float(DPD_PUNISHMENT)),
+}
+
+
+# -- Register --
+INFINITE_GAMES: dict[str, GameConfig] = {
+    "continuous_pd": GameConfig(
+        name="Continuous Prisoner's Dilemma",
+        description=(
+            "A generalization of the Prisoner's Dilemma with variable "
+            "cooperation levels instead of binary choices. Each unit of "
+            "cooperation costs the player but benefits the opponent more. "
+            "Tests whether agents find intermediate cooperation strategies "
+            "in continuous action spaces."
+        ),
+        actions=_CPD_ACTS,
+        game_type="continuous_pd",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_continuous_pd_payoff,
+    ),
+    "discounted_pd": GameConfig(
+        name="Discounted Prisoner's Dilemma",
+        description=(
+            "A high-stakes Prisoner's Dilemma with many rounds, modeling "
+            "an effectively infinite repeated interaction. The shadow of "
+            "the future makes cooperation sustainable under folk theorem "
+            "conditions. Tests long-horizon strategic reasoning with "
+            "higher temptation and reward differentials."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DPD_DEFAULT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_DPD_MATRIX),
+    ),
+}
+
+GAMES.update(INFINITE_GAMES)

common/games_coop/pd_variants.py

@@ -0,0 +1,145 @@
+"""Prisoner's Dilemma variants for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import (
+    PD_CC_PAYOFF, PD_CD_PAYOFF, PD_DC_PAYOFF, PD_DD_PAYOFF,
+    DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS,
+)
+from constant_definitions.var.pd_variant_constants import (
+    OPD_EXIT_PAYOFF,
+    APD_A_TEMPTATION, APD_A_REWARD, APD_A_PUNISHMENT, APD_A_SUCKER,
+    APD_B_TEMPTATION, APD_B_REWARD, APD_B_PUNISHMENT, APD_B_SUCKER,
+    DONATION_BENEFIT, DONATION_COST,
+    FOF_SHARE_PAYOFF, FOF_STEAL_WIN_PAYOFF,
+    PW_DISARM_DISARM, PW_DISARM_ARM, PW_ARM_DISARM, PW_ARM_ARM,
+)
+
+_ZERO_F = float()
+
+
+# -- Optional PD (cooperate / defect / exit) --
+_OPD_EXIT_F = float(OPD_EXIT_PAYOFF)
+_OPD_BASE: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(PD_CC_PAYOFF), float(PD_CC_PAYOFF)),
+    ("cooperate", "defect"):    (float(PD_CD_PAYOFF), float(PD_DC_PAYOFF)),
+    ("defect", "cooperate"):    (float(PD_DC_PAYOFF), float(PD_CD_PAYOFF)),
+    ("defect", "defect"):       (float(PD_DD_PAYOFF), float(PD_DD_PAYOFF)),
+}
+
+
+def _optional_pd_payoff(pa: str, oa: str) -> tuple[float, float]:
+    if pa == "exit" or oa == "exit":
+        return (_OPD_EXIT_F, _OPD_EXIT_F)
+    return _OPD_BASE[(pa, oa)]
+
+
+# -- Asymmetric PD (alibi game: different payoffs per player) --
+_ASYM_PD: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(APD_A_REWARD), float(APD_B_REWARD)),
+    ("cooperate", "defect"):    (float(APD_A_SUCKER), float(APD_B_TEMPTATION)),
+    ("defect", "cooperate"):    (float(APD_A_TEMPTATION), float(APD_B_SUCKER)),
+    ("defect", "defect"):       (float(APD_A_PUNISHMENT), float(APD_B_PUNISHMENT)),
+}
+
+
+# -- Donation Game (pay cost c to give benefit b to opponent) --
+_DG: dict[tuple[str, str], tuple[float, float]] = {
+    ("donate", "donate"): (
+        float(DONATION_BENEFIT - DONATION_COST),
+        float(DONATION_BENEFIT - DONATION_COST),
+    ),
+    ("donate", "keep"): (float(-DONATION_COST), float(DONATION_BENEFIT)),
+    ("keep", "donate"):  (float(DONATION_BENEFIT), float(-DONATION_COST)),
+    ("keep", "keep"):    (_ZERO_F, _ZERO_F),
+}
+
+
+# -- Friend or Foe (game show: both defect yields zero) --
+_FOF: dict[tuple[str, str], tuple[float, float]] = {
+    ("friend", "friend"): (float(FOF_SHARE_PAYOFF), float(FOF_SHARE_PAYOFF)),
+    ("friend", "foe"):    (_ZERO_F, float(FOF_STEAL_WIN_PAYOFF)),
+    ("foe", "friend"):    (float(FOF_STEAL_WIN_PAYOFF), _ZERO_F),
+    ("foe", "foe"):       (_ZERO_F, _ZERO_F),
+}
+
+
+# -- Peace-War Game (arms race framing from international relations) --
+_PW: dict[tuple[str, str], tuple[float, float]] = {
+    ("disarm", "disarm"): (float(PW_DISARM_DISARM), float(PW_DISARM_DISARM)),
+    ("disarm", "arm"):    (float(PW_DISARM_ARM), float(PW_ARM_DISARM)),
+    ("arm", "disarm"):    (float(PW_ARM_DISARM), float(PW_DISARM_ARM)),
+    ("arm", "arm"):       (float(PW_ARM_ARM), float(PW_ARM_ARM)),
+}
+
+
+# -- Register --
+PD_VARIANT_GAMES: dict[str, GameConfig] = {
+    "optional_pd": GameConfig(
+        name="Optional Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma with a third action: exit. Exiting gives "
+            "a safe intermediate payoff regardless of the opponent's choice. "
+            "Tests whether outside options change cooperation dynamics and "
+            "models situations where players can walk away from interactions."
+        ),
+        actions=["cooperate", "defect", "exit"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_optional_pd_payoff,
+    ),
+    "asymmetric_pd": GameConfig(
+        name="Asymmetric Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma where players have unequal payoff "
+            "structures. The first player has an alibi advantage with a "
+            "higher punishment payoff. Tests strategic reasoning under "
+            "asymmetric incentive conditions."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_ASYM_PD),
+    ),
+    "donation_game": GameConfig(
+        name="Donation Game",
+        description=(
+            "A simplified cooperation model: each player independently "
+            "decides whether to donate. Donating costs the donor but "
+            "gives a larger benefit to the recipient. The dominant "
+            "strategy is to keep, but mutual donation is Pareto superior."
+        ),
+        actions=["donate", "keep"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_DG),
+    ),
+    "friend_or_foe": GameConfig(
+        name="Friend or Foe",
+        description=(
+            "A game show variant of the Prisoner's Dilemma. If both choose "
+            "friend, winnings are shared. If one steals (foe), they take all. "
+            "If both choose foe, neither gets anything. Unlike standard PD, "
+            "mutual defection yields zero, creating a weak equilibrium."
+        ),
+        actions=["friend", "foe"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_FOF),
+    ),
+    "peace_war": GameConfig(
+        name="Peace-War Game",
+        description=(
+            "An international relations framing of the Prisoner's Dilemma. "
+            "Players choose to arm or disarm. Mutual disarmament yields the "
+            "best joint outcome but unilateral arming dominates. Models "
+            "the security dilemma and arms race escalation dynamics."
+        ),
+        actions=["disarm", "arm"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_PW),
+    ),
+}
+
+GAMES.update(PD_VARIANT_GAMES)

common/games_coop/stochastic.py

@@ -0,0 +1,128 @@
+"""Stochastic and evolutionary game variants for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.batch4.stochastic_constants import (
+    SPD_CC, SPD_CD, SPD_DC, SPD_DD,
+    RD_PAYOFF_DOMINANT, RD_RISK_DOMINANT, RD_MISCOORDINATION,
+    TPG_ENDOWMENT, TPG_THRESHOLD, TPG_SUCCESS_BONUS,
+    EPD_COOP_COOP, EPD_COOP_DEFECT, EPD_DEFECT_COOP, EPD_DEFECT_DEFECT,
+    EPD_TFT_DEFECT, EPD_DEFECT_TFT,
+)
+
+_ONE = int(bool(True))
+
+
+# -- Stochastic PD (expected payoffs under action noise) --
+_SPD: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(SPD_CC), float(SPD_CC)),
+    ("cooperate", "defect"):    (float(SPD_CD), float(SPD_DC)),
+    ("defect", "cooperate"):    (float(SPD_DC), float(SPD_CD)),
+    ("defect", "defect"):       (float(SPD_DD), float(SPD_DD)),
+}
+
+
+# -- Risk Dominance (payoff-dominant vs risk-dominant equilibria) --
+_RD: dict[tuple[str, str], tuple[float, float]] = {
+    ("risky", "risky"):   (float(RD_PAYOFF_DOMINANT), float(RD_PAYOFF_DOMINANT)),
+    ("risky", "safe"):    (float(RD_MISCOORDINATION), float(RD_MISCOORDINATION)),
+    ("safe", "risky"):    (float(RD_MISCOORDINATION), float(RD_MISCOORDINATION)),
+    ("safe", "safe"):     (float(RD_RISK_DOMINANT), float(RD_RISK_DOMINANT)),
+}
+
+
+# -- Threshold Public Goods (step-function provision) --
+_TPG_ENDOW_F = float(TPG_ENDOWMENT)
+_TPG_THRESH = TPG_THRESHOLD
+_TPG_BONUS = float(TPG_SUCCESS_BONUS)
+
+
+def _tpg_payoff(pa: str, oa: str) -> tuple[float, float]:
+    p_c = int(pa.rsplit("_", _ONE)[_ONE])
+    o_c = int(oa.rsplit("_", _ONE)[_ONE])
+    total = p_c + o_c
+    if total >= _TPG_THRESH:
+        p_pay = _TPG_ENDOW_F - float(p_c) + _TPG_BONUS
+        o_pay = _TPG_ENDOW_F - float(o_c) + _TPG_BONUS
+    else:
+        p_pay = _TPG_ENDOW_F - float(p_c)
+        o_pay = _TPG_ENDOW_F - float(o_c)
+    return (p_pay, o_pay)
+
+
+_TPG_ACTS = [f"contribute_{i}" for i in range(TPG_ENDOWMENT + _ONE)]
+
+
+# -- Evolutionary PD (always_coop / always_defect / tit_for_tat) --
+_EPD: dict[tuple[str, str], tuple[float, float]] = {
+    ("always_coop", "always_coop"):     (float(EPD_COOP_COOP), float(EPD_COOP_COOP)),
+    ("always_coop", "always_defect"):   (float(EPD_COOP_DEFECT), float(EPD_DEFECT_COOP)),
+    ("always_coop", "tit_for_tat"):     (float(EPD_COOP_COOP), float(EPD_COOP_COOP)),
+    ("always_defect", "always_coop"):   (float(EPD_DEFECT_COOP), float(EPD_COOP_DEFECT)),
+    ("always_defect", "always_defect"): (float(EPD_DEFECT_DEFECT), float(EPD_DEFECT_DEFECT)),
+    ("always_defect", "tit_for_tat"):   (float(EPD_DEFECT_TFT), float(EPD_TFT_DEFECT)),
+    ("tit_for_tat", "always_coop"):     (float(EPD_COOP_COOP), float(EPD_COOP_COOP)),
+    ("tit_for_tat", "always_defect"):   (float(EPD_TFT_DEFECT), float(EPD_DEFECT_TFT)),
+    ("tit_for_tat", "tit_for_tat"):     (float(EPD_COOP_COOP), float(EPD_COOP_COOP)),
+}
+
+
+# -- Register --
+STOCHASTIC_GAMES: dict[str, GameConfig] = {
+    "stochastic_pd": GameConfig(
+        name="Stochastic Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma variant where action execution is noisy. "
+            "With some probability each player's intended action is flipped. "
+            "Expected payoffs differ from the standard PD, reflecting the "
+            "tremble probabilities. Tests robustness of strategies to noise."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_SPD),
+    ),
+    "risk_dominance": GameConfig(
+        name="Risk Dominance Game",
+        description=(
+            "A coordination game with two pure Nash equilibria: one "
+            "payoff-dominant (risky-risky yields higher mutual payoff) and "
+            "one risk-dominant (safe-safe is more robust to uncertainty). "
+            "Tests whether agents optimize for payoff or safety under "
+            "strategic uncertainty about the opponent's behavior."
+        ),
+        actions=["risky", "safe"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_RD),
+    ),
+    "threshold_public_goods": GameConfig(
+        name="Threshold Public Goods Game",
+        description=(
+            "A public goods game with a provision threshold. Each player "
+            "contributes from an endowment. If total contributions meet the "
+            "threshold a bonus is provided to all. Otherwise contributions "
+            "are spent without the bonus. Tests coordination on provision."
+        ),
+        actions=_TPG_ACTS,
+        game_type="threshold_public_goods",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_tpg_payoff,
+    ),
+    "evolutionary_pd": GameConfig(
+        name="Evolutionary Prisoner's Dilemma",
+        description=(
+            "A multi-strategy Prisoner's Dilemma representing long-run "
+            "evolutionary dynamics. Players choose from always cooperate "
+            "and always defect and tit-for-tat. Payoffs represent expected "
+            "long-run fitness across many interactions between strategies."
+        ),
+        actions=["always_coop", "always_defect", "tit_for_tat"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_EPD),
+    ),
+}
+
+GAMES.update(STOCHASTIC_GAMES)

common/games_ext/auction.py

@@ -0,0 +1,138 @@
+"""Auction mechanism games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import SINGLE_SHOT_ROUNDS
+from constant_definitions.auction_nplayer_constants import (
+    AUCTION_ITEM_VALUE, AUCTION_MAX_BID, AUCTION_BID_INCREMENT,
+)
+
+_ONE = int(bool(True))
+_ZERO = int()
+_ZERO_F = float()
+
+
+def _parse_bid(action: str) -> int:
+    """Extract bid amount from action string like 'bid_5'."""
+    return int(action.rsplit("_", _ONE)[_ONE])
+
+
+# -- First-Price Sealed Bid Auction --
+
+def _first_price_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Highest bidder wins and pays their own bid."""
+    p_bid = _parse_bid(player_action)
+    o_bid = _parse_bid(opponent_action)
+
+    if p_bid > o_bid:
+        p_pay = float(AUCTION_ITEM_VALUE - p_bid)
+        o_pay = _ZERO_F
+    elif o_bid > p_bid:
+        p_pay = _ZERO_F
+        o_pay = float(AUCTION_ITEM_VALUE - o_bid)
+    else:
+        half_surplus = float(AUCTION_ITEM_VALUE - p_bid) / (_ONE + _ONE)
+        p_pay = half_surplus
+        o_pay = half_surplus
+    return (p_pay, o_pay)
+
+
+# -- Second-Price (Vickrey) Auction --
+
+def _vickrey_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Highest bidder wins but pays the second-highest bid."""
+    p_bid = _parse_bid(player_action)
+    o_bid = _parse_bid(opponent_action)
+
+    if p_bid > o_bid:
+        p_pay = float(AUCTION_ITEM_VALUE - o_bid)
+        o_pay = _ZERO_F
+    elif o_bid > p_bid:
+        p_pay = _ZERO_F
+        o_pay = float(AUCTION_ITEM_VALUE - p_bid)
+    else:
+        half_surplus = float(AUCTION_ITEM_VALUE - p_bid) / (_ONE + _ONE)
+        p_pay = half_surplus
+        o_pay = half_surplus
+    return (p_pay, o_pay)
+
+
+# -- All-Pay Auction --
+
+def _allpay_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Both bidders pay their bids; only the winner gets the item."""
+    p_bid = _parse_bid(player_action)
+    o_bid = _parse_bid(opponent_action)
+
+    if p_bid > o_bid:
+        p_pay = float(AUCTION_ITEM_VALUE - p_bid)
+        o_pay = float(-o_bid)
+    elif o_bid > p_bid:
+        p_pay = float(-p_bid)
+        o_pay = float(AUCTION_ITEM_VALUE - o_bid)
+    else:
+        half_value = float(AUCTION_ITEM_VALUE) / (_ONE + _ONE)
+        p_pay = half_value - float(p_bid)
+        o_pay = half_value - float(o_bid)
+    return (p_pay, o_pay)
+
+
+# -- Action lists --
+
+_BID_ACTIONS = [
+    f"bid_{i}" for i in range(
+        _ZERO, AUCTION_MAX_BID + AUCTION_BID_INCREMENT, AUCTION_BID_INCREMENT,
+    )
+]
+
+
+# -- Register --
+
+AUCTION_GAMES: dict[str, GameConfig] = {
+    "first_price_auction": GameConfig(
+        name="First-Price Sealed-Bid Auction",
+        description=(
+            "Two bidders simultaneously submit sealed bids for an item. "
+            "The highest bidder wins and pays their own bid. Strategic "
+            "bidding requires shading below true value to maximize surplus "
+            "while still winning."
+        ),
+        actions=_BID_ACTIONS,
+        game_type="auction",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_first_price_payoff,
+    ),
+    "vickrey_auction": GameConfig(
+        name="Second-Price (Vickrey) Auction",
+        description=(
+            "Two bidders submit sealed bids. The highest bidder wins but "
+            "pays the second-highest bid. The dominant strategy is to bid "
+            "one's true valuation, making this a strategy-proof mechanism."
+        ),
+        actions=_BID_ACTIONS,
+        game_type="auction",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_vickrey_payoff,
+    ),
+    "allpay_auction": GameConfig(
+        name="All-Pay Auction",
+        description=(
+            "Two bidders submit sealed bids. Both pay their bids regardless "
+            "of outcome, but only the highest bidder receives the item. "
+            "Models contests, lobbying, and rent-seeking where effort is "
+            "spent whether or not you win."
+        ),
+        actions=_BID_ACTIONS,
+        game_type="auction",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_allpay_payoff,
+    ),
+}
+
+GAMES.update(AUCTION_GAMES)

common/games_ext/generated.py

@@ -0,0 +1,144 @@
+"""Procedurally generated games for KantBench."""
+from __future__ import annotations
+
+import random as _rand
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS
+from constant_definitions.auction_nplayer_constants import (
+    GENERATED_DEFAULT_ACTIONS, GENERATED_PAYOFF_MIN, GENERATED_PAYOFF_MAX,
+    GENERATED_SEED_DEFAULT,
+)
+
+_ONE = int(bool(True))
+
+
+def _action_label(index: int) -> str:
+    """Generate action label: a, b, c, ... z, aa, ab, ..."""
+    alphabet_size = ord("z") - ord("a") + _ONE
+    if index < alphabet_size:
+        return chr(ord("a") + index)
+    first = index // alphabet_size - _ONE
+    second = index % alphabet_size
+    return chr(ord("a") + first) + chr(ord("a") + second)
+
+
+def generate_random_symmetric(
+    num_actions: int = GENERATED_DEFAULT_ACTIONS,
+    payoff_min: int = GENERATED_PAYOFF_MIN,
+    payoff_max: int = GENERATED_PAYOFF_MAX,
+    seed: int = GENERATED_SEED_DEFAULT,
+) -> GameConfig:
+    """Generate a random symmetric NxN matrix game.
+
+    In a symmetric game, the payoff for the first player choosing (a, b)
+    equals the payoff for the second player facing (b, a).
+    """
+    rng = _rand.Random(seed)
+    actions = [_action_label(i) for i in range(num_actions)]
+
+    matrix: dict[tuple[str, str], tuple[float, float]] = {}
+    for i, a in enumerate(actions):
+        for j, b in enumerate(actions):
+            if (a, b) not in matrix:
+                p_first = float(rng.randint(payoff_min, payoff_max))
+                p_second = float(rng.randint(payoff_min, payoff_max))
+                matrix[(a, b)] = (p_first, p_second)
+                matrix[(b, a)] = (p_second, p_first)
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"Random Symmetric {num_actions}x{num_actions} (seed={seed})",
+        description=(
+            f"A randomly generated {num_actions}x{num_actions} symmetric "
+            f"matrix game with payoffs in [{payoff_min}, {payoff_max}]. "
+            f"Tests generalization to novel strategic structures."
+        ),
+        actions=actions,
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_payoff,
+    )
+
+
+def generate_random_asymmetric(
+    num_actions: int = GENERATED_DEFAULT_ACTIONS,
+    payoff_min: int = GENERATED_PAYOFF_MIN,
+    payoff_max: int = GENERATED_PAYOFF_MAX,
+    seed: int = GENERATED_SEED_DEFAULT,
+) -> GameConfig:
+    """Generate a random asymmetric NxN matrix game.
+
+    Each cell has independently drawn payoffs for both players.
+    """
+    rng = _rand.Random(seed)
+    actions = [_action_label(i) for i in range(num_actions)]
+
+    matrix: dict[tuple[str, str], tuple[float, float]] = {}
+    for a in actions:
+        for b in actions:
+            p_first = float(rng.randint(payoff_min, payoff_max))
+            p_second = float(rng.randint(payoff_min, payoff_max))
+            matrix[(a, b)] = (p_first, p_second)
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"Random Asymmetric {num_actions}x{num_actions} (seed={seed})",
+        description=(
+            f"A randomly generated {num_actions}x{num_actions} asymmetric "
+            f"matrix game with independent payoffs in [{payoff_min}, {payoff_max}]. "
+            f"Tests reasoning in novel non-symmetric strategic settings."
+        ),
+        actions=actions,
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_payoff,
+    )
+
+
+def generate_parameterized_pd(
+    temptation: int,
+    reward: int,
+    punishment: int,
+    sucker: int,
+    seed: int = GENERATED_SEED_DEFAULT,
+) -> GameConfig:
+    """Create a Prisoner's Dilemma with custom T > R > P > S payoffs."""
+    matrix: dict[tuple[str, str], tuple[float, float]] = {
+        ("cooperate", "cooperate"): (float(reward), float(reward)),
+        ("cooperate", "defect"):    (float(sucker), float(temptation)),
+        ("defect", "cooperate"):    (float(temptation), float(sucker)),
+        ("defect", "defect"):       (float(punishment), float(punishment)),
+    }
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"PD(T={temptation},R={reward},P={punishment},S={sucker})",
+        description=(
+            f"A parameterized Prisoner's Dilemma with T={temptation}, "
+            f"R={reward}, P={punishment}, S={sucker}. Tests sensitivity "
+            f"to varying incentive structures."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_payoff,
+    )
+
+
+# -- Register default generated instances --
+
+_DEFAULT_SYMMETRIC = generate_random_symmetric()
+_DEFAULT_ASYMMETRIC = generate_random_asymmetric(seed=GENERATED_SEED_DEFAULT + _ONE)
+
+GENERATED_GAMES: dict[str, GameConfig] = {
+    "random_symmetric_3x3": _DEFAULT_SYMMETRIC,
+    "random_asymmetric_3x3": _DEFAULT_ASYMMETRIC,
+}
+
+GAMES.update(GENERATED_GAMES)

common/games_ext/matrix_games.py

@@ -0,0 +1,152 @@
+"""Extended matrix (normal-form) games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.zero_sum_constants import (
+    MP_MATCH_PAYOFF, MP_MISMATCH_PAYOFF,
+    RPS_WIN_PAYOFF, RPS_LOSE_PAYOFF, RPS_DRAW_PAYOFF,
+)
+from constant_definitions.coordination_constants import (
+    BOS_PREFERRED_PAYOFF, BOS_COMPROMISE_PAYOFF, BOS_MISMATCH_PAYOFF,
+    PC_MATCH_PAYOFF, PC_MISMATCH_PAYOFF,
+    DL_DC_PAYOFF, DL_DD_PAYOFF, DL_CC_PAYOFF, DL_CD_PAYOFF,
+    HM_CC_PAYOFF, HM_DC_PAYOFF, HM_CD_PAYOFF, HM_DD_PAYOFF,
+)
+
+# -- Matching Pennies --
+_MP_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("heads", "heads"): (float(MP_MATCH_PAYOFF), float(MP_MISMATCH_PAYOFF)),
+    ("heads", "tails"): (float(MP_MISMATCH_PAYOFF), float(MP_MATCH_PAYOFF)),
+    ("tails", "heads"): (float(MP_MISMATCH_PAYOFF), float(MP_MATCH_PAYOFF)),
+    ("tails", "tails"): (float(MP_MATCH_PAYOFF), float(MP_MISMATCH_PAYOFF)),
+}
+
+# -- Rock-Paper-Scissors --
+_W, _L, _D = float(RPS_WIN_PAYOFF), float(RPS_LOSE_PAYOFF), float(RPS_DRAW_PAYOFF)
+_RPS_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("rock", "rock"):         (_D, _D),
+    ("rock", "scissors"):     (_W, _L),
+    ("rock", "paper"):        (_L, _W),
+    ("scissors", "rock"):     (_L, _W),
+    ("scissors", "scissors"): (_D, _D),
+    ("scissors", "paper"):    (_W, _L),
+    ("paper", "rock"):        (_W, _L),
+    ("paper", "scissors"):    (_L, _W),
+    ("paper", "paper"):       (_D, _D),
+}
+
+# -- Battle of the Sexes --
+_BOS_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("opera", "opera"):       (float(BOS_PREFERRED_PAYOFF), float(BOS_COMPROMISE_PAYOFF)),
+    ("opera", "football"):    (float(BOS_MISMATCH_PAYOFF), float(BOS_MISMATCH_PAYOFF)),
+    ("football", "opera"):    (float(BOS_MISMATCH_PAYOFF), float(BOS_MISMATCH_PAYOFF)),
+    ("football", "football"): (float(BOS_COMPROMISE_PAYOFF), float(BOS_PREFERRED_PAYOFF)),
+}
+
+# -- Pure Coordination --
+_PC_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("left", "left"):   (float(PC_MATCH_PAYOFF), float(PC_MATCH_PAYOFF)),
+    ("left", "right"):  (float(PC_MISMATCH_PAYOFF), float(PC_MISMATCH_PAYOFF)),
+    ("right", "left"):  (float(PC_MISMATCH_PAYOFF), float(PC_MISMATCH_PAYOFF)),
+    ("right", "right"): (float(PC_MATCH_PAYOFF), float(PC_MATCH_PAYOFF)),
+}
+
+# -- Deadlock --
+_DL_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(DL_CC_PAYOFF), float(DL_CC_PAYOFF)),
+    ("cooperate", "defect"):    (float(DL_CD_PAYOFF), float(DL_DC_PAYOFF)),
+    ("defect", "cooperate"):    (float(DL_DC_PAYOFF), float(DL_CD_PAYOFF)),
+    ("defect", "defect"):       (float(DL_DD_PAYOFF), float(DL_DD_PAYOFF)),
+}
+
+# -- Harmony --
+_HM_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(HM_CC_PAYOFF), float(HM_CC_PAYOFF)),
+    ("cooperate", "defect"):    (float(HM_CD_PAYOFF), float(HM_DC_PAYOFF)),
+    ("defect", "cooperate"):    (float(HM_DC_PAYOFF), float(HM_CD_PAYOFF)),
+    ("defect", "defect"):       (float(HM_DD_PAYOFF), float(HM_DD_PAYOFF)),
+}
+
+# -- Register all games --
+
+EXTENDED_MATRIX_GAMES: dict[str, GameConfig] = {
+    "matching_pennies": GameConfig(
+        name="Matching Pennies",
+        description=(
+            "A pure zero-sum game. The matcher wins if both choose the same "
+            "side; the mismatcher wins if they differ. The only Nash "
+            "equilibrium is a mixed strategy of equal randomization."
+        ),
+        actions=["heads", "tails"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_MP_MATRIX),
+    ),
+    "rock_paper_scissors": GameConfig(
+        name="Rock-Paper-Scissors",
+        description=(
+            "A three-action zero-sum game: rock beats scissors, scissors "
+            "beats paper, paper beats rock. The unique Nash equilibrium "
+            "is uniform randomization over all three actions."
+        ),
+        actions=["rock", "paper", "scissors"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_RPS_MATRIX),
+    ),
+    "battle_of_the_sexes": GameConfig(
+        name="Battle of the Sexes",
+        description=(
+            "Two players want to coordinate but have different preferences. "
+            "The first player prefers opera, the second prefers football. "
+            "Both prefer any coordination over miscoordination. Two pure "
+            "Nash equilibria exist at (opera, opera) and (football, football)."
+        ),
+        actions=["opera", "football"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_BOS_MATRIX),
+    ),
+    "pure_coordination": GameConfig(
+        name="Pure Coordination",
+        description=(
+            "Two players receive a positive payoff only when they choose "
+            "the same action. Both (left, left) and (right, right) are "
+            "Nash equilibria. Tests whether agents can converge on a focal "
+            "point without communication."
+        ),
+        actions=["left", "right"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_PC_MATRIX),
+    ),
+    "deadlock": GameConfig(
+        name="Deadlock",
+        description=(
+            "Similar to the Prisoner's Dilemma but with different payoff "
+            "ordering: DC > DD > CC > CD. Both players prefer mutual "
+            "defection over mutual cooperation. The unique Nash equilibrium "
+            "is (defect, defect) and it is also Pareto optimal."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_DL_MATRIX),
+    ),
+    "harmony": GameConfig(
+        name="Harmony",
+        description=(
+            "The opposite of a social dilemma: cooperation is the dominant "
+            "strategy for both players. Payoff ordering CC > DC > CD > DD "
+            "means rational self-interest naturally leads to the socially "
+            "optimal outcome of mutual cooperation."
+        ),
+        actions=["cooperate", "defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_HM_MATRIX),
+    ),
+}
+
+GAMES.update(EXTENDED_MATRIX_GAMES)

common/games_ext/nplayer.py

@@ -0,0 +1,143 @@
+"""N-player social dilemma games for KantBench.
+
+Modeled as one agent vs one opponent (representing aggregate of others).
+"""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.auction_nplayer_constants import (
+    COMMONS_RESOURCE_CAPACITY, COMMONS_MAX_EXTRACTION,
+    COMMONS_DEPLETION_PENALTY,
+    VOLUNTEER_BENEFIT, VOLUNTEER_COST, VOLUNTEER_NO_VOL,
+    EL_FAROL_ATTEND_REWARD, EL_FAROL_CROWD_PENALTY, EL_FAROL_STAY_HOME,
+    EL_FAROL_CAPACITY,
+)
+
+_ONE = int(bool(True))
+_ZERO_F = float()
+
+
+# -- Tragedy of the Commons --
+
+def _commons_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Resource extraction game.
+
+    Each player extracts from a shared resource. If total extraction
+    exceeds capacity, both suffer a depletion penalty.
+    """
+    p_extract = int(player_action.rsplit("_", _ONE)[_ONE])
+    o_extract = int(opponent_action.rsplit("_", _ONE)[_ONE])
+    total = p_extract + o_extract
+
+    if total > COMMONS_RESOURCE_CAPACITY:
+        return (float(COMMONS_DEPLETION_PENALTY), float(COMMONS_DEPLETION_PENALTY))
+
+    return (float(p_extract), float(o_extract))
+
+
+_COMMONS_ACTIONS = [
+    f"extract_{i}" for i in range(COMMONS_MAX_EXTRACTION + _ONE)
+]
+
+
+# -- Volunteer's Dilemma --
+
+def _volunteer_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """At least one must volunteer for everyone to benefit.
+
+    Volunteering costs the volunteer but benefits all.
+    If nobody volunteers, everyone gets nothing.
+    """
+    p_vol = player_action == "volunteer"
+    o_vol = opponent_action == "volunteer"
+
+    if not p_vol and not o_vol:
+        return (float(VOLUNTEER_NO_VOL), float(VOLUNTEER_NO_VOL))
+
+    p_pay = float(VOLUNTEER_BENEFIT - VOLUNTEER_COST) if p_vol else float(VOLUNTEER_BENEFIT)
+    o_pay = float(VOLUNTEER_BENEFIT - VOLUNTEER_COST) if o_vol else float(VOLUNTEER_BENEFIT)
+    return (p_pay, o_pay)
+
+
+# -- El Farol Bar Problem --
+
+def _el_farol_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Bar attendance decision game.
+
+    Going to the bar is fun if few attend (under capacity), but
+    unpleasant if crowded. Staying home gives a moderate fixed payoff.
+    """
+    p_goes = player_action == "attend"
+    o_goes = opponent_action == "attend"
+
+    attendees = int(p_goes) + int(o_goes)
+    crowded = attendees > _ONE
+
+    if not p_goes:
+        p_pay = float(EL_FAROL_STAY_HOME)
+    elif crowded:
+        p_pay = float(EL_FAROL_CROWD_PENALTY)
+    else:
+        p_pay = float(EL_FAROL_ATTEND_REWARD)
+
+    if not o_goes:
+        o_pay = float(EL_FAROL_STAY_HOME)
+    elif crowded:
+        o_pay = float(EL_FAROL_CROWD_PENALTY)
+    else:
+        o_pay = float(EL_FAROL_ATTEND_REWARD)
+
+    return (p_pay, o_pay)
+
+
+# -- Register --
+
+NPLAYER_GAMES: dict[str, GameConfig] = {
+    "tragedy_of_commons": GameConfig(
+        name="Tragedy of the Commons",
+        description=(
+            "Players extract resources from a shared pool. Individual "
+            "incentive is to extract more, but if total extraction exceeds "
+            "the sustainable capacity, the resource collapses and everyone "
+            "suffers. Models environmental and resource management dilemmas."
+        ),
+        actions=_COMMONS_ACTIONS,
+        game_type="commons",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_commons_payoff,
+    ),
+    "volunteer_dilemma": GameConfig(
+        name="Volunteer's Dilemma",
+        description=(
+            "At least one player must volunteer (at personal cost) for "
+            "everyone to receive a benefit. If nobody volunteers, all get "
+            "nothing. Models bystander effects and public good provision."
+        ),
+        actions=["volunteer", "abstain"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_volunteer_payoff,
+    ),
+    "el_farol": GameConfig(
+        name="El Farol Bar Problem",
+        description=(
+            "Each player decides whether to attend a bar. If attendance "
+            "is below capacity, going is better than staying home. If the "
+            "bar is crowded, staying home is better. Models minority games "
+            "and congestion dynamics."
+        ),
+        actions=["attend", "stay_home"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_el_farol_payoff,
+    ),
+}
+
+GAMES.update(NPLAYER_GAMES)

common/games_ext/sequential.py

@@ -0,0 +1,140 @@
+"""Sequential (extensive-form) games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import SINGLE_SHOT_ROUNDS, DEFAULT_NUM_ROUNDS
+from constant_definitions.sequential_constants import (
+    DICTATOR_ENDOWMENT,
+    CENTIPEDE_INITIAL_POT, CENTIPEDE_GROWTH_MULTIPLIER, CENTIPEDE_MAX_STAGES,
+    CENTIPEDE_LARGE_SHARE_NUMERATOR, CENTIPEDE_LARGE_SHARE_DENOMINATOR,
+    CENTIPEDE_SMALL_SHARE_NUMERATOR, CENTIPEDE_SMALL_SHARE_DENOMINATOR,
+    STACKELBERG_DEMAND_INTERCEPT, STACKELBERG_DEMAND_SLOPE,
+    STACKELBERG_MARGINAL_COST, STACKELBERG_MAX_QUANTITY,
+)
+
+_ONE = int(bool(True))
+
+
+# -- Dictator Game --
+
+def _dictator_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Dictator allocates from endowment; recipient has no choice."""
+    amount = int(player_action.rsplit("_", _ONE)[_ONE])
+    dictator_keeps = float(DICTATOR_ENDOWMENT - amount)
+    recipient_gets = float(amount)
+    return (dictator_keeps, recipient_gets)
+
+
+_DICTATOR_ACTIONS = [
+    f"give_{i}" for i in range(DICTATOR_ENDOWMENT + _ONE)
+]
+
+
+# -- Centipede Game --
+
+def _centipede_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Alternating pass/take game with growing pot.
+
+    Actions encode the stage: 'take_N' means take at stage N,
+    'pass_all' means pass through all stages.
+    The opponent strategy similarly responds with take or pass.
+    """
+    if player_action == "pass_all":
+        player_stage = CENTIPEDE_MAX_STAGES + _ONE
+    else:
+        player_stage = int(player_action.rsplit("_", _ONE)[_ONE])
+
+    if opponent_action == "pass_all":
+        opp_stage = CENTIPEDE_MAX_STAGES + _ONE
+    else:
+        opp_stage = int(opponent_action.rsplit("_", _ONE)[_ONE])
+
+    take_stage = min(player_stage, opp_stage)
+
+    pot = CENTIPEDE_INITIAL_POT
+    for _ in range(take_stage):
+        pot = pot * CENTIPEDE_GROWTH_MULTIPLIER
+
+    large = pot * CENTIPEDE_LARGE_SHARE_NUMERATOR // CENTIPEDE_LARGE_SHARE_DENOMINATOR
+    small = pot * CENTIPEDE_SMALL_SHARE_NUMERATOR // CENTIPEDE_SMALL_SHARE_DENOMINATOR
+
+    if player_stage <= opp_stage:
+        return (float(large), float(small))
+    return (float(small), float(large))
+
+
+_CENTIPEDE_ACTIONS = [
+    f"take_{i}" for i in range(CENTIPEDE_MAX_STAGES + _ONE)
+] + ["pass_all"]
+
+
+# -- Stackelberg Competition --
+
+def _stackelberg_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Stackelberg duopoly: leader (player) and follower (opponent).
+
+    Profit = (demand_intercept - slope * (q_leader + q_follower) - cost) * q
+    """
+    q_leader = int(player_action.rsplit("_", _ONE)[_ONE])
+    q_follower = int(opponent_action.rsplit("_", _ONE)[_ONE])
+
+    total_q = q_leader + q_follower
+    price = STACKELBERG_DEMAND_INTERCEPT - STACKELBERG_DEMAND_SLOPE * total_q
+
+    leader_profit = float((price - STACKELBERG_MARGINAL_COST) * q_leader)
+    follower_profit = float((price - STACKELBERG_MARGINAL_COST) * q_follower)
+    return (leader_profit, follower_profit)
+
+
+_STACKELBERG_ACTIONS = [
+    f"produce_{i}" for i in range(STACKELBERG_MAX_QUANTITY + _ONE)
+]
+
+
+# -- Register --
+
+SEQUENTIAL_GAMES: dict[str, GameConfig] = {
+    "dictator": GameConfig(
+        name="Dictator Game",
+        description=(
+            "One player (the dictator) decides how to split an endowment "
+            "with a passive recipient who has no say. Tests fairness "
+            "preferences and altruistic behavior when there is no strategic "
+            "incentive to share."
+        ),
+        actions=_DICTATOR_ACTIONS,
+        game_type="dictator",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_dictator_payoff,
+    ),
+    "centipede": GameConfig(
+        name="Centipede Game",
+        description=(
+            "Players alternate deciding to take or pass. Each pass doubles "
+            "the pot. The taker gets the larger share while the other gets "
+            "the smaller share. Backward induction predicts immediate taking, "
+            "but cooperation through passing yields higher joint payoffs."
+        ),
+        actions=_CENTIPEDE_ACTIONS,
+        game_type="centipede",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_centipede_payoff,
+    ),
+    "stackelberg": GameConfig(
+        name="Stackelberg Competition",
+        description=(
+            "A quantity-setting duopoly where the leader commits to a "
+            "production quantity first, and the follower observes and "
+            "responds. The leader can exploit first-mover advantage. "
+            "Price is determined by total market quantity."
+        ),
+        actions=_STACKELBERG_ACTIONS,
+        game_type="stackelberg",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_stackelberg_payoff,
+    ),
+}
+
+GAMES.update(SEQUENTIAL_GAMES)

common/games_info/bayesian.py

@@ -0,0 +1,125 @@
+"""Bayesian and incomplete information games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.batch4.bayesian_constants import (
+    GG_ATTACK_ATTACK, GG_ATTACK_WAIT, GG_WAIT_ATTACK, GG_WAIT_WAIT,
+    JV_CONVICT_CONVICT, JV_ACQUIT_ACQUIT, JV_SPLIT_VOTE,
+    IC_SIGNAL_SIGNAL, IC_SIGNAL_CROWD, IC_CROWD_SIGNAL, IC_CROWD_CROWD,
+    ASI_REVEAL_REVEAL, ASI_REVEAL_HIDE, ASI_HIDE_REVEAL, ASI_HIDE_HIDE,
+)
+
+
+# -- Global Game (regime change / bank run under private signals) --
+_GG: dict[tuple[str, str], tuple[float, float]] = {
+    ("attack", "attack"):   (float(GG_ATTACK_ATTACK), float(GG_ATTACK_ATTACK)),
+    ("attack", "wait"):     (float(GG_ATTACK_WAIT), float(GG_WAIT_ATTACK)),
+    ("wait", "attack"):     (float(GG_WAIT_ATTACK), float(GG_ATTACK_WAIT)),
+    ("wait", "wait"):       (float(GG_WAIT_WAIT), float(GG_WAIT_WAIT)),
+}
+
+
+# -- Jury Voting (unanimity rule for conviction) --
+_JV: dict[tuple[str, str], tuple[float, float]] = {
+    ("guilty", "guilty"):   (float(JV_CONVICT_CONVICT), float(JV_CONVICT_CONVICT)),
+    ("guilty", "acquit"):   (float(JV_SPLIT_VOTE), float(JV_SPLIT_VOTE)),
+    ("acquit", "guilty"):   (float(JV_SPLIT_VOTE), float(JV_SPLIT_VOTE)),
+    ("acquit", "acquit"):   (float(JV_ACQUIT_ACQUIT), float(JV_ACQUIT_ACQUIT)),
+}
+
+
+# -- Information Cascade (follow own signal vs follow crowd) --
+_IC: dict[tuple[str, str], tuple[float, float]] = {
+    ("follow_signal", "follow_signal"): (
+        float(IC_SIGNAL_SIGNAL), float(IC_SIGNAL_SIGNAL),
+    ),
+    ("follow_signal", "follow_crowd"): (
+        float(IC_SIGNAL_CROWD), float(IC_CROWD_SIGNAL),
+    ),
+    ("follow_crowd", "follow_signal"): (
+        float(IC_CROWD_SIGNAL), float(IC_SIGNAL_CROWD),
+    ),
+    ("follow_crowd", "follow_crowd"): (
+        float(IC_CROWD_CROWD), float(IC_CROWD_CROWD),
+    ),
+}
+
+
+# -- Adverse Selection (reveal or hide private type) --
+_ASI: dict[tuple[str, str], tuple[float, float]] = {
+    ("reveal_type", "reveal_type"): (
+        float(ASI_REVEAL_REVEAL), float(ASI_REVEAL_REVEAL),
+    ),
+    ("reveal_type", "hide_type"): (
+        float(ASI_REVEAL_HIDE), float(ASI_HIDE_REVEAL),
+    ),
+    ("hide_type", "reveal_type"): (
+        float(ASI_HIDE_REVEAL), float(ASI_REVEAL_HIDE),
+    ),
+    ("hide_type", "hide_type"): (
+        float(ASI_HIDE_HIDE), float(ASI_HIDE_HIDE),
+    ),
+}
+
+
+# -- Register --
+BAYESIAN_GAMES: dict[str, GameConfig] = {
+    "global_game": GameConfig(
+        name="Global Game",
+        description=(
+            "A coordination game modeling regime change or bank runs under "
+            "incomplete information. Players receive private signals about "
+            "fundamentals and choose to attack or wait. Successful coordination "
+            "on attack yields high payoffs but unilateral attack is costly. "
+            "Tests strategic behavior under private information."
+        ),
+        actions=["attack", "wait"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_GG),
+    ),
+    "jury_voting": GameConfig(
+        name="Jury Voting Game",
+        description=(
+            "Two jurors simultaneously vote guilty or acquit under a unanimity "
+            "rule. Conviction requires both voting guilty. Each juror has a "
+            "private signal about the defendant. Strategic voting may differ "
+            "from sincere voting. Tests information aggregation under voting."
+        ),
+        actions=["guilty", "acquit"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_JV),
+    ),
+    "information_cascade": GameConfig(
+        name="Information Cascade Game",
+        description=(
+            "Players choose whether to follow their own private signal or "
+            "follow the crowd. Independent signal-following leads to better "
+            "information aggregation while crowd-following creates herding. "
+            "Asymmetric payoffs reflect the benefit of diverse information. "
+            "Tests independence of judgment under social influence."
+        ),
+        actions=["follow_signal", "follow_crowd"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_IC),
+    ),
+    "adverse_selection_insurance": GameConfig(
+        name="Adverse Selection Insurance Game",
+        description=(
+            "An insurance market game with asymmetric information. Each player "
+            "can reveal their private risk type for efficient pricing or hide "
+            "it to exploit information asymmetry. Mutual revelation enables "
+            "fair pricing. Hiding while the other reveals creates adverse "
+            "selection profit. Tests screening and pooling dynamics."
+        ),
+        actions=["reveal_type", "hide_type"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_ASI),
+    ),
+}
+
+GAMES.update(BAYESIAN_GAMES)

common/games_info/communication.py

@@ -0,0 +1,162 @@
+"""Communication and mediation games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.var.communication_constants import (
+    CTPD_REWARD, CTPD_TEMPTATION, CTPD_PUNISHMENT, CTPD_SUCKER,
+    COMMIT_COST,
+    CE_FOLLOW_FOLLOW, CE_FOLLOW_DEVIATE,
+    CE_DEVIATE_FOLLOW, CE_DEVIATE_DEVIATE,
+    FP_MATCH_PAYOFF, FP_MISMATCH_PAYOFF,
+    MG_ACCEPT_ACCEPT, MG_ACCEPT_REJECT,
+    MG_REJECT_ACCEPT, MG_REJECT_REJECT,
+)
+
+_ONE = int(bool(True))
+_ZERO_F = float()
+
+# -- Cheap Talk PD (message + action, messages are non-binding) --
+_CTPD_BASE: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(CTPD_REWARD), float(CTPD_REWARD)),
+    ("cooperate", "defect"):    (float(CTPD_SUCKER), float(CTPD_TEMPTATION)),
+    ("defect", "cooperate"):    (float(CTPD_TEMPTATION), float(CTPD_SUCKER)),
+    ("defect", "defect"):       (float(CTPD_PUNISHMENT), float(CTPD_PUNISHMENT)),
+}
+
+
+def _cheap_talk_pd_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Message is cheap talk; payoff depends only on actual action."""
+    actual_p = pa.rsplit("_", _ONE)[_ONE]
+    actual_o = oa.rsplit("_", _ONE)[_ONE]
+    return _CTPD_BASE[(actual_p, actual_o)]
+
+
+_CTPD_ACTS = [
+    "msg_coop_cooperate", "msg_coop_defect",
+    "msg_def_cooperate", "msg_def_defect",
+]
+
+
+# -- Binding Commitment (costly commitment mechanism) --
+_CC = float(CTPD_REWARD)
+_CS = float(CTPD_SUCKER)
+_CT = float(CTPD_TEMPTATION)
+_CP = float(CTPD_PUNISHMENT)
+_COST = float(COMMIT_COST)
+
+_BIND_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("commit_coop", "commit_coop"):  (_CC - _COST, _CC - _COST),
+    ("commit_coop", "free_coop"):    (_CC - _COST, _CC),
+    ("commit_coop", "free_defect"):  (_CS - _COST, _CT),
+    ("free_coop", "commit_coop"):    (_CC, _CC - _COST),
+    ("free_coop", "free_coop"):      (_CC, _CC),
+    ("free_coop", "free_defect"):    (_CS, _CT),
+    ("free_defect", "commit_coop"):  (_CT, _CS - _COST),
+    ("free_defect", "free_coop"):    (_CT, _CS),
+    ("free_defect", "free_defect"):  (_CP, _CP),
+}
+
+
+# -- Correlated Equilibrium (follow external mediator or deviate) --
+_CE: dict[tuple[str, str], tuple[float, float]] = {
+    ("follow", "follow"):   (float(CE_FOLLOW_FOLLOW), float(CE_FOLLOW_FOLLOW)),
+    ("follow", "deviate"):  (float(CE_FOLLOW_DEVIATE), float(CE_DEVIATE_FOLLOW)),
+    ("deviate", "follow"):  (float(CE_DEVIATE_FOLLOW), float(CE_FOLLOW_DEVIATE)),
+    ("deviate", "deviate"): (float(CE_DEVIATE_DEVIATE), float(CE_DEVIATE_DEVIATE)),
+}
+
+
+# -- Focal Point (multi-option coordination without communication) --
+_FP_MATCH = float(FP_MATCH_PAYOFF)
+_FP_MISS = float(FP_MISMATCH_PAYOFF)
+_FP_OPTIONS = ["choose_red", "choose_green", "choose_blue", "choose_yellow"]
+
+
+def _focal_point_payoff(pa: str, oa: str) -> tuple[float, float]:
+    if pa == oa:
+        return (_FP_MATCH, _FP_MATCH)
+    return (_FP_MISS, _FP_MISS)
+
+
+# -- Mediated Game (accept or reject third-party mediation) --
+_MED: dict[tuple[str, str], tuple[float, float]] = {
+    ("accept", "accept"):   (float(MG_ACCEPT_ACCEPT), float(MG_ACCEPT_ACCEPT)),
+    ("accept", "reject"):   (float(MG_ACCEPT_REJECT), float(MG_REJECT_ACCEPT)),
+    ("reject", "accept"):   (float(MG_REJECT_ACCEPT), float(MG_ACCEPT_REJECT)),
+    ("reject", "reject"):   (float(MG_REJECT_REJECT), float(MG_REJECT_REJECT)),
+}
+
+
+# -- Register --
+COMMUNICATION_GAMES: dict[str, GameConfig] = {
+    "cheap_talk_pd": GameConfig(
+        name="Cheap Talk Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma where each player sends a non-binding "
+            "message before acting. Messages are cheap talk: costless and "
+            "unenforceable. Payoffs depend only on actual actions. Tests "
+            "whether non-binding communication improves cooperation."
+        ),
+        actions=_CTPD_ACTS,
+        game_type="cheap_talk_pd",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_cheap_talk_pd_payoff,
+    ),
+    "binding_commitment": GameConfig(
+        name="Binding Commitment Game",
+        description=(
+            "A Prisoner's Dilemma where players can pay a cost to make a "
+            "binding commitment to cooperate. The commitment is credible "
+            "but costly. Tests whether costly signaling through commitment "
+            "mechanisms changes equilibrium behavior."
+        ),
+        actions=["commit_coop", "free_coop", "free_defect"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_BIND_MATRIX),
+    ),
+    "correlated_equilibrium": GameConfig(
+        name="Correlated Equilibrium Game",
+        description=(
+            "An external mediator sends private recommendations to each "
+            "player. Following yields an efficient correlated outcome. "
+            "Deviating can be profitable if the other follows but mutual "
+            "deviation destroys coordination gains. Tests trust in "
+            "external coordination mechanisms."
+        ),
+        actions=["follow", "deviate"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_CE),
+    ),
+    "focal_point": GameConfig(
+        name="Focal Point Game",
+        description=(
+            "Players must coordinate on the same choice from four options "
+            "without communication. Only matching yields a positive payoff. "
+            "Tests Schelling focal point reasoning and the ability to "
+            "identify salient coordination targets."
+        ),
+        actions=_FP_OPTIONS,
+        game_type="focal_point",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_focal_point_payoff,
+    ),
+    "mediated_game": GameConfig(
+        name="Mediated Game",
+        description=(
+            "A dispute between two players where a mediator proposes a "
+            "fair resolution. Both accepting yields an efficient outcome. "
+            "Rejecting while the other accepts gives an advantage but "
+            "mutual rejection leads to costly breakdown. Tests willingness "
+            "to accept third-party dispute resolution."
+        ),
+        actions=["accept", "reject"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_MED),
+    ),
+}
+
+GAMES.update(COMMUNICATION_GAMES)

common/games_info/contracts.py

@@ -0,0 +1,125 @@
+"""Principal-agent and contract theory games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.dynamic_constants import (
+    MH_BASE_OUTPUT, MH_EFFORT_BOOST, MH_EFFORT_COST, MH_MAX_BONUS,
+    SCR_HIGH_TYPE_VALUE, SCR_LOW_TYPE_VALUE,
+    SCR_PREMIUM_PRICE, SCR_BASIC_PRICE,
+    GE_MAX_WAGE, GE_MAX_EFFORT,
+    GE_EFFORT_COST_PER_UNIT, GE_PRODUCTIVITY_PER_EFFORT,
+)
+
+_ONE = int(bool(True))
+_ZERO = int()
+
+
+# -- Moral Hazard --
+def _moral_hazard_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Principal sets bonus; agent chooses effort.
+
+    Principal: output - bonus if agent works.
+    Agent: bonus - effort_cost if working, base if shirking.
+    """
+    bonus = int(player_action.rsplit("_", _ONE)[_ONE])
+    works = opponent_action == "work"
+    output = MH_BASE_OUTPUT + MH_EFFORT_BOOST if works else MH_BASE_OUTPUT
+    principal_pay = float(output - bonus)
+    agent_pay = float(bonus - MH_EFFORT_COST) if works else float(bonus)
+    return (principal_pay, agent_pay)
+
+
+_MH_BONUS_ACTIONS = [f"bonus_{i}" for i in range(MH_MAX_BONUS + _ONE)]
+
+
+# -- Screening --
+def _screening_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Principal offers contract menu; agent self-selects.
+
+    Agent picks premium or basic contract based on private type.
+    """
+    if player_action == "offer_premium":
+        price = SCR_PREMIUM_PRICE
+    else:
+        price = SCR_BASIC_PRICE
+
+    if opponent_action == "choose_premium":
+        buyer_value = SCR_HIGH_TYPE_VALUE
+        seller_pay = float(SCR_PREMIUM_PRICE)
+        buyer_pay = float(buyer_value - SCR_PREMIUM_PRICE)
+    else:
+        buyer_value = SCR_LOW_TYPE_VALUE
+        seller_pay = float(SCR_BASIC_PRICE)
+        buyer_pay = float(buyer_value - SCR_BASIC_PRICE)
+
+    return (seller_pay, buyer_pay)
+
+
+# -- Gift Exchange --
+def _gift_exchange_payoff(
+    player_action: str, opponent_action: str,
+) -> tuple[float, float]:
+    """Employer offers wage; worker chooses effort.
+
+    Employer profit = productivity * effort - wage.
+    Worker payoff = wage - effort_cost * effort.
+    """
+    wage = int(player_action.rsplit("_", _ONE)[_ONE])
+    effort = int(opponent_action.rsplit("_", _ONE)[_ONE])
+    employer_pay = float(GE_PRODUCTIVITY_PER_EFFORT * effort - wage)
+    worker_pay = float(wage - GE_EFFORT_COST_PER_UNIT * effort)
+    return (employer_pay, worker_pay)
+
+
+_GE_WAGE_ACTIONS = [f"wage_{i}" for i in range(GE_MAX_WAGE + _ONE)]
+
+
+# -- Register --
+CONTRACT_GAMES: dict[str, GameConfig] = {
+    "moral_hazard": GameConfig(
+        name="Moral Hazard (Principal-Agent)",
+        description=(
+            "A principal offers a bonus contract; an agent with "
+            "unobservable effort decides whether to work or shirk. "
+            "Tests optimal incentive design and the tradeoff between "
+            "motivation and rent extraction."
+        ),
+        actions=_MH_BONUS_ACTIONS,
+        game_type="moral_hazard",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_moral_hazard_payoff,
+    ),
+    "screening": GameConfig(
+        name="Screening Game",
+        description=(
+            "An uninformed principal offers a menu of contracts; "
+            "agents of different types self-select. Tests understanding "
+            "of incentive compatibility and separating mechanisms "
+            "as in Rothschild-Stiglitz insurance models."
+        ),
+        actions=["offer_premium", "offer_basic"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_screening_payoff,
+    ),
+    "gift_exchange": GameConfig(
+        name="Gift Exchange Game",
+        description=(
+            "An employer offers a wage; a worker chooses effort. "
+            "Nash prediction is minimal effort regardless of wage, "
+            "but reciprocity often leads to higher wages eliciting "
+            "higher effort. Tests fairness-driven behavior."
+        ),
+        actions=_GE_WAGE_ACTIONS,
+        game_type="gift_exchange",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_gift_exchange_payoff,
+    ),
+}
+
+GAMES.update(CONTRACT_GAMES)

common/games_info/network.py

@@ -0,0 +1,120 @@
+"""Network and security interaction games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.batch4.network_constants import (
+    SG_DEFEND_SUCCESS, SG_ATTACK_FAIL, SG_DEFEND_FAIL, SG_ATTACK_SUCCESS,
+    LF_MUTUAL_CONNECT, LF_UNILATERAL_COST, LF_MUTUAL_ISOLATE,
+    TWP_CC, TWP_CD, TWP_DC, TWP_DD,
+    TWP_CP, TWP_PC, TWP_DP, TWP_PD, TWP_PP,
+    DG_EARLY_EARLY, DG_EARLY_LATE, DG_LATE_EARLY, DG_LATE_LATE,
+)
+
+
+# -- Security Game (defender allocates, attacker targets) --
+_SG: dict[tuple[str, str], tuple[float, float]] = {
+    ("target_a", "target_a"): (float(SG_DEFEND_SUCCESS), float(SG_ATTACK_FAIL)),
+    ("target_a", "target_b"): (float(SG_DEFEND_FAIL), float(SG_ATTACK_SUCCESS)),
+    ("target_b", "target_a"): (float(SG_DEFEND_FAIL), float(SG_ATTACK_SUCCESS)),
+    ("target_b", "target_b"): (float(SG_DEFEND_SUCCESS), float(SG_ATTACK_FAIL)),
+}
+
+
+# -- Link Formation (bilateral consent required) --
+_LF_CON = float(LF_MUTUAL_CONNECT)
+_LF_UNI = float(LF_UNILATERAL_COST)
+_LF_ISO = float(LF_MUTUAL_ISOLATE)
+
+_LF: dict[tuple[str, str], tuple[float, float]] = {
+    ("connect", "connect"): (_LF_CON, _LF_CON),
+    ("connect", "isolate"): (_LF_UNI, _LF_ISO),
+    ("isolate", "connect"): (_LF_ISO, _LF_UNI),
+    ("isolate", "isolate"): (_LF_ISO, _LF_ISO),
+}
+
+
+# -- Trust with Punishment (3x3: cooperate, defect, punish) --
+_TWP: dict[tuple[str, str], tuple[float, float]] = {
+    ("cooperate", "cooperate"): (float(TWP_CC), float(TWP_CC)),
+    ("cooperate", "defect"):    (float(TWP_CD), float(TWP_DC)),
+    ("cooperate", "punish"):    (float(TWP_CP), float(TWP_PC)),
+    ("defect", "cooperate"):    (float(TWP_DC), float(TWP_CD)),
+    ("defect", "defect"):       (float(TWP_DD), float(TWP_DD)),
+    ("defect", "punish"):       (float(TWP_DP), float(TWP_PD)),
+    ("punish", "cooperate"):    (float(TWP_PC), float(TWP_CP)),
+    ("punish", "defect"):       (float(TWP_PD), float(TWP_DP)),
+    ("punish", "punish"):       (float(TWP_PP), float(TWP_PP)),
+}
+
+
+# -- Dueling Game (fire timing) --
+_DG: dict[tuple[str, str], tuple[float, float]] = {
+    ("fire_early", "fire_early"): (float(DG_EARLY_EARLY), float(DG_EARLY_EARLY)),
+    ("fire_early", "fire_late"):  (float(DG_EARLY_LATE), float(DG_LATE_EARLY)),
+    ("fire_late", "fire_early"):  (float(DG_LATE_EARLY), float(DG_EARLY_LATE)),
+    ("fire_late", "fire_late"):   (float(DG_LATE_LATE), float(DG_LATE_LATE)),
+}
+
+
+# -- Register --
+NETWORK_GAMES: dict[str, GameConfig] = {
+    "security_game": GameConfig(
+        name="Security Game",
+        description=(
+            "An attacker-defender game where the defender allocates protection "
+            "to one of two targets and the attacker simultaneously chooses "
+            "which target to attack. Matching the attacker's target means a "
+            "successful defense. Misallocation lets the attacker succeed. "
+            "Tests strategic resource allocation under adversarial uncertainty."
+        ),
+        actions=["target_a", "target_b"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_SG),
+    ),
+    "link_formation": GameConfig(
+        name="Link Formation Game",
+        description=(
+            "A network formation game where two players simultaneously decide "
+            "whether to form a connection. A link forms only when both agree. "
+            "Mutual connection yields network benefits. Unilateral connection "
+            "attempt is costly. Mutual isolation yields nothing. Tests "
+            "bilateral consent in network formation."
+        ),
+        actions=["connect", "isolate"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_LF),
+    ),
+    "trust_with_punishment": GameConfig(
+        name="Trust with Punishment Game",
+        description=(
+            "An extended trust game where players can cooperate or defect as "
+            "in the standard Prisoner's Dilemma plus a costly punishment "
+            "action. Punishing reduces the opponent's payoff but also costs "
+            "the punisher. Tests whether altruistic punishment enforces "
+            "cooperation even at personal cost."
+        ),
+        actions=["cooperate", "defect", "punish"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_TWP),
+    ),
+    "dueling_game": GameConfig(
+        name="Dueling Game",
+        description=(
+            "A timing game where two players simultaneously choose when to "
+            "fire: early for a safe but moderate payoff or late for higher "
+            "accuracy. Firing early against a late opponent is advantageous. "
+            "Mutual late firing yields better outcomes than mutual early. "
+            "Tests patience versus preemption under uncertainty."
+        ),
+        actions=["fire_early", "fire_late"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_DG),
+    ),
+}
+
+GAMES.update(NETWORK_GAMES)

common/games_info/signaling.py

@@ -0,0 +1,142 @@
+"""Signaling and incomplete information games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.signaling_constants import (
+    BQ_TOUGH_BEER_PAYOFF, BQ_TOUGH_QUICHE_PAYOFF,
+    BQ_WEAK_BEER_PAYOFF, BQ_WEAK_QUICHE_PAYOFF,
+    BQ_CHALLENGE_COST, BQ_NO_CHALLENGE_BONUS,
+    SPENCE_HIGH_WAGE, SPENCE_LOW_WAGE,
+    SPENCE_EDU_COST_HIGH, SPENCE_EDU_COST_LOW,
+    CT_ALIGNED_MATCH, CT_ALIGNED_MISMATCH, CT_BIAS,
+    LEMON_GOOD_QUALITY_VALUE, LEMON_BAD_QUALITY_VALUE,
+    LEMON_GOOD_SELLER_COST, LEMON_BAD_SELLER_COST, LEMON_MAX_PRICE,
+    BP_GOOD_STATE_VALUE, BP_BAD_STATE_PENALTY, BP_SAFE_PAYOFF,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+
+
+# -- Beer-Quiche (simplified as simultaneous signal-response) --
+_BQ_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("beer", "challenge"):    (float(BQ_TOUGH_BEER_PAYOFF + BQ_CHALLENGE_COST), float(_TWO)),
+    ("beer", "back_down"):    (float(BQ_TOUGH_BEER_PAYOFF + BQ_NO_CHALLENGE_BONUS), float(int())),
+    ("quiche", "challenge"):  (float(BQ_WEAK_QUICHE_PAYOFF + BQ_CHALLENGE_COST), float(-_ONE)),
+    ("quiche", "back_down"):  (float(BQ_WEAK_QUICHE_PAYOFF + BQ_NO_CHALLENGE_BONUS), float(int())),
+}
+
+
+# -- Spence Signaling (worker picks edu level, firm responds) --
+def _spence_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Worker chooses education; firm offers wage based on signal."""
+    educated = player_action == "educate"
+    high_wage = opponent_action == "high_wage"
+    wage = SPENCE_HIGH_WAGE if high_wage else SPENCE_LOW_WAGE
+    cost = SPENCE_EDU_COST_HIGH if educated else int()
+    worker_pay = float(wage - cost)
+    firm_pay = float(SPENCE_HIGH_WAGE - wage) if educated else float(SPENCE_LOW_WAGE - wage)
+    return (worker_pay, firm_pay)
+
+
+# -- Cheap Talk --
+_CT_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("signal_left", "act_left"):   (float(CT_ALIGNED_MATCH), float(CT_ALIGNED_MATCH)),
+    ("signal_left", "act_right"):  (float(CT_ALIGNED_MISMATCH), float(CT_ALIGNED_MISMATCH)),
+    ("signal_right", "act_left"):  (float(CT_ALIGNED_MISMATCH + CT_BIAS), float(CT_ALIGNED_MISMATCH)),
+    ("signal_right", "act_right"): (float(CT_ALIGNED_MATCH + CT_BIAS), float(CT_ALIGNED_MATCH)),
+}
+
+
+# -- Lemon Market --
+def _lemon_payoff(player_action: str, opponent_action: str) -> tuple[float, float]:
+    """Seller sets price; buyer decides to buy or pass."""
+    price = int(player_action.rsplit("_", _ONE)[_ONE])
+    if opponent_action == "pass":
+        return (float(int()), float(int()))
+    avg_value = (LEMON_GOOD_QUALITY_VALUE + LEMON_BAD_QUALITY_VALUE) // _TWO
+    buyer_pay = float(avg_value - price)
+    avg_cost = (LEMON_GOOD_SELLER_COST + LEMON_BAD_SELLER_COST) // _TWO
+    seller_pay = float(price - avg_cost)
+    return (seller_pay, buyer_pay)
+
+
+_LEMON_ACTIONS = [f"price_{i}" for i in range(LEMON_MAX_PRICE + _ONE)]
+
+
+# -- Bayesian Persuasion --
+_BP_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("reveal", "act"):    (float(BP_GOOD_STATE_VALUE), float(BP_GOOD_STATE_VALUE)),
+    ("reveal", "safe"):   (float(BP_SAFE_PAYOFF), float(BP_SAFE_PAYOFF)),
+    ("conceal", "act"):   (float(BP_BAD_STATE_PENALTY), float(BP_BAD_STATE_PENALTY)),
+    ("conceal", "safe"):  (float(BP_SAFE_PAYOFF), float(BP_SAFE_PAYOFF)),
+}
+
+
+# -- Register --
+SIGNALING_GAMES: dict[str, GameConfig] = {
+    "beer_quiche": GameConfig(
+        name="Beer-Quiche Game",
+        description=(
+            "A signaling game: the sender chooses a meal (beer or quiche) "
+            "to signal their type; the receiver decides whether to challenge. "
+            "Tests reasoning about sequential equilibrium and belief refinement."
+        ),
+        actions=["beer", "quiche"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_BQ_MATRIX),
+    ),
+    "spence_signaling": GameConfig(
+        name="Spence Job Market Signaling",
+        description=(
+            "A worker chooses whether to acquire education as a signal of "
+            "ability; a firm responds with a wage offer. Tests understanding "
+            "of separating versus pooling equilibria in labor markets."
+        ),
+        actions=["educate", "no_educate"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_spence_payoff,
+    ),
+    "cheap_talk": GameConfig(
+        name="Cheap Talk",
+        description=(
+            "A sender observes a state and sends a costless message; "
+            "the receiver chooses an action. Interests are partially "
+            "aligned. Tests strategic communication and credibility."
+        ),
+        actions=["signal_left", "signal_right"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_CT_MATRIX),
+    ),
+    "lemon_market": GameConfig(
+        name="Lemon Market",
+        description=(
+            "A seller with private quality information sets a price; "
+            "the buyer decides whether to purchase. Adverse selection "
+            "can cause market unraveling where only low-quality goods trade."
+        ),
+        actions=_LEMON_ACTIONS,
+        game_type="lemon",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_lemon_payoff,
+    ),
+    "bayesian_persuasion": GameConfig(
+        name="Bayesian Persuasion",
+        description=(
+            "A sender designs an information structure (reveal or conceal "
+            "the state); a receiver takes an action based on the signal. "
+            "Tests strategic information disclosure and commitment to "
+            "information policies."
+        ),
+        actions=["reveal", "conceal"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_BP_MATRIX),
+    ),
+}
+
+GAMES.update(SIGNALING_GAMES)

common/games_market/advanced.py

@@ -0,0 +1,125 @@
+"""Advanced market mechanism games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.batch4.advanced_constants import (
+    PRE_EARLY_EARLY, PRE_EARLY_LATE, PRE_LATE_EARLY, PRE_LATE_LATE,
+    PRE_OUT_PAYOFF,
+    WOG_LARGE_LARGE, WOG_LARGE_SMALL, WOG_LARGE_NONE,
+    WOG_SMALL_SMALL, WOG_SMALL_NONE, WOG_NO_GIFT,
+    PS_SAVE_PAYOFF, PS_SCORE_PAYOFF, PS_CENTER_BONUS,
+)
+
+_ZERO_F = float()
+_OUT_F = float(PRE_OUT_PAYOFF)
+
+
+# -- Preemption Game (enter_early / enter_late / stay_out) --
+_PRE: dict[tuple[str, str], tuple[float, float]] = {
+    ("enter_early", "enter_early"): (
+        float(PRE_EARLY_EARLY), float(PRE_EARLY_EARLY),
+    ),
+    ("enter_early", "enter_late"): (
+        float(PRE_EARLY_LATE), float(PRE_LATE_EARLY),
+    ),
+    ("enter_early", "stay_out"): (float(PRE_EARLY_LATE), _OUT_F),
+    ("enter_late", "enter_early"): (
+        float(PRE_LATE_EARLY), float(PRE_EARLY_LATE),
+    ),
+    ("enter_late", "enter_late"): (
+        float(PRE_LATE_LATE), float(PRE_LATE_LATE),
+    ),
+    ("enter_late", "stay_out"): (float(PRE_LATE_LATE), _OUT_F),
+    ("stay_out", "enter_early"): (_OUT_F, float(PRE_EARLY_LATE)),
+    ("stay_out", "enter_late"):  (_OUT_F, float(PRE_LATE_LATE)),
+    ("stay_out", "stay_out"):    (_OUT_F, _OUT_F),
+}
+
+
+# -- War of Gifts (gift_large / gift_small / no_gift) --
+_WOG_LL = float(WOG_LARGE_LARGE)
+_WOG_LS = float(WOG_LARGE_SMALL)
+_WOG_LN = float(WOG_LARGE_NONE)
+_WOG_SS = float(WOG_SMALL_SMALL)
+_WOG_SN = float(WOG_SMALL_NONE)
+_WOG_NG = float(WOG_NO_GIFT)
+_WOG_SL = _ZERO_F  # small loses to large
+
+_WOG: dict[tuple[str, str], tuple[float, float]] = {
+    ("gift_large", "gift_large"): (_WOG_LL, _WOG_LL),
+    ("gift_large", "gift_small"): (_WOG_LS, _WOG_SL),
+    ("gift_large", "no_gift"):    (_WOG_LN, _WOG_NG),
+    ("gift_small", "gift_large"): (_WOG_SL, _WOG_LS),
+    ("gift_small", "gift_small"): (_WOG_SS, _WOG_SS),
+    ("gift_small", "no_gift"):    (_WOG_SN, _WOG_NG),
+    ("no_gift", "gift_large"):    (_WOG_NG, _WOG_LN),
+    ("no_gift", "gift_small"):    (_WOG_NG, _WOG_SN),
+    ("no_gift", "no_gift"):       (_WOG_NG, _WOG_NG),
+}
+
+
+# -- Penalty Shootout (left / center / right, kicker vs keeper) --
+_PS_SAVE = float(PS_SAVE_PAYOFF)
+_PS_SCORE = float(PS_SCORE_PAYOFF)
+_PS_CENTER = float(PS_CENTER_BONUS)
+
+
+def _penalty_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Kicker (player) vs keeper (opponent). Match means save."""
+    if pa == oa:
+        return (_PS_SAVE, -_PS_SAVE)
+    if pa == "center":
+        score = _PS_SCORE + _PS_CENTER
+    else:
+        score = _PS_SCORE
+    return (score, -score)
+
+
+# -- Register --
+ADVANCED_GAMES: dict[str, GameConfig] = {
+    "preemption_game": GameConfig(
+        name="Preemption Game",
+        description=(
+            "A timing game with first-mover advantage. Players choose to "
+            "enter a market early (risky if both enter) or late (safer but "
+            "second-mover disadvantage) or stay out entirely for a safe "
+            "payoff. Early entry against a late opponent captures the market. "
+            "Tests preemption incentives and entry deterrence."
+        ),
+        actions=["enter_early", "enter_late", "stay_out"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_PRE),
+    ),
+    "war_of_gifts": GameConfig(
+        name="War of Gifts",
+        description=(
+            "A competitive generosity game. Players choose to give a large "
+            "gift or small gift or no gift. The largest giver wins prestige "
+            "but at material cost. Mutual large gifts cancel prestige gains. "
+            "No gift is safe but earns no prestige. Tests competitive "
+            "signaling through costly generosity."
+        ),
+        actions=["gift_large", "gift_small", "no_gift"],
+        game_type="matrix",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_WOG),
+    ),
+    "penalty_shootout": GameConfig(
+        name="Penalty Shootout",
+        description=(
+            "A zero-sum mismatch game modeling penalty kicks. The kicker "
+            "chooses left or center or right; the goalkeeper dives. Matching "
+            "means a save. Mismatching means a goal. Center kicks score a "
+            "bonus when the goalkeeper guesses wrong. Tests mixed-strategy "
+            "reasoning in adversarial settings."
+        ),
+        actions=["left", "center", "right"],
+        game_type="penalty_shootout",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_penalty_payoff,
+    ),
+}
+
+GAMES.update(ADVANCED_GAMES)

common/games_market/classic.py

@@ -0,0 +1,164 @@
+"""Classic dilemma and extended strategic games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.var.classic_constants import (
+    TD_MIN_CLAIM, TD_MAX_CLAIM, TD_BONUS,
+    DOLLAR_PRIZE, DOLLAR_MAX_BID,
+    UD_CHEAP_COST, UD_EXPENSIVE_COST, UD_CHEAP_VALUE, UD_EXPENSIVE_VALUE,
+    MINO_WIN_PAYOFF, MINO_TIE_PAYOFF,
+    RPSLS_WIN_PAYOFF, RPSLS_LOSE_PAYOFF, RPSLS_DRAW_PAYOFF,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+_ZERO_F = float()
+
+
+# -- Traveler's Dilemma --
+def _travelers_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Lower claim gets bonus; higher claim gets penalty."""
+    claim_p = int(pa.rsplit("_", _ONE)[_ONE])
+    claim_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if claim_p == claim_o:
+        return (float(claim_p), float(claim_o))
+    if claim_p < claim_o:
+        return (float(claim_p + TD_BONUS), float(claim_p - TD_BONUS))
+    return (float(claim_o - TD_BONUS), float(claim_o + TD_BONUS))
+
+
+_TD_ACTS = [f"claim_{i}" for i in range(TD_MIN_CLAIM, TD_MAX_CLAIM + _ONE)]
+
+
+# -- Dollar Auction (escalation: both pay, highest wins) --
+def _dollar_auction_payoff(pa: str, oa: str) -> tuple[float, float]:
+    bid_p = int(pa.rsplit("_", _ONE)[_ONE])
+    bid_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if bid_p > bid_o:
+        return (float(DOLLAR_PRIZE - bid_p), float(-bid_o))
+    if bid_o > bid_p:
+        return (float(-bid_p), float(DOLLAR_PRIZE - bid_o))
+    half = float(DOLLAR_PRIZE) / _TWO
+    return (half - float(bid_p), half - float(bid_o))
+
+
+_DA_ACTS = [f"bid_{i}" for i in range(DOLLAR_MAX_BID + _ONE)]
+
+
+# -- Unscrupulous Diner's Dilemma (shared bill) --
+def _diner_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each orders cheap or expensive; bill is split equally."""
+    costs = {"order_cheap": UD_CHEAP_COST, "order_expensive": UD_EXPENSIVE_COST}
+    values = {"order_cheap": UD_CHEAP_VALUE, "order_expensive": UD_EXPENSIVE_VALUE}
+    total_bill = float(costs[pa] + costs[oa])
+    each_pays = total_bill / _TWO
+    p_val = float(values[pa]) - each_pays
+    o_val = float(values[oa]) - each_pays
+    return (p_val, o_val)
+
+
+# -- Minority Game (anti-coordination: minority side wins) --
+_MINO_ACTS = ["choose_a", "choose_b", "choose_c"]
+
+
+def _minority_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """With two players: matching = both lose; differing = both win."""
+    if pa == oa:
+        return (float(MINO_TIE_PAYOFF), float(MINO_TIE_PAYOFF))
+    return (float(MINO_WIN_PAYOFF), float(MINO_WIN_PAYOFF))
+
+
+# -- Rock-Paper-Scissors-Lizard-Spock --
+_RPSLS_W = float(RPSLS_WIN_PAYOFF)
+_RPSLS_L = float(RPSLS_LOSE_PAYOFF)
+_RPSLS_D = float(RPSLS_DRAW_PAYOFF)
+
+_RPSLS_BEATS = {
+    "rock": ["scissors", "lizard"],
+    "paper": ["rock", "spock"],
+    "scissors": ["paper", "lizard"],
+    "lizard": ["paper", "spock"],
+    "spock": ["rock", "scissors"],
+}
+
+
+def _rpsls_payoff(pa: str, oa: str) -> tuple[float, float]:
+    if pa == oa:
+        return (_RPSLS_D, _RPSLS_D)
+    if oa in _RPSLS_BEATS[pa]:
+        return (_RPSLS_W, _RPSLS_L)
+    return (_RPSLS_L, _RPSLS_W)
+
+
+# -- Register --
+CLASSIC_GAMES: dict[str, GameConfig] = {
+    "travelers_dilemma": GameConfig(
+        name="Traveler's Dilemma",
+        description=(
+            "Two travelers submit claims. The lower claim sets the base "
+            "payout with a bonus for the lower claimant and a penalty for "
+            "the higher. Nash equilibrium is the minimum claim but "
+            "experimental subjects often claim high. Tests the rationality "
+            "paradox in iterative dominance reasoning."
+        ),
+        actions=_TD_ACTS,
+        game_type="travelers_dilemma",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_travelers_payoff,
+    ),
+    "dollar_auction": GameConfig(
+        name="Dollar Auction",
+        description=(
+            "An escalation game: both players bid and both pay their bids "
+            "but only the highest bidder wins the prize. Ties split the "
+            "prize. Models sunk cost escalation and commitment traps. "
+            "Tests resistance to escalation bias."
+        ),
+        actions=_DA_ACTS,
+        game_type="dollar_auction",
+        default_rounds=SINGLE_SHOT_ROUNDS,
+        payoff_fn=_dollar_auction_payoff,
+    ),
+    "unscrupulous_diner": GameConfig(
+        name="Unscrupulous Diner's Dilemma",
+        description=(
+            "Diners at a restaurant independently order cheap or expensive "
+            "meals and split the bill equally. Each prefers expensive food "
+            "but shared costs create a free-rider problem. A multiplayer "
+            "generalization of the Prisoner's Dilemma in social settings."
+        ),
+        actions=["order_cheap", "order_expensive"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_diner_payoff,
+    ),
+    "minority_game": GameConfig(
+        name="Minority Game",
+        description=(
+            "Players independently choose from three options. With two "
+            "players, matching choices yield a low tie payoff while "
+            "different choices yield a high payoff for both. Tests "
+            "anti-coordination and contrarian strategic reasoning."
+        ),
+        actions=_MINO_ACTS,
+        game_type="minority",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_minority_payoff,
+    ),
+    "rpsls": GameConfig(
+        name="Rock-Paper-Scissors-Lizard-Spock",
+        description=(
+            "An extended zero-sum game with five actions. Each action "
+            "beats two others and loses to two others. The unique Nash "
+            "equilibrium is uniform randomization. Tests strategic "
+            "reasoning in larger zero-sum action spaces."
+        ),
+        actions=["rock", "paper", "scissors", "lizard", "spock"],
+        game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_rpsls_payoff,
+    ),
+}
+
+GAMES.update(CLASSIC_GAMES)

common/games_market/contests.py

@@ -0,0 +1,188 @@
+"""Contest, conflict, and fair division games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.conflict_constants import (
+    BLOTTO_BATTLEFIELDS, BLOTTO_TOTAL_TROOPS,
+    WOA_PRIZE, WOA_COST_PER_ROUND, WOA_MAX_PERSISTENCE,
+    TULLOCK_PRIZE, TULLOCK_MAX_EFFORT,
+    INSP_VIOLATION_GAIN, INSP_FINE, INSP_INSPECTION_COST,
+    INSP_COMPLIANCE_PAYOFF,
+    RUB_SURPLUS, RUB_DISCOUNT_NUM, RUB_DISCOUNT_DEN,
+    DAC_ENDOWMENT,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+_ZERO_F = float()
+
+
+# -- Colonel Blotto (three battlefields, encoded as alloc_X_Y_Z) --
+def _blotto_payoff(pa: str, oa: str) -> tuple[float, float]:
+    """Each player allocates troops across battlefields. Most wins per field."""
+    p_parts = pa.split("_")[_ONE:]
+    o_parts = oa.split("_")[_ONE:]
+    p_wins = int()
+    o_wins = int()
+    for pv, ov in zip(p_parts, o_parts):
+        pi, oi = int(pv), int(ov)
+        if pi > oi:
+            p_wins += _ONE
+        elif oi > pi:
+            o_wins += _ONE
+    return (float(p_wins), float(o_wins))
+
+
+def _generate_blotto_actions() -> list[str]:
+    """Generate all valid troop allocations across battlefields."""
+    actions = []
+    for a in range(BLOTTO_TOTAL_TROOPS + _ONE):
+        for b in range(BLOTTO_TOTAL_TROOPS - a + _ONE):
+            c = BLOTTO_TOTAL_TROOPS - a - b
+            actions.append(f"alloc_{a}_{b}_{c}")
+    return actions
+
+
+_BLOTTO_ACTS = _generate_blotto_actions()
+
+
+# -- War of Attrition --
+def _woa_payoff(pa: str, oa: str) -> tuple[float, float]:
+    p_pers = int(pa.rsplit("_", _ONE)[_ONE])
+    o_pers = int(oa.rsplit("_", _ONE)[_ONE])
+    if p_pers > o_pers:
+        return (float(WOA_PRIZE - p_pers * WOA_COST_PER_ROUND),
+                float(-o_pers * WOA_COST_PER_ROUND))
+    if o_pers > p_pers:
+        return (float(-p_pers * WOA_COST_PER_ROUND),
+                float(WOA_PRIZE - o_pers * WOA_COST_PER_ROUND))
+    half = float(WOA_PRIZE) / _TWO
+    cost = float(p_pers * WOA_COST_PER_ROUND)
+    return (half - cost, half - cost)
+
+
+_WOA_ACTS = [f"persist_{i}" for i in range(WOA_MAX_PERSISTENCE + _ONE)]
+
+
+# -- Tullock Contest --
+def _tullock_payoff(pa: str, oa: str) -> tuple[float, float]:
+    e_p = int(pa.rsplit("_", _ONE)[_ONE])
+    e_o = int(oa.rsplit("_", _ONE)[_ONE])
+    total = e_p + e_o
+    if total == int():
+        half = float(TULLOCK_PRIZE) / _TWO
+        return (half, half)
+    p_prob = float(e_p) / float(total)
+    return (float(p_prob * TULLOCK_PRIZE - e_p),
+            float((_ONE - p_prob) * TULLOCK_PRIZE - e_o))
+
+
+_TULLOCK_ACTS = [f"effort_{i}" for i in range(TULLOCK_MAX_EFFORT + _ONE)]
+
+
+# -- Inspection Game --
+_INSP_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("violate", "inspect"):   (float(-INSP_FINE), float(INSP_FINE - INSP_INSPECTION_COST)),
+    ("violate", "no_inspect"): (float(INSP_VIOLATION_GAIN), float(int())),
+    ("comply", "inspect"):    (float(INSP_COMPLIANCE_PAYOFF), float(-INSP_INSPECTION_COST)),
+    ("comply", "no_inspect"): (float(INSP_COMPLIANCE_PAYOFF), float(int())),
+}
+
+
+# -- Rubinstein Bargaining (modeled as demand with discount) --
+def _rubinstein_payoff(pa: str, oa: str) -> tuple[float, float]:
+    d_p = int(pa.rsplit("_", _ONE)[_ONE])
+    d_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if d_p + d_o <= RUB_SURPLUS:
+        return (float(d_p), float(d_o))
+    disc_p = float(d_p * RUB_DISCOUNT_NUM) / float(RUB_DISCOUNT_DEN)
+    disc_o = float(d_o * RUB_DISCOUNT_NUM) / float(RUB_DISCOUNT_DEN)
+    if d_p + d_o <= RUB_SURPLUS + _TWO:
+        return (disc_p, disc_o)
+    return (_ZERO_F, _ZERO_F)
+
+
+_RUB_ACTS = [f"demand_{i}" for i in range(RUB_SURPLUS + _ONE)]
+
+
+# -- Divide-and-Choose --
+def _dac_payoff(pa: str, oa: str) -> tuple[float, float]:
+    split = int(pa.rsplit("_", _ONE)[_ONE])
+    choice = oa
+    left_piece = split
+    right_piece = DAC_ENDOWMENT - split
+    if choice == "choose_left":
+        return (float(right_piece), float(left_piece))
+    return (float(left_piece), float(right_piece))
+
+
+_DAC_SPLIT_ACTS = [f"split_{i}" for i in range(DAC_ENDOWMENT + _ONE)]
+
+CONTEST_GAMES: dict[str, GameConfig] = {
+    "colonel_blotto": GameConfig(
+        name="Colonel Blotto",
+        description=(
+            "Two players allocate limited troops across multiple "
+            "battlefields. The player with more troops wins each field. "
+            "Tests multi-dimensional strategic resource allocation."
+        ),
+        actions=_BLOTTO_ACTS, game_type="blotto",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_blotto_payoff,
+    ),
+    "war_of_attrition": GameConfig(
+        name="War of Attrition",
+        description=(
+            "Both players choose how long to persist. The survivor wins "
+            "a prize but both pay costs for duration. Tests endurance "
+            "strategy and rent dissipation reasoning."
+        ),
+        actions=_WOA_ACTS, game_type="war_of_attrition",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_woa_payoff,
+    ),
+    "tullock_contest": GameConfig(
+        name="Tullock Contest",
+        description=(
+            "Players invest effort to win a prize. Win probability is "
+            "proportional to relative effort. Models lobbying, rent-seeking, "
+            "and competitive R&D spending."
+        ),
+        actions=_TULLOCK_ACTS, game_type="tullock",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_tullock_payoff,
+    ),
+    "inspection_game": GameConfig(
+        name="Inspection Game",
+        description=(
+            "A potential violator chooses to comply or violate; an inspector "
+            "chooses whether to inspect. Mixed-strategy equilibrium models "
+            "compliance, auditing, and arms control verification."
+        ),
+        actions=["violate", "comply"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_INSP_MATRIX),
+    ),
+    "rubinstein_bargaining": GameConfig(
+        name="Rubinstein Bargaining",
+        description=(
+            "Players make simultaneous demands over a surplus. Compatible "
+            "demands yield immediate payoff; excessive demands are "
+            "discounted. Models alternating-offers bargaining with "
+            "time preference."
+        ),
+        actions=_RUB_ACTS, game_type="rubinstein",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_rubinstein_payoff,
+    ),
+    "divide_and_choose": GameConfig(
+        name="Divide-and-Choose",
+        description=(
+            "The divider splits a resource into two portions; the "
+            "chooser takes their preferred portion. The optimal "
+            "strategy for the divider is an even split. Tests "
+            "envy-free fair division reasoning."
+        ),
+        actions=_DAC_SPLIT_ACTS, game_type="divide_choose",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_dac_payoff,
+    ),
+}
+
+GAMES.update(CONTEST_GAMES)

common/games_market/generated_v2.py

@@ -0,0 +1,125 @@
+"""Extended procedurally generated games for KantBench."""
+from __future__ import annotations
+
+import random as _rand
+
+from common.games import GAMES, GameConfig
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS
+from constant_definitions.var.generated_ext_constants import (
+    RZS_SEED, RZS_MAX_PAYOFF, RZS_DEFAULT_ACTIONS,
+    RC_SEED, RC_MATCH_BONUS, RC_MISMATCH_MAX, RC_DEFAULT_ACTIONS,
+    PCHK_RESOURCE, PCHK_FIGHT_COST,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+
+
+def _action_label(index: int) -> str:
+    return chr(ord("a") + index)
+
+
+def generate_random_zero_sum(
+    num_actions: int = RZS_DEFAULT_ACTIONS,
+    max_payoff: int = RZS_MAX_PAYOFF,
+    seed: int = RZS_SEED,
+) -> GameConfig:
+    """Generate a random NxN zero-sum game."""
+    rng = _rand.Random(seed)
+    actions = [_action_label(i) for i in range(num_actions)]
+    matrix: dict[tuple[str, str], tuple[float, float]] = {}
+    for a in actions:
+        for b in actions:
+            val = float(rng.randint(-max_payoff, max_payoff))
+            matrix[(a, b)] = (val, -val)
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"Random Zero-Sum {num_actions}x{num_actions} (seed={seed})",
+        description=(
+            f"A randomly generated {num_actions}x{num_actions} zero-sum "
+            f"game. Every outcome sums to zero. Tests minimax reasoning "
+            f"in adversarial strategic settings."
+        ),
+        actions=actions, game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_payoff,
+    )
+
+
+def generate_random_coordination(
+    num_actions: int = RC_DEFAULT_ACTIONS,
+    match_bonus: int = RC_MATCH_BONUS,
+    mismatch_max: int = RC_MISMATCH_MAX,
+    seed: int = RC_SEED,
+) -> GameConfig:
+    """Generate a random NxN coordination game with diagonal bonus."""
+    rng = _rand.Random(seed)
+    actions = [_action_label(i) for i in range(num_actions)]
+    matrix: dict[tuple[str, str], tuple[float, float]] = {}
+    for a in actions:
+        for b in actions:
+            if a == b:
+                val = float(match_bonus + rng.randint(int(), mismatch_max))
+                matrix[(a, b)] = (val, val)
+            else:
+                val = float(rng.randint(int(), mismatch_max))
+                matrix[(a, b)] = (val, val)
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"Random Coordination {num_actions}x{num_actions} (seed={seed})",
+        description=(
+            f"A randomly generated {num_actions}x{num_actions} coordination "
+            f"game. Matching actions receive a bonus payoff. Tests focal "
+            f"point identification in novel coordination structures."
+        ),
+        actions=actions, game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_payoff,
+    )
+
+
+def generate_parameterized_chicken(
+    resource: int = PCHK_RESOURCE,
+    fight_cost: int = PCHK_FIGHT_COST,
+) -> GameConfig:
+    """Create a Hawk-Dove / Chicken game with custom parameters."""
+    half_v = float(resource) / _TWO
+    fight_pay = (float(resource) - float(fight_cost)) / _TWO
+    matrix: dict[tuple[str, str], tuple[float, float]] = {
+        ("hawk", "hawk"):   (fight_pay, fight_pay),
+        ("hawk", "dove"):   (float(resource), float(int())),
+        ("dove", "hawk"):   (float(int()), float(resource)),
+        ("dove", "dove"):   (half_v, half_v),
+    }
+
+    def _payoff(pa: str, oa: str) -> tuple[float, float]:
+        return matrix[(pa, oa)]
+
+    return GameConfig(
+        name=f"Chicken(V={resource},C={fight_cost})",
+        description=(
+            f"A parameterized Chicken / Hawk-Dove game with resource value "
+            f"{resource} and fight cost {fight_cost}. Tests anti-coordination "
+            f"behavior under varied incentive parameters."
+        ),
+        actions=["hawk", "dove"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_payoff,
+    )
+
+
+# -- Register default instances --
+_ZS = generate_random_zero_sum()
+_CO = generate_random_coordination()
+_CH = generate_parameterized_chicken()
+
+GENERATED_V2: dict[str, GameConfig] = {
+    "random_zero_sum_3x3": _ZS,
+    "random_coordination_3x3": _CO,
+    "parameterized_chicken": _CH,
+}
+
+GAMES.update(GENERATED_V2)

common/games_market/oligopoly.py

@@ -0,0 +1,152 @@
+"""Market competition and bargaining games for KantBench."""
+from __future__ import annotations
+
+from common.games import GAMES, GameConfig, _matrix_payoff_fn
+from constant_definitions.game_constants import DEFAULT_NUM_ROUNDS, SINGLE_SHOT_ROUNDS
+from constant_definitions.ext.market_constants import (
+    COURNOT_DEMAND_INTERCEPT, COURNOT_DEMAND_SLOPE, COURNOT_MARGINAL_COST,
+    COURNOT_MAX_QUANTITY,
+    BERTRAND_MAX_PRICE, BERTRAND_MARGINAL_COST, BERTRAND_MARKET_SIZE,
+    HOTELLING_LINE_LENGTH, HOTELLING_TRANSPORT_COST, HOTELLING_MARKET_VALUE,
+    ED_MONOPOLY_PROFIT, ED_DUOPOLY_PROFIT, ED_FIGHT_COST,
+    ED_ENTRANT_FIGHT_LOSS, ED_STAY_OUT_PAYOFF,
+    ND_SURPLUS, DA_BUYER_VALUE, DA_SELLER_COST, DA_MAX_PRICE,
+)
+
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+_ZERO_F = float()
+
+
+def _cournot_payoff(pa: str, oa: str) -> tuple[float, float]:
+    q_p = int(pa.rsplit("_", _ONE)[_ONE])
+    q_o = int(oa.rsplit("_", _ONE)[_ONE])
+    total = q_p + q_o
+    price = COURNOT_DEMAND_INTERCEPT - COURNOT_DEMAND_SLOPE * total
+    return (float((price - COURNOT_MARGINAL_COST) * q_p),
+            float((price - COURNOT_MARGINAL_COST) * q_o))
+
+
+def _bertrand_payoff(pa: str, oa: str) -> tuple[float, float]:
+    p_p = int(pa.rsplit("_", _ONE)[_ONE])
+    p_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if p_p < p_o:
+        demand = max(BERTRAND_MARKET_SIZE - p_p, int())
+        return (float((p_p - BERTRAND_MARGINAL_COST) * demand), _ZERO_F)
+    if p_o < p_p:
+        demand = max(BERTRAND_MARKET_SIZE - p_o, int())
+        return (_ZERO_F, float((p_o - BERTRAND_MARGINAL_COST) * demand))
+    demand = max(BERTRAND_MARKET_SIZE - p_p, int())
+    half_profit = float((p_p - BERTRAND_MARGINAL_COST) * demand) / _TWO
+    return (half_profit, half_profit)
+
+
+def _hotelling_payoff(pa: str, oa: str) -> tuple[float, float]:
+    loc_p = int(pa.rsplit("_", _ONE)[_ONE])
+    loc_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if loc_p == loc_o:
+        share = float(HOTELLING_MARKET_VALUE) / _TWO
+        return (share, share)
+    mid = (loc_p + loc_o) / _TWO
+    p_share = mid if loc_p < loc_o else float(HOTELLING_LINE_LENGTH) - mid
+    o_share = float(HOTELLING_LINE_LENGTH) - p_share
+    return (float(p_share * HOTELLING_TRANSPORT_COST),
+            float(o_share * HOTELLING_TRANSPORT_COST))
+
+
+_ED_MATRIX: dict[tuple[str, str], tuple[float, float]] = {
+    ("enter", "accommodate"): (float(ED_DUOPOLY_PROFIT), float(ED_DUOPOLY_PROFIT)),
+    ("enter", "fight"):       (float(ED_ENTRANT_FIGHT_LOSS), float(ED_FIGHT_COST)),
+    ("stay_out", "accommodate"): (float(ED_STAY_OUT_PAYOFF), float(ED_MONOPOLY_PROFIT)),
+    ("stay_out", "fight"):    (float(ED_STAY_OUT_PAYOFF), float(ED_MONOPOLY_PROFIT)),
+}
+
+
+def _nash_demand_payoff(pa: str, oa: str) -> tuple[float, float]:
+    d_p = int(pa.rsplit("_", _ONE)[_ONE])
+    d_o = int(oa.rsplit("_", _ONE)[_ONE])
+    if d_p + d_o <= ND_SURPLUS:
+        return (float(d_p), float(d_o))
+    return (_ZERO_F, _ZERO_F)
+
+
+def _double_auction_payoff(pa: str, oa: str) -> tuple[float, float]:
+    bid = int(pa.rsplit("_", _ONE)[_ONE])
+    ask = int(oa.rsplit("_", _ONE)[_ONE])
+    if bid >= ask:
+        price = (bid + ask) // _TWO
+        return (float(DA_BUYER_VALUE - price), float(price - DA_SELLER_COST))
+    return (_ZERO_F, _ZERO_F)
+
+
+_COURNOT_ACTS = [f"produce_{i}" for i in range(COURNOT_MAX_QUANTITY + _ONE)]
+_BERTRAND_ACTS = [f"price_{i}" for i in range(BERTRAND_MAX_PRICE + _ONE)]
+_HOTELLING_ACTS = [f"locate_{i}" for i in range(HOTELLING_LINE_LENGTH + _ONE)]
+_ND_ACTS = [f"demand_{i}" for i in range(ND_SURPLUS + _ONE)]
+_DA_ACTS = [f"bid_{i}" for i in range(DA_MAX_PRICE + _ONE)]
+
+OLIGOPOLY_GAMES: dict[str, GameConfig] = {
+    "cournot": GameConfig(
+        name="Cournot Duopoly",
+        description=(
+            "Two firms simultaneously choose production quantities. "
+            "Market price decreases with total output. Tests Nash "
+            "equilibrium reasoning in quantity competition."
+        ),
+        actions=_COURNOT_ACTS, game_type="cournot",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_cournot_payoff,
+    ),
+    "bertrand": GameConfig(
+        name="Bertrand Competition",
+        description=(
+            "Two firms simultaneously set prices. The lower-price firm "
+            "captures the market. The Bertrand paradox predicts pricing "
+            "at marginal cost even with only two competitors."
+        ),
+        actions=_BERTRAND_ACTS, game_type="bertrand",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_bertrand_payoff,
+    ),
+    "hotelling": GameConfig(
+        name="Hotelling Location Game",
+        description=(
+            "Two firms choose locations on a line. Consumers visit the "
+            "nearest firm. Tests the principle of minimum differentiation "
+            "and spatial competition dynamics."
+        ),
+        actions=_HOTELLING_ACTS, game_type="hotelling",
+        default_rounds=DEFAULT_NUM_ROUNDS, payoff_fn=_hotelling_payoff,
+    ),
+    "entry_deterrence": GameConfig(
+        name="Entry Deterrence",
+        description=(
+            "A potential entrant decides whether to enter a market; "
+            "the incumbent decides whether to fight or accommodate. "
+            "Tests credible commitment and limit pricing reasoning."
+        ),
+        actions=["enter", "stay_out"], game_type="matrix",
+        default_rounds=DEFAULT_NUM_ROUNDS,
+        payoff_fn=_matrix_payoff_fn(_ED_MATRIX),
+    ),
+    "nash_demand": GameConfig(
+        name="Nash Demand Game",
+        description=(
+            "Two players simultaneously demand shares of a surplus. "
+            "If demands are compatible (sum within surplus), both "
+            "receive their demand; otherwise both get nothing."
+        ),
+        actions=_ND_ACTS, game_type="nash_demand",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_nash_demand_payoff,
+    ),
+    "double_auction": GameConfig(
+        name="Double Auction",
+        description=(
+            "A buyer submits a bid and a seller submits an ask. Trade "
+            "occurs at the midpoint if bid exceeds ask. Tests price "
+            "discovery and competitive market behavior."
+        ),
+        actions=_DA_ACTS, game_type="double_auction",
+        default_rounds=SINGLE_SHOT_ROUNDS, payoff_fn=_double_auction_payoff,
+    ),
+}
+
+GAMES.update(OLIGOPOLY_GAMES)