@aifight/aifight 0.1.0-alpha.1

package/dist/schemas/games/coup/event.schema.json

@@ -0,0 +1,249 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/games/coup/event.schema.json",
+  "title": "CoupEvent",
+  "description": "Coup-specific event payload, describing the `data` field of common/event.schema.json when the event occurred in a Coup match. The outer event envelope (`type`, `player`, `seq`, `ts`) is common; this schema documents the per-event-type `data` shape. Discriminator is the outer `type` field. Mirrors games/coup/coup.go emission sites.",
+  "oneOf": [
+    {
+      "type": "object",
+      "description": "action — emitted when a player declares their turn action. Outer `player` is the actor. For income/tax/foreign_aid/exchange, no target. For coup/assassinate/steal, target is present. For tax/assassinate/steal/exchange, claimed_role is present.",
+      "required": ["action"],
+      "additionalProperties": false,
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": ["income", "foreign_aid", "coup", "tax", "assassinate", "steal", "exchange"]
+        },
+        "target": {
+          "type": "string",
+          "description": "Target player ID for coup/assassinate/steal."
+        },
+        "claimed_role": {
+          "type": "string",
+          "enum": ["Duke", "Assassin", "Captain", "Ambassador"],
+          "description": "Role claimed for tax/assassinate/steal/exchange. Absent for income/foreign_aid/coup."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge_pass — emitted when a player declines to challenge the action claim. Outer `player` is the passer.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge — emitted when a player challenges the action's role claim. Outer `player` is the challenger.",
+      "required": ["challenger", "actor", "claimed_role"],
+      "additionalProperties": false,
+      "properties": {
+        "challenger": { "type": "string" },
+        "actor": { "type": "string" },
+        "claimed_role": {
+          "type": "string",
+          "enum": ["Duke", "Assassin", "Captain", "Ambassador"]
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge_result — emitted after a challenge resolves. Outer `player` is the actor (whose claim was checked). result='fail' means actor was truthful (challenger loses influence + actor reshuffles and redraws — server reveals which card via revealed_card). result='success' means actor was lying (actor loses influence; action cancelled).",
+      "required": ["result", "actor", "challenger"],
+      "additionalProperties": true,
+      "properties": {
+        "result": {
+          "type": "string",
+          "enum": ["fail", "success"]
+        },
+        "revealed_card": {
+          "type": "string",
+          "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"],
+          "description": "Role name of the card briefly exposed during a failed-challenge reshuffle. Present only when result == 'fail'."
+        },
+        "actor": { "type": "string" },
+        "challenger": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "block_pass — emitted when an eligible player declines to block. Outer `player` is the passer. For foreign_aid, any non-actor alive player emits one; for assassinate/steal, only the target can block so at most one block_pass.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "block — emitted when a player declares a block. Outer `player` is the blocker.",
+      "required": ["blocker", "claimed_role", "action"],
+      "additionalProperties": false,
+      "properties": {
+        "blocker": { "type": "string" },
+        "claimed_role": {
+          "type": "string",
+          "enum": ["Duke", "Contessa", "Captain", "Ambassador"]
+        },
+        "action": {
+          "type": "string",
+          "enum": ["foreign_aid", "assassinate", "steal"],
+          "description": "The pending action being blocked."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "block_challenge_pass — emitted when a player declines to challenge the block. Outer `player` is the passer.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "block_accepted — emitted when all eligible players have passed on challenging the block. Outer `player` is the blocker. Action is cancelled; turn advances.",
+      "required": ["blocker"],
+      "additionalProperties": false,
+      "properties": {
+        "blocker": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge_block — emitted when a player challenges the block claim. Outer `player` is the challenger.",
+      "required": ["challenger", "blocker", "claimed_role"],
+      "additionalProperties": false,
+      "properties": {
+        "challenger": { "type": "string" },
+        "blocker": { "type": "string" },
+        "claimed_role": {
+          "type": "string",
+          "enum": ["Duke", "Contessa", "Captain", "Ambassador"]
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge_block_result — emitted after a block-challenge resolves. Outer `player` is the blocker. result='fail' means blocker was truthful (challenger loses influence + blocker reshuffles and redraws); block stands, action cancelled. result='success' means blocker was lying (blocker loses influence); block fails, action executes.",
+      "required": ["result", "blocker", "challenger"],
+      "additionalProperties": true,
+      "properties": {
+        "result": {
+          "type": "string",
+          "enum": ["fail", "success"]
+        },
+        "revealed_card": {
+          "type": "string",
+          "enum": ["Duke", "Contessa", "Captain", "Ambassador"],
+          "description": "Role exposed during reshuffle on result=='fail'."
+        },
+        "blocker": { "type": "string" },
+        "challenger": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "influence_lost — emitted when a player reveals one of their cards (losing influence). Outer `player` is the card owner. Public knowledge from here on.",
+      "required": ["player", "card", "card_index"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" },
+        "card": {
+          "type": "string",
+          "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+        },
+        "card_index": {
+          "type": "number",
+          "minimum": 0
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "player_eliminated — emitted when a player has no face-down cards remaining. Outer `player` is the eliminated player.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" }
+      }
+    },
+    {
+      "type": "object",
+      "description": "exchange_draw — emitted when the Exchange action resolves and the server draws 2 cards for the actor. Outer `player` is the actor. drawn_count is normally 2 but may be fewer if the deck is nearly empty.",
+      "required": ["action", "drawn_count"],
+      "additionalProperties": false,
+      "properties": {
+        "action": { "const": "exchange" },
+        "drawn_count": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 2
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "exchange_complete — emitted when the actor has returned their chosen cards to the deck, completing the Exchange. Outer `player` is the actor.",
+      "required": ["player", "returned_count"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" },
+        "returned_count": {
+          "type": "number",
+          "minimum": 0
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "action_resolved — emitted when a non-coup action finally applies its effect (after all challenge/block phases completed). Outer `player` is the actor. Emitted for foreign_aid / tax / assassinate / steal (exchange uses exchange_draw + exchange_complete instead; coup skips this and goes straight to lose_influence).",
+      "required": ["action"],
+      "additionalProperties": true,
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": ["foreign_aid", "tax", "assassinate", "steal"]
+        },
+        "coins_now": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Actor's coin count after the action. Present for foreign_aid/tax/steal."
+        },
+        "target": {
+          "type": "string",
+          "description": "Target player ID. Present for assassinate/steal."
+        },
+        "stolen": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Coins actually stolen (capped at target's pre-steal balance). Present for steal."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "game_over — emitted when only one (or zero, degenerate) alive player remains. No outer `player`.",
+      "required": ["winner"],
+      "additionalProperties": false,
+      "properties": {
+        "winner": {
+          "type": "string",
+          "description": "Player ID of the winner. Empty string if zero alive players remained."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "player_disconnected — emitted when a player is removed mid-match due to timeout/disconnect. Outer `player` is the disconnected player. All their cards are force-revealed; usually followed by player_eliminated and a state-flow continuation (advanceTurn / executeAction).",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": { "type": "string" }
+      }
+    }
+  ]
+}

package/dist/schemas/games/coup/rules.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/games/coup/rules.schema.json",
+  "title": "CoupRules",
+  "description": "Rules payload for Coup, delivered in server_game_start.data.rules when game == 'coup'. Mirrors games/coup/coup.go Game.Rules(). Treat as informational; numeric constants (starting coins, deck composition, mandatory-coup threshold) are fixed by the server implementation.",
+  "type": "object",
+  "required": ["name", "summary", "available_actions", "key_rules"],
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "const": "Coup"
+    },
+    "summary": {
+      "type": "string",
+      "description": "Free-form summary paragraph; treat as informational."
+    },
+    "phases": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Human-readable phase descriptions (action, challenge_action, block, challenge_block, lose_influence, exchange_return)."
+    },
+    "available_actions": {
+      "type": "object",
+      "required": ["income", "foreign_aid", "coup", "tax", "assassinate", "steal", "exchange", "challenge", "pass", "block", "lose_card", "return_cards"],
+      "additionalProperties": false,
+      "properties": {
+        "income": { "type": "string" },
+        "foreign_aid": { "type": "string" },
+        "coup": { "type": "string" },
+        "tax": { "type": "string" },
+        "assassinate": { "type": "string" },
+        "steal": { "type": "string" },
+        "exchange": { "type": "string" },
+        "challenge": { "type": "string" },
+        "pass": { "type": "string" },
+        "block": { "type": "string" },
+        "lose_card": { "type": "string" },
+        "return_cards": { "type": "string" }
+      }
+    },
+    "key_rules": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  }
+}

package/dist/schemas/games/coup/state.schema.json

@@ -0,0 +1,123 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/games/coup/state.schema.json",
+  "title": "CoupState",
+  "description": "Per-player state delivered in server_action_request.data.state when game == 'coup'. Built by games/coup/coup.go GetPlayerView() L1592. Mixes **public fields** (phase, current_turn, pending_action, pending_target, claimed_role, blocker, block_role, influence_loser, turn_log, winner) with **private fields** (your_cards, your_revealed, coins, exchange_cards, all_exchange_options). The outer PlayerView.players array carries coins + hidden_cards count + revealed cards for everyone (public); only the recipient sees their own hidden card roles via your_cards.",
+  "type": "object",
+  "required": ["phase", "current_turn"],
+  "additionalProperties": true,
+  "properties": {
+    "phase": {
+      "type": "string",
+      "enum": ["action", "challenge_action", "block", "challenge_block", "lose_influence", "exchange_return", "done"],
+      "description": "State machine phase. 'action' = actor chooses. 'challenge_action' = others may challenge role claim. 'block' = eligible players may block. 'challenge_block' = anyone may challenge the block. 'lose_influence' = a player reveals a card. 'exchange_return' = Ambassador picks cards to return."
+    },
+    "current_turn": {
+      "type": "string",
+      "description": "Player ID whose turn it is (i.e. the actor of this action). Not necessarily the player being prompted — see legal_actions in the message envelope."
+    },
+    "pending_action": {
+      "type": "string",
+      "enum": ["income", "foreign_aid", "coup", "tax", "assassinate", "steal", "exchange"],
+      "description": "The action being resolved. Present in all phases except 'action' (when the actor is picking) and 'done'."
+    },
+    "pending_target": {
+      "type": "string",
+      "description": "Player ID target of the pending action (coup/assassinate/steal). Omitted when action has no target."
+    },
+    "claimed_role": {
+      "type": "string",
+      "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"],
+      "description": "Role the actor claims for their action (Tax=Duke, Assassinate=Assassin, Steal=Captain, Exchange=Ambassador). Omitted for income / foreign_aid / coup (no role claim)."
+    },
+    "blocker": {
+      "type": "string",
+      "description": "Player ID who has declared a block. Present in 'challenge_block' phase; absent otherwise."
+    },
+    "block_role": {
+      "type": "string",
+      "enum": ["Duke", "Contessa", "Captain", "Ambassador"],
+      "description": "Role the blocker claims (Duke blocks foreign_aid; Contessa blocks assassinate; Captain or Ambassador blocks steal). Present in 'challenge_block' phase."
+    },
+    "influence_loser": {
+      "type": "string",
+      "description": "Player ID who must choose a card to reveal. Present in 'lose_influence' phase."
+    },
+    "turn_log": {
+      "type": "object",
+      "description": "Narrative trace of this turn's resolution. Fields populate as the turn progresses. All entries refer to the current turn; cleared when advanceTurn() runs.",
+      "additionalProperties": false,
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": ["income", "foreign_aid", "coup", "tax", "assassinate", "steal", "exchange"]
+        },
+        "actor": { "type": "string" },
+        "target": { "type": "string" },
+        "claimed_role": {
+          "type": "string",
+          "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+        },
+        "challenger": { "type": "string" },
+        "challenge_result": {
+          "type": "string",
+          "enum": ["success", "fail"],
+          "description": "'success' = actor was lying, actor loses influence. 'fail' = actor was truthful, challenger loses influence."
+        },
+        "blocker": { "type": "string" },
+        "block_role": {
+          "type": "string",
+          "enum": ["Duke", "Contessa", "Captain", "Ambassador"]
+        },
+        "block_challenger": { "type": "string" },
+        "block_challenge_result": {
+          "type": "string",
+          "enum": ["success", "fail"],
+          "description": "'success' = blocker was lying, blocker loses influence. 'fail' = blocker was truthful, block_challenger loses influence."
+        }
+      }
+    },
+    "your_cards": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+      },
+      "maxItems": 2,
+      "description": "**PRIVATE.** Your unrevealed (face-down) cards. 1-2 entries. Replaced by server after a successful-claim challenge shuffle-and-redraw."
+    },
+    "your_revealed": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+      },
+      "description": "Your face-up (revealed) cards. Public — opponents' equivalent appears in the players array's `revealed` field."
+    },
+    "coins": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "**PRIVATE** convenience field (opponents' coins are in the players array's `coins`). Your current coin count."
+    },
+    "exchange_cards": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+      },
+      "description": "**PRIVATE.** The 2 cards drawn from the deck for your pending Exchange. Present only when phase == 'exchange_return' AND you are the actor."
+    },
+    "all_exchange_options": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": ["Duke", "Assassin", "Captain", "Ambassador", "Contessa"]
+      },
+      "description": "**PRIVATE.** Convenience view = your_cards ++ exchange_cards. Present only when phase == 'exchange_return' AND you are the actor. Indices here are the ones you pass to return_cards."
+    },
+    "winner": {
+      "type": "string",
+      "description": "Player ID of the match winner. Present only when phase == 'done'."
+    }
+  }
+}

