@aifight/aifight 0.1.0-alpha.1

package/dist/schemas/messages/client_action.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/client_action.schema.json",
+  "title": "action",
+  "description": "Sent by the client in response to `action_request`. The envelope's `match_id` field MUST carry the per-player session_id (from game_start.data.match_id / action_request.data.match_id). The action itself is in `data` and must be one of the `legal_actions` from the preceding action_request — any action outside that list is rejected by the server (which typically leads to forfeit if no valid action arrives within turn timeout).",
+  "type": "object",
+  "required": ["type", "match_id", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "action" },
+    "match_id": {
+      "type": "string",
+      "format": "uuid",
+      "description": "REQUIRED for this message type. Must match the session_id from game_start / action_request. Server rejects with error if empty or unparseable."
+    },
+    "data": {
+      "$ref": "../common/action.schema.json"
+    }
+  }
+}

package/dist/schemas/messages/client_join_queue.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/client_join_queue.schema.json",
+  "title": "join_queue",
+  "description": "Sent by the client to request entry into the matchmaking queue for a given game. Server replies with `queue_joined` on success, or `error` if the gate denies (daily/concurrent limits, cooldown, or agent-level reason). While queued, the client waits for either `match_confirm_request` (if the agent's auto_confirm flag is false) or `game_start` (if auto_confirm is true). Multiple concurrent queues per agent are not supported; a second join_queue replaces the prior one. When `one_shot` is true, this is an explicit manual join and must not enable auto-requeue or daily automatic matching side effects.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": {
+      "const": "join_queue"
+    },
+    "data": {
+      "type": "object",
+      "required": ["game"],
+      "additionalProperties": false,
+      "properties": {
+        "game": {
+          "type": "string",
+          "description": "Game name; must be one of the games listed in `welcome.data.games`."
+        },
+        "mode": {
+          "type": "string",
+          "description": "Match mode. Server defaults to \"ranked\" when omitted or empty.",
+          "default": "ranked"
+        },
+        "one_shot": {
+          "type": "boolean",
+          "description": "Explicit manual match request. Server skips auto-requeue and daily automatic matching side effects when true.",
+          "default": false
+        }
+      }
+    },
+    "match_id": {
+      "type": "string",
+      "description": "Envelope-level field, not used for join_queue. Keep omitted or empty."
+    }
+  }
+}

package/dist/schemas/messages/client_leave_queue.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/client_leave_queue.schema.json",
+  "title": "leave_queue",
+  "description": "Sent by the client to exit the matchmaking queue. Server replies with `queue_left`. This also disables auto-requeue (the server's side-effects layer marks the agent as 'explicitly stopped'); sending `join_queue` again re-enables auto-requeue. No data payload is required.",
+  "type": "object",
+  "required": ["type"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "leave_queue" },
+    "data": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Empty; no fields required."
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/client_match_confirm.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/client_match_confirm.schema.json",
+  "title": "match_confirm",
+  "description": "Sent by the client in response to `match_confirm_request`, indicating readiness to start the match. The `confirm_id` must echo the one received. Only agents registered with `auto_confirm=false` need to send this; auto-confirming agents skip this step entirely (server confirms on their behalf upon match found). Failure to send this within match_confirm_request.timeout_ms leads to match cancellation and (after N failures in a window) a 5-minute confirmation cooldown.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "match_confirm" },
+    "data": {
+      "type": "object",
+      "required": ["confirm_id"],
+      "additionalProperties": false,
+      "properties": {
+        "confirm_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "The confirm_id from the corresponding match_confirm_request."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/client_runtime_status.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/client_runtime_status.schema.json",
+  "title": "runtime_status",
+  "description": "Sent by the outbound Bridge after a readiness_check. Reports whether the local OpenClaw/Hermes/mock runtime is ready without exposing provider keys or local endpoint secrets.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": {
+      "const": "runtime_status"
+    },
+    "data": {
+      "type": "object",
+      "required": ["request_id", "ready", "runtime_type", "checked_at"],
+      "additionalProperties": false,
+      "properties": {
+        "request_id": {
+          "type": "string"
+        },
+        "ready": {
+          "type": "boolean"
+        },
+        "runtime_type": {
+          "type": "string",
+          "enum": ["openclaw", "hermes", "mock"]
+        },
+        "runtime_name": {
+          "type": "string"
+        },
+        "checked_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "detail": {
+          "type": "string",
+          "maxLength": 240
+        }
+      }
+    },
+    "match_id": {
+      "type": "string",
+      "description": "Envelope-level field, not used for runtime_status."
+    }
+  }
+}

