feat: add live replays and PostgreSQL maintenance tools

- Stream compact live replay updates across local and clustered dashboards.
- Render responsive snake bodies as SVG paths with aligned custom icons.
- Add cache-busted assets, replay fallback routes, and live-follow playback.
- Support PostgreSQL benchmark sampling and idempotent SQLite migration.
- Add dry-run cleanup for old low-quality PostgreSQL replay payloads.
- Reward safe perimeter lanes and bump Prism to version 1.5.0.
- Add backend, migration, dashboard, and perimeter regression coverage.

server/database/backend/PostgresqlGameplayBackend.py

@@ -12,7 +12,7 @@ Connection: pass a DSN via the `dsn` constructor argument, e.g.
 or set GAMEPLAY_DB_PG_DSN in the environment.
 """
 
-import asyncio, json, logging, sqlite3, sys
+import asyncio, logging, sqlite3, json, sys
 from datetime import datetime, timezone
 from pathlib import Path
 from urllib.parse import urlparse, urlunparse
@@ -263,11 +263,20 @@ class PostgresqlGameplayBackend(GameplayBackendTemplate):
     conn.row_factory = sqlite3.Row
 
     try:
-      games = conn.execute("""
+      game_columns = {
+        row["name"] for row in conn.execute("PRAGMA table_info(games)").fetchall()
+      }
+      if "winner_name" in game_columns:
+        winner_name_expression = "winner_name"
+      elif "winner_names_json" in game_columns:
+        winner_name_expression = "winner_names_json"
+      else:
+        winner_name_expression = "NULL"
+      games = conn.execute(f"""
         SELECT game_id, started_at, ended_at, width, height, source, map_name,
           ruleset_name, ruleset_version, your_snake_id, your_snake_name,
           your_snake_type, your_snake_version, game_type,
-          winner_names_json, winner_you, final_turn, status
+          {winner_name_expression} AS winner_name, winner_you, final_turn, status
         FROM games
         ORDER BY started_at ASC
       """).fetchall()
@@ -301,6 +310,15 @@ class PostgresqlGameplayBackend(GameplayBackendTemplate):
     except (json.JSONDecodeError, TypeError):
       return None
 
+  def _migrated_winner_name(self, value:str|None) -> str|None:
+    """Accept both the current winner_name and legacy winner_names_json value."""
+    if not value:
+      return None
+    parsed = self._parse_json(value)
+    if isinstance(parsed, list):
+      return next((str(name) for name in parsed if name), None)
+    return value
+
   async def _insert_migrated_data(self, games:list, turns:list, snake_turns:list) -> None:
     assert self._pool is not None
     async with self._pool.acquire() as conn:
@@ -332,7 +350,7 @@ class PostgresqlGameplayBackend(GameplayBackendTemplate):
               row["your_snake_type"],
               row["your_snake_version"],
               row["game_type"],
-              (self._parse_json(row["winner_names_json"]) or [None])[0],
+              self._migrated_winner_name(row["winner_name"]),
               bool(row["winner_you"]),
               row["final_turn"],
               row["status"],

server/database/benchmark_states.py

@@ -0,0 +1,111 @@
+"""Load sampled gameplay positions from SQLite or PostgreSQL."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from urllib.parse import urlparse
+
+def is_postgresql_source(source: str) -> bool:
+  return urlparse(source).scheme.lower() in {"postgres", "postgresql"}
+
+def _decode_json(value, default):
+  if value is None:
+    return default
+  if isinstance(value, str):
+    return json.loads(value)
+  return value
+
+def _build_state(row, snake_rows) -> tuple[dict, dict] | None:
+  board = _decode_json(row[1], {})
+  you = _decode_json(row[2], {})
+  if not board.get("snakes"):
+    snakes = []
+    for snake_row in snake_rows:
+      snake_id = snake_row[0]
+      snake_name = snake_row[1] or (row[6] if snake_id == row[5] else snake_id)
+      snakes.append({
+        "id": snake_id,
+        "name": snake_name,
+        "health": snake_row[2],
+        "length": snake_row[3],
+        "head": {"x": snake_row[4], "y": snake_row[5]},
+        "body": _decode_json(snake_row[6], []),
+        "customizations": _decode_json(snake_row[7], {}),
+      })
+    board = {
+      "width": row[7],
+      "height": row[8],
+      "food": _decode_json(row[3], []),
+      "hazards": _decode_json(row[4], []),
+      "snakes": snakes,
+    }
+  if not you:
+    you = next(
+      (snake for snake in board.get("snakes", []) if snake.get("id") == row[5]),
+      {},
+    )
+  if not you or not board.get("snakes"):
+    return None
+  return board, {
+    "you": you,
+    "game_id": row[9],
+    "source": row[10] or "custom",
+    "map": row[11] or "standard",
+    "ruleset": {
+      "name": row[12] or "standard",
+      "version": row[13] or "v1.0.0",
+      "settings": {},
+    },
+    "turn": int(row[14]),
+  }
+
+async def _load_postgresql_states(dsn: str, samples: int, stride: int) -> list[tuple[dict, dict]]:
+  try:
+    import asyncpg
+  except ImportError as exc:
+    raise RuntimeError("asyncpg is required for PostgreSQL benchmark sources") from exc
+
+  connection = await asyncpg.connect(dsn=dsn)
+  try:
+    max_id = int(await connection.fetchval("SELECT max(id) FROM turns") or 0)
+    if max_id == 0:
+      return []
+    query = """
+      SELECT t.id, t.board_state, t.you, t.food, t.hazards,
+             g.your_snake_id, g.your_snake_name, g.width, g.height,
+             g.game_id, g.source, g.map_name,
+             g.ruleset_name, g.ruleset_version, t.turn
+      FROM turns AS t
+      JOIN games AS g ON g.game_id = t.game_id
+      WHERE t.id >= $1
+      ORDER BY t.id
+      LIMIT 1
+    """
+    snake_query = """
+      SELECT st.snake_id, COALESCE(gs.snake_name, st.snake_name),
+             st.health, st.length, st.head_x, st.head_y, st.body,
+             COALESCE(gs.customizations, '{}'::jsonb)
+      FROM snake_turns AS st
+      LEFT JOIN game_snakes AS gs
+        ON gs.game_id = st.game_id AND gs.snake_id = st.snake_id
+      WHERE st.game_id = $1 AND st.turn = $2
+      ORDER BY st.id
+    """
+    states = []
+    next_id = max(1, max_id - (samples - 1) * stride)
+    while len(states) < samples and next_id <= max_id:
+      row = await connection.fetchrow(query, next_id)
+      if row is None:
+        break
+      snake_rows = await connection.fetch(snake_query, row[9], row[14])
+      state = _build_state(row, snake_rows)
+      if state is not None:
+        states.append(state)
+      next_id = int(row[0]) + stride
+    return states
+  finally:
+    await connection.close()
+
+def load_postgresql_states(dsn: str, samples: int, stride: int) -> list[tuple[dict, dict]]:
+  return asyncio.run(_load_postgresql_states(dsn, samples, stride))