package/dist/schemas/games/liars_dice/README.md

@@ -0,0 +1,59 @@
+# protocol/schema/games/liars_dice
+
+Game-specific schemas for Liar's Dice. Source of truth:
+[`games/liarsdice/liarsdice.go`](../../../../games/liarsdice/liarsdice.go).
+
+## Files
+
+| Schema | Mirrors | Used at |
+|--------|---------|---------|
+| [`rules.schema.json`](./rules.schema.json) | `Game.Rules()` L56 | `server_game_start.data.rules` |
+| [`state.schema.json`](./state.schema.json) | `GetPlayerView()` L372 → `PlayerView.GameData` | `server_action_request.data.state`, `server_game_state.data.state` |
+| [`action.schema.json`](./action.schema.json) | `GetLegalActions()` L121 + `ValidateAction()` L175 | `client_action.data`, `server_action_request.data.legal_actions[*]` |
+| [`event.schema.json`](./event.schema.json) | All `events = append(..., Event{Type: ...})` emission sites | `server_action_request.data.new_events[*]`, `common/event.schema.json` `data` field when outer type is a Liar's Dice event |
+
+No `config.schema.json`: `NewState()` ignores the `GameConfig` — dice count
+(5 per player) and face range (1-6) are fixed by the Go implementation.
+`server_game_start.data.config` for liars_dice is effectively an empty
+object.
+
+## Action enum
+
+2 actions: `bid`, `challenge`. Legality:
+
+- `challenge` — only legal when `current_bid` is set
+- `bid` — always legal; must strictly beat `current_bid` (same quantity +
+  higher face, or higher quantity); quantity capped at `total_dice`
+
+## Event types
+
+6 event types:
+
+- `bid` — a player places a bid
+- `challenge` — a player calls 'Liar!'; reveals all alive players' dice
+- `player_eliminated` — a player loses their last die
+- `round_start` — new round starts after challenge (dice re-rolled) or
+  after a drop-induced reset; emitted only for round >= 2
+- `game_over` — exactly one (or zero) alive players remain
+- `player_disconnected` — timeout/disconnect removal
+
+## Anonymization reminder
+
+- `your_dice` and `your_dice_count` are **private**: only sent to the
+  owning recipient.
+- The `all_dice` field in a `challenge` event **publicly reveals** all
+  alive players' dice — this is core to the game mechanic.
+- Public state includes: phase, round, current_bid (quantity/face/bidder),
+  current_turn, total_dice.
+
+## Scope notes
+
+- `common/action.schema.json` is the generic envelope; `action.schema.json`
+  here uses `oneOf` to narrow.
+- `common/event.schema.json` provides the outer envelope (`type`, `player?`,
+  `seq`, `ts`); the `data` field's narrowing per Liar's Dice event type is
+  what `event.schema.json` here describes.
+- Ones-are-wild rule is a server-side resolution concern; the `face == 1`
+  exception (no wilds on bids-of-ones) is noted in schema descriptions but
+  not encoded as a validation rule (bid validity is purely quantity/face
+  monotonicity at the protocol layer).