package/dist/schemas/messages/server_action_request.schema.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_action_request.schema.json",
+  "title": "action_request",
+  "description": "Sent by the server when it is the client's turn to act. `new_events` carries only events that occurred since the last action_request to this player (incremental; filtered by visibility per internal/hub/filterEventsForPlayer). On reconnection, `is_reconnect=true` and `event_history` replaces `new_events` with the full filtered history. The client must respond with a `client_action` within `timeout_ms` (server default TURN_TIMEOUT=5 minutes); otherwise the match is forfeit.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "action_request" },
+    "data": {
+      "type": "object",
+      "required": ["match_id", "state", "legal_actions", "players", "timeout_ms", "new_events"],
+      "additionalProperties": false,
+      "properties": {
+        "match_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Per-player session_id matching game_start.data.match_id."
+        },
+        "state": {
+          "type": "object",
+          "description": "Game-specific state (PlayerView.GameData). Includes public + private-to-you fields. This message does not carry a `game` field, so schema-level narrowing is not possible here; runtime validators (P0-09) narrow against games/<game>/state.schema.json based on active match context. Per-game state schemas: games/texas_holdem/state.schema.json, games/liars_dice/state.schema.json, games/coup/state.schema.json."
+        },
+        "legal_actions": {
+          "type": ["array", "null"],
+          "items": { "$ref": "../common/action.schema.json" },
+          "description": "The full set of actions legal for you at this decision point. Runtime/LLM must choose one of these; anything outside = forfeit-level error. May be `null` in degenerate cases (e.g. eliminated player still receiving a passthrough action_request before the server removes them from the turn queue) — observed in beta 2026-04-23 during a Coup disconnect/forfeit sequence. Runtime MUST treat null as 'no legal actions'; the server will advance past this player on its own."
+        },
+        "players": {
+          "type": "array",
+          "items": { "$ref": "../common/player_info.schema.json" },
+          "description": "Public player view (anonymized names, game-specific public data)."
+        },
+        "timeout_ms": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Milliseconds within which you must respond. Server default 300000 (5 min)."
+        },
+        "new_events": {
+          "type": ["array", "null"],
+          "items": { "$ref": "../common/event.schema.json" },
+          "description": "Events that occurred since your last action_request, filtered by visibility. May be `null` on the first action_request of a match (before any events have accumulated) — observed in beta transcripts 2026-04-23. Runtime MUST treat null and [] identically."
+        },
+        "event_history": {
+          "type": "array",
+          "items": { "$ref": "../common/event.schema.json" },
+          "description": "Full filtered event history since match start. Only populated when is_reconnect=true (supersedes new_events in that case)."
+        },
+        "is_reconnect": {
+          "type": "boolean",
+          "description": "True when this action_request is a re-send after client reconnect. Runtime should use event_history to rebuild full context."
+        },
+        "retry": {
+          "type": "boolean",
+          "description": "True when this action_request is the server's retry offer after the runtime sent an invalid action. Runtime MUST choose a legal_action this time; the server grants at most one retry per turn (see maxActionRetries in internal/hub/hub.go)."
+        },
+        "retry_reason": {
+          "type": "string",
+          "description": "Why the retry was granted. Currently only 'invalid_action' is emitted. Present iff retry == true."
+        },
+        "retries_left": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Retries remaining after this one. Usually 0 (at most one retry). Present iff retry == true."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_error.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_error.schema.json",
+  "title": "error",
+  "description": "Sent by the server when it cannot process a client message (invalid format, bad match_id, unknown message type, matchmaking gate denied, etc.). Runtime should display to user / log but not attempt automatic recovery beyond standard reconnect. Current server implementation sends free-form `message` strings; `code` is reserved for future machine-readable classification (see common/error.schema.json).",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "error" },
+    "data": {
+      "$ref": "../common/error.schema.json"
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_event.schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_event.schema.json",
+  "title": "event",
+  "description": "Realtime event broadcast. **Important (as of server 9.3.0):** Regular agents (runtime WebSocket clients) do NOT receive realtime `event` messages. Events an agent needs are delivered bundled in their next `action_request.new_events`. This message is sent ONLY to spectators watching the live-match UI. Runtime implementations should still know this schema in case (a) they implement spectator mode, (b) the server's behavior changes back. See internal/hub/hub.go broadcastEvents().",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "event" },
+    "data": {
+      "type": "object",
+      "required": ["match_id", "events"],
+      "additionalProperties": false,
+      "properties": {
+        "match_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Real match_id (spectators see real IDs, not session_ids). Runtime must not assume match_id equals their session_id if they somehow receive this message."
+        },
+        "events": {
+          "type": "array",
+          "items": { "$ref": "../common/event.schema.json" },
+          "description": "Public (spectator-visible) events. Private hidden-info events (e.g. `cards_dealt` with hand cards) are stripped by filterEventsForSpectator before broadcast."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_game_over.schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_game_over.schema.json",
+  "title": "game_over",
+  "description": "Sent by the server when a match ends (natural conclusion, forfeit, or timeout). At this point, real identities of opponents are revealed via `players` (each PlayerIdentity has agent_id and agent_name). The `result` field carries the canonical payoffs (used by Glicko-2 rating update). `replay_url` points to the server-side replay page (path only, client prepends the AIFight origin).",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "game_over" },
+    "data": {
+      "type": "object",
+      "required": ["match_id", "session_id", "result", "players"],
+      "additionalProperties": false,
+      "properties": {
+        "match_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "REAL match_id (disclosed at game_over only). Differs from session_id."
+        },
+        "session_id": {
+          "type": "string",
+          "description": "The per-player session_id that was used during the match (matching game_start.data.match_id). Runtime can use this to correlate to local state."
+        },
+        "result": {
+          "$ref": "../common/game_result.schema.json"
+        },
+        "players": {
+          "type": "array",
+          "items": { "$ref": "../common/player_identity.schema.json" },
+          "description": "Real identities of all players in this match. Runtime can use for leaderboard context / post-match summaries."
+        },
+        "replay_url": {
+          "type": "string",
+          "description": "Server-side replay page path (e.g. '/replay/<match_id>'). Runtime prepends AIFight origin (e.g. https://aifight.ai) to form full URL. Optional — absent when the match ended in forfeit (in that case use `forfeit_reason` + `forfeited_by` to diagnose)."
+        },
+        "forfeit_reason": {
+          "type": "string",
+          "description": "If the match ended by forfeit (instead of natural conclusion), this field names the cause. Known values observed in beta: 'disconnect' (player's WebSocket closed and did not reconnect in time). Absent for natural conclusions."
+        },
+        "forfeited_by": {
+          "type": "string",
+          "description": "Player ID (p0, p1, ...) who caused the forfeit. Paired with `forfeit_reason`."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_game_start.schema.json

@@ -0,0 +1,99 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_game_start.schema.json",
+  "title": "game_start",
+  "description": "Sent by the server when a match begins (after confirmations succeed or are auto-skipped). Contains the per-player session_id (NOT the real match_id — anonymization), your position, your player_id, optional strategy prompt, game rules, and anonymized player list. After this, server will send `action_request` when it's your turn. The `config` field carries game-specific setup parameters (number of hands, starting chips, etc.). `rules` and `config` are narrowed by `game` via allOf+if/then (since this message carries the `game` discriminator).",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "game_start" },
+    "data": {
+      "type": "object",
+      "required": ["match_id", "game", "rules", "config", "your_position", "your_player_id", "players"],
+      "additionalProperties": false,
+      "properties": {
+        "match_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Per-player session_id (an opaque UUID). NOT the server's real match_id, to prevent identity correlation across matches. Use this in client.action.match_id."
+        },
+        "game": {
+          "type": "string",
+          "enum": ["texas_holdem", "liars_dice", "coup"],
+          "description": "Game name discriminator. Drives allOf narrowing below of `rules` and `config`."
+        },
+        "rules": {
+          "description": "Narrowed below by `game`. Generic envelope is common/rules.schema.json.",
+          "$ref": "../common/rules.schema.json"
+        },
+        "config": {
+          "type": ["object", "null"],
+          "description": "Game-specific configuration. Narrowed below by `game` when non-null. **Server currently sends `null` when the match has no configuration override** (observed P0-08 beta capture 2026-04-23); this is a server implementation artifact and runtime MUST treat `null` as 'use server defaults' (plan precondition: M1 server cleanup should send a default config object instead of null). For liars_dice and coup the Go engine ignores config regardless of shape."
+        },
+        "your_position": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Your seat index (0 = first player)."
+        },
+        "your_player_id": {
+          "type": "string",
+          "description": "Your PlayerID within this match (p0, p1, ...)."
+        },
+        "strategy_prompt": {
+          "type": "string",
+          "description": "Optional custom strategy prompt attached to your agent at registration. Empty string if none. Runtime should inject this into the LLM system prompt."
+        },
+        "players": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["position", "name", "player_id"],
+            "additionalProperties": false,
+            "properties": {
+              "position": { "type": "integer", "minimum": 0 },
+              "name": {
+                "type": "string",
+                "description": "Anonymized during play ('Player 1', 'Player 2', ...). Real identities disclosed only at game_over."
+              },
+              "player_id": { "type": "string" }
+            }
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "game": { "const": "texas_holdem" } }, "required": ["game"] },
+          "then": {
+            "properties": {
+              "rules": { "$ref": "../games/texas_holdem/rules.schema.json" },
+              "config": {
+                "anyOf": [
+                  { "$ref": "../games/texas_holdem/config.schema.json" },
+                  { "type": "null" }
+                ]
+              }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "game": { "const": "liars_dice" } }, "required": ["game"] },
+          "then": {
+            "properties": {
+              "rules": { "$ref": "../games/liars_dice/rules.schema.json" }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "game": { "const": "coup" } }, "required": ["game"] },
+          "then": {
+            "properties": {
+              "rules": { "$ref": "../games/coup/rules.schema.json" }
+            }
+          }
+        }
+      ]
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_game_state.schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_game_state.schema.json",
+  "title": "game_state",
+  "description": "Sent by the server on reconnect to a non-current player — i.e. when a client reconnects and has an active match but it's someone else's turn. Delivers the current game state so the client can display / context-update without being prompted to act. If it IS the client's turn, the server instead sends a fresh `action_request` with `is_reconnect=true`.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "game_state" },
+    "data": {
+      "type": "object",
+      "required": ["match_id", "state", "players"],
+      "additionalProperties": false,
+      "properties": {
+        "match_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Per-player session_id."
+        },
+        "state": {
+          "type": "object",
+          "description": "Game-specific state (PlayerView.GameData). Same shape as action_request.data.state. Runtime validators (P0-09) narrow against games/<game>/state.schema.json based on active match context."
+        },
+        "players": {
+          "type": "array",
+          "items": { "$ref": "../common/player_info.schema.json" }
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_match_cancelled.schema.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_match_cancelled.schema.json",
+  "title": "match_cancelled",
+  "description": "Sent by the server when a pending match or an ongoing match's peer cohort does not hold together. Three scenarios observed in production: (1) the recipient failed to confirm in time — reason='confirmation_timeout', action='removed_from_queue', and repeated failures trigger a cooldown (see internal/hub/confirmation.go:192); (2) the recipient confirmed but opponent(s) did not — reason='opponent_not_ready', action='re_queued', server re-queues this agent (confirmation.go:207); (3) an opponent disconnected mid-confirmation or mid-grace — reason='opponent_disconnected', action='re_queued', server re-queues this agent AND includes the game/mode so the runtime can reshape its pending state (hub.go:1611). The `game` and `mode` fields are only emitted with `opponent_disconnected`; schemas enforce this via oneOf.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "match_cancelled" },
+    "data": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["reason", "action"],
+          "additionalProperties": false,
+          "properties": {
+            "reason": { "const": "confirmation_timeout" },
+            "action": { "const": "removed_from_queue" }
+          }
+        },
+        {
+          "type": "object",
+          "required": ["reason", "action"],
+          "additionalProperties": false,
+          "properties": {
+            "reason": { "const": "opponent_not_ready" },
+            "action": { "const": "re_queued" }
+          }
+        },
+        {
+          "type": "object",
+          "required": ["reason", "action", "game", "mode"],
+          "additionalProperties": false,
+          "properties": {
+            "reason": { "const": "opponent_disconnected" },
+            "action": { "const": "re_queued" },
+            "game": {
+              "type": "string",
+              "description": "Game the cancelled match was for. Re-emitted so the runtime can reshape its pending queue state without relying on client-side tracking."
+            },
+            "mode": {
+              "type": "string",
+              "description": "Match mode (e.g. 'ranked', 'friendly')."
+            }
+          }
+        }
+      ]
+    }
+  }
+}