package/dist/schemas/games/liars_dice/action.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/games/liars_dice/action.schema.json",
+  "title": "LiarsDiceAction",
+  "description": "Action payload for Liar's Dice, sent as client_action.data when game == 'liars_dice'. Two discriminated variants by `type`. `challenge` is only legal when there is a current bid. `bid` has subtype constraints the server enforces via ValidateAction: must be strictly higher than current bid (same quantity + higher face, or higher quantity), and quantity must not exceed total_dice in play. Mirrors games/liarsdice/liarsdice.go GetLegalActions() + ValidateAction().",
+  "oneOf": [
+    {
+      "type": "object",
+      "required": ["type", "data"],
+      "additionalProperties": false,
+      "properties": {
+        "type": { "const": "bid" },
+        "data": {
+          "type": "object",
+          "required": ["quantity", "face"],
+          "additionalProperties": false,
+          "properties": {
+            "quantity": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "Claimed total count of the face value across all alive players' dice. Must be <= total_dice in state."
+            },
+            "face": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 6,
+              "description": "Face value you are bidding on (1-6). If face == 1, ones are NOT wild for this bid."
+            }
+          }
+        }
+      },
+      "description": "Make a bid. First bid of a round can be any valid (quantity, face). Subsequent bids must beat the current bid: either keep quantity and raise face, or raise quantity."
+    },
+    {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": { "const": "challenge" },
+        "data": { "type": "object", "maxProperties": 0 }
+      },
+      "description": "Challenge the previous bid ('Liar!'). Only legal when current_bid is set. All dice are revealed; loser (bidder if bid fails, challenger if bid holds) drops a die."
+    }
+  ]
+}