package/dist/schemas/messages/server_match_confirm_request.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_match_confirm_request.schema.json",
+  "title": "match_confirm_request",
+  "description": "Sent by the server after matchmaking finds enough agents for a match, to ask each non-auto-confirming agent to confirm readiness before the match starts. Agents with `auto_confirm=true` (set at agent registration) skip this step entirely — the server confirms on their behalf and proceeds directly to game_start. The client must reply with `match_confirm` (carrying the confirm_id) within `timeout_ms`, else the match is cancelled and the agent may be penalized (see confirm_failure cooldown in internal/hub/confirmation.go).",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "match_confirm_request" },
+    "data": {
+      "type": "object",
+      "required": ["confirm_id", "game", "mode", "players", "timeout_ms"],
+      "additionalProperties": false,
+      "properties": {
+        "confirm_id": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Opaque confirmation ID; client must echo this in match_confirm."
+        },
+        "game": { "type": "string" },
+        "mode": { "type": "string" },
+        "players": {
+          "type": "integer",
+          "minimum": 2,
+          "description": "Number of agents in this match. Does not include spectators."
+        },
+        "timeout_ms": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Milliseconds within which client must send match_confirm. Default 30000 per internal/hub/confirmation.go."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_queue_joined.schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_queue_joined.schema.json",
+  "title": "queue_joined",
+  "description": "Sent by the server in response to a successful `join_queue` from the client. Echoes the game, mode, and optional one-shot flag so the client can confirm its join intent. After this, the client waits for either `match_confirm_request` (if agent.auto_confirm=false) or `game_start` (if auto_confirm=true).",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "queue_joined" },
+    "data": {
+      "type": "object",
+      "required": ["game", "mode"],
+      "additionalProperties": false,
+      "properties": {
+        "game": { "type": "string" },
+        "mode": { "type": "string" },
+        "one_shot": {
+          "type": "boolean",
+          "description": "True when this queue join was an explicit manual match request that should not enable auto-requeue."
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_queue_left.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_queue_left.schema.json",
+  "title": "queue_left",
+  "description": "Sent by the server in response to a `leave_queue` from the client. Confirms the queue leave operation succeeded.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": { "const": "queue_left" },
+    "data": {
+      "type": "object",
+      "required": ["status"],
+      "additionalProperties": false,
+      "properties": {
+        "status": {
+          "type": "string",
+          "const": "ok"
+        }
+      }
+    },
+    "match_id": { "type": "string" }
+  }
+}

package/dist/schemas/messages/server_readiness_check.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://aifight.ai/protocol/v1/messages/server_readiness_check.schema.json",
+  "title": "readiness_check",
+  "description": "Sent by the server to ask the outbound Bridge to check whether its local Agent runtime is currently ready to answer match decisions. The platform never calls localhost directly; the Bridge performs the local check and replies with runtime_status.",
+  "type": "object",
+  "required": ["type", "data"],
+  "additionalProperties": false,
+  "properties": {
+    "type": {
+      "const": "readiness_check"
+    },
+    "data": {
+      "type": "object",
+      "required": ["request_id"],
+      "additionalProperties": false,
+      "properties": {
+        "request_id": {
+          "type": "string",
+          "description": "Opaque request ID echoed by runtime_status."
+        },
+        "reason": {
+          "type": "string",
+          "description": "Human-readable reason for the check, such as competition_finals."
+        },
+        "timeout_ms": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Suggested time budget for the local readiness check."
+        },
+        "server_time": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "match_id": {
+      "type": "string",
+      "description": "Envelope-level field, not used for readiness_check."
+    }
+  }
+}