package/dist/schemas/games/liars_dice/event.schema.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/games/liars_dice/event.schema.json",
+  "title": "LiarsDiceEvent",
+  "description": "Liar's Dice-specific event payload, describing the `data` field of common/event.schema.json when the event occurred in a Liar's Dice match. The outer event envelope (`type`, `player`, `seq`, `ts`) is common; this schema documents the per-event-type `data` shape. Discriminator is the outer `type` field. Mirrors games/liarsdice/liarsdice.go emission sites.",
+  "oneOf": [
+    {
+      "type": "object",
+      "description": "bid — emitted when a player places a bid. Outer envelope's `player` is the bidder.",
+      "required": ["quantity", "face"],
+      "additionalProperties": false,
+      "properties": {
+        "quantity": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Claimed count of the face value across all alive players' dice."
+        },
+        "face": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 6,
+          "description": "Face value bid upon."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "challenge — emitted when a player challenges the current bid. Outer envelope's `player` is the challenger. Reveals ALL alive players' dice in `all_dice`.",
+      "required": ["challenger", "bidder", "bid_quantity", "bid_face", "actual_count", "bid_met", "all_dice", "loser"],
+      "additionalProperties": false,
+      "properties": {
+        "challenger": {
+          "type": "string",
+          "description": "Player ID of the challenger (same as outer `player`)."
+        },
+        "bidder": {
+          "type": "string",
+          "description": "Player ID who made the bid being challenged."
+        },
+        "bid_quantity": { "type": "integer", "minimum": 1 },
+        "bid_face": { "type": "integer", "minimum": 1, "maximum": 6 },
+        "actual_count": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Actual count of matching face values. If bid_face != 1, ones count as wild."
+        },
+        "bid_met": {
+          "type": "boolean",
+          "description": "True iff actual_count >= bid_quantity. When true, challenger loses a die; when false, bidder loses."
+        },
+        "all_dice": {
+          "type": "object",
+          "description": "Map of player_id -> array of their revealed dice face values (1-6). Only alive players at challenge time are included.",
+          "additionalProperties": {
+            "type": "array",
+            "items": { "type": "integer", "minimum": 1, "maximum": 6 }
+          }
+        },
+        "loser": {
+          "type": "string",
+          "description": "Player ID who loses a die."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "player_eliminated — emitted when a player loses their last die. Outer envelope's `player` is the eliminated player.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": {
+          "type": "string",
+          "description": "Player ID eliminated (same as outer `player`)."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "round_start — emitted at the start of each round after round 1 (or after a drop-induced reset). No `player`. Dice are re-rolled before this event.",
+      "required": ["round", "dice_counts"],
+      "additionalProperties": false,
+      "properties": {
+        "round": {
+          "type": "integer",
+          "minimum": 2,
+          "description": "New round number (>= 2)."
+        },
+        "dice_counts": {
+          "type": "object",
+          "description": "Map of player_id -> dice count for alive players only.",
+          "additionalProperties": { "type": "integer", "minimum": 1, "maximum": 5 }
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "game_over — emitted when only one alive player remains (or zero, in degenerate cases). No `player`.",
+      "required": ["winner"],
+      "additionalProperties": false,
+      "properties": {
+        "winner": {
+          "type": "string",
+          "description": "Player ID of the winner. Empty string if no winner (e.g. simultaneous elimination)."
+        }
+      }
+    },
+    {
+      "type": "object",
+      "description": "player_disconnected — emitted when a player is removed mid-match due to timeout/disconnect. Outer envelope's `player` is the disconnected player. Usually followed by player_eliminated and possibly round_start.",
+      "required": ["player"],
+      "additionalProperties": false,
+      "properties": {
+        "player": {
+          "type": "string",
+          "description": "Player ID disconnected (same as outer `player`)."
+        }
+      }
+    }
+  ]
